Decompiled source of Emergency Dice Updated v1.14.1

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!

Decompiled source of Emergency Dice Updated v1.14.1

DicePoltergeistCompat.dll

Decompiled 2 weeks ago

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using DicePoltergeistCompat.NetcodePatcher;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using MysteryDice;
using MysteryDice.Dice;
using Poltergeist;
using Poltergeist.GhostInteractibles;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 DicePoltergeistCompat
{
	internal class DiceGhostInteractible : NetworkedInteractible
	{
		private DieBehaviour dice;

		protected override void DoSetup()
		{
			dice = ((Component)this).GetComponentInParent<DieBehaviour>();
		}

		public override float GetCost()
		{
			return Plugin.energyUsage.Value;
		}

		public override float Interact(Transform playerTransform)
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return 0f;
			}
			if (SpectatorCamController.instance.Power < ((NetworkedInteractible)this).GetCost())
			{
				return 0f;
			}
			if ((Object)(object)dice == (Object)null || dice.isRolling || !((GrabbableObject)dice).grabbable || StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded || (Object)(object)((GrabbableObject)dice).playerHeldBy != (Object)null)
			{
				return 0f;
			}
			RollDiceServerRpc(((NetworkBehaviour)dice).NetworkObject.NetworkObjectId, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, SpectatorCamController.instance.ClientPlayer));
			return ((NetworkedInteractible)this).GetCost();
		}

		[ServerRpc(RequireOwnership = true)]
		private void RollDiceServerRpc(ulong diceId, int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Invalid comparison between Unknown and I4
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3295779142u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, diceId);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3295779142u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(diceId, out var value))
			{
				DieBehaviour component = ((Component)value).GetComponent<DieBehaviour>();
				if (!((Object)(object)component == (Object)null) && !component.isRolling && ((GrabbableObject)component).grabbable && !((Object)(object)((GrabbableObject)component).playerHeldBy != (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerID];
					((MonoBehaviour)component).StartCoroutine(component.doStuff(7510501, val3));
				}
			}
		}

		public override string GetTipText()
		{
			return (SpectatorCamController.instance.Power < ((NetworkedInteractible)this).GetCost()) ? $"Not Enough Power ({((NetworkedInteractible)this).GetCost():F0})" : $"Roll Dice : [{PoltergeistCustomInputs.GetInteractString()}] ({((NetworkedInteractible)this).GetCost():F0})";
		}

		protected override void __initializeVariables()
		{
			((NetworkedInteractible)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3295779142u, new RpcReceiveHandler(__rpc_handler_3295779142), "RollDiceServerRpc");
			((NetworkedInteractible)this).__initializeRpcs();
		}

		private static void __rpc_handler_3295779142(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				ulong diceId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref diceId);
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGhostInteractible)(object)target).RollDiceServerRpc(diceId, playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "DiceGhostInteractible";
		}
	}
	[BepInPlugin("Slayer6409.DicePoltergeistCompat", "DicePoltergeistCompat", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static AssetBundle LoadedAssets;

		public static GameObject GhostInteractiblePrefab;

		private readonly Harmony harmony = new Harmony("Slayer6409.DicePoltergeistCompat");

		public static ConfigEntry<bool> poltergeistEnabled;

		public static ConfigEntry<float> energyUsage;

		private void Awake()
		{
			if (!Chainloader.PluginInfos.ContainsKey("coderCleric.Poltergeist"))
			{
				MysteryDice.CustomLogger.LogInfo((object)"Poltergeist not found disabling Poltergeist Compatability");
				return;
			}
			LoadedAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "mysterydicepoltergeistcompat"));
			GhostInteractiblePrefab = LoadedAssets.LoadAsset<GameObject>("GhostInteractiblePrefab");
			poltergeistEnabled = MysteryDice.BepInExConfig.Bind<bool>("Poltergeist", "Enabled", true, "If poltergeist compatability is enabled");
			if (poltergeistEnabled.Value)
			{
				energyUsage = MysteryDice.BepInExConfig.Bind<float>("Poltergeist", "Energy Usage", 51f, "How much energy it takes to roll dice");
				NetworkPrefabs.RegisterNetworkPrefab(GhostInteractiblePrefab);
				harmony.PatchAll();
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "DicePoltergeistCompat";

		public const string PLUGIN_NAME = "DicePoltergeistCompat";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace DicePoltergeistCompat.Patches
{
	[HarmonyPatch(typeof(DieBehaviour), "Start")]
	internal class DieBehaviourPatch
	{
		private static void Postfix(DieBehaviour __instance)
		{
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(Plugin.GhostInteractiblePrefab, ((Component)__instance).transform);
				val.GetComponent<NetworkObject>().Spawn(false);
				val.transform.parent = ((Component)__instance).transform;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace DicePoltergeistCompat.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}

DiceStrangerThingsIntegration.dll

Decompiled 2 weeks ago

Download (5.1 KB)

using System;
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.Bootstrap;
using DiceStrangerThingsIntegration.NetcodePatcher;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MoreCompany.Cosmetics;
using MysteryDice;
using StrangerThings.Registries;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("MysteryDice")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DiceStrangerThingsIntegration")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Twitch Integration for The Dice Mod")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DiceStrangerThingsIntegration")]
[assembly: AssemblyTitle("DiceStrangerThingsIntegration")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 DiceStrangerThingsIntegration
{
	[BepInPlugin("Slayer6409.DiceStrangerThingsIntegration", "Dice Stranger Things Integration", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private const string modGUID = "Slayer6409.DiceStrangerThingsIntegration";

		private const string modName = "Dice Stranger Things Integration";

		private const string modVersion = "1.0.0";

		private readonly Harmony harmony = new Harmony("Slayer6409.DiceStrangerThingsIntegration");

		private void Awake()
		{
			if (MysteryDice.TwitchEnabled.Value && Chainloader.PluginInfos.ContainsKey("Lega.StrangerThings"))
			{
				MysteryDice.CustomLogger.LogInfo((object)"Dice Stranger Things Integration has been loaded!");
				harmony.PatchAll();
			}
		}
	}
	public class StrangerThingsCompat
	{
		[HarmonyPatch]
		internal static class StrangerThingsScanNodePatch
		{
			[HarmonyPostfix]
			[HarmonyPatch(typeof(DimensionRegistry), "UpdateVisibilityState")]
			private static void UpdateVisibilityState_Postfix(GameObject entity)
			{
				try
				{
					if ((Object)(object)entity == (Object)null)
					{
						return;
					}
					PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
					if ((Object)(object)localPlayerController == (Object)null)
					{
						return;
					}
					bool flag = DimensionRegistry.AreInSameDimension(((Component)localPlayerController).gameObject, entity);
					PlayerControllerB value = default(PlayerControllerB);
					if (entity.gameObject.TryGetComponent<PlayerControllerB>(ref value) && Networker.Instance.scanNodesByPlayerIndex.TryGetValue(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, value), out var value2))
					{
						value2.SetActive(flag);
					}
					MaskedPlayerEnemy val = default(MaskedPlayerEnemy);
					if (entity.TryGetComponent<MaskedPlayerEnemy>(ref val))
					{
						if (Chainloader.PluginInfos.TryGetValue("me.swipez.melonloader.morecompany", out var _))
						{
							((Behaviour)((Component)((Component)val).transform).GetComponentInChildren<CosmeticApplication>()).enabled = flag;
						}
						if (Networker.Instance.MimicTrackers.TryGetValue(val, out var value4))
						{
							((Behaviour)value4).enabled = flag;
						}
					}
				}
				catch (Exception)
				{
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "DiceStrangerThingsIntegration";

		public const string PLUGIN_NAME = "DiceStrangerThingsIntegration";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace DiceStrangerThingsIntegration.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}

DiceTwitchIntegration.dll

Decompiled 2 weeks ago

Download (16.7 KB)

using System;
using System.Collections;
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.Bootstrap;
using BepInEx.Configuration;
using DiceTwitchIntegration.NetcodePatcher;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using Microsoft.CodeAnalysis;
using MysteryDice;
using MysteryDice.Effects;
using MysteryDice.Patches;
using TwitchChatAPI;
using TwitchChatAPI.Objects;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DiceTwitchIntegration")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Twitch Integration for The Dice Mod")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DiceTwitchIntegration")]
[assembly: AssemblyTitle("DiceTwitchIntegration")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 DiceTwitchIntegration
{
	public class ConfigManager
	{
		public static void SetupLethalConfig()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(TwitchHandler.enableSubs);
			IntInputFieldConfigItem val2 = new IntInputFieldConfigItem(TwitchHandler.cheerMin);
			IntInputFieldConfigItem val3 = new IntInputFieldConfigItem(TwitchHandler.cheerGood);
			IntInputFieldConfigItem val4 = new IntInputFieldConfigItem(TwitchHandler.cheerAwful);
			IntInputFieldConfigItem val5 = new IntInputFieldConfigItem(TwitchHandler.cheerGreat);
			IntInputFieldConfigItem val6 = new IntInputFieldConfigItem(TwitchHandler.cheerMixed);
			IntInputFieldConfigItem val7 = new IntInputFieldConfigItem(TwitchHandler.cheerBad);
			BoolCheckBoxConfigItem val8 = new BoolCheckBoxConfigItem(TwitchHandler.enableCheer);
			BoolCheckBoxConfigItem val9 = new BoolCheckBoxConfigItem(TwitchHandler.enableRaid);
			BoolCheckBoxConfigItem val10 = new BoolCheckBoxConfigItem(TwitchHandler.enableChatEvents);
			IntInputFieldConfigItem val11 = new IntInputFieldConfigItem(TwitchHandler.chattersMin);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val3);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val5);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val6);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val7);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val8);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val9);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val10);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val11);
		}
	}
	[BepInPlugin("Slayer6409.DiceTwitchIntegration", "Dice Twitch Integration", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private const string modGUID = "Slayer6409.DiceTwitchIntegration";

		private const string modName = "Dice Twitch Integration";

		private const string modVersion = "1.0.0";

		private readonly Harmony harmony = new Harmony("Slayer6409.DiceTwitchIntegration");

		public static bool LethalConfigPresent;

		private void Awake()
		{
			if (MysteryDice.TwitchEnabled.Value && Chainloader.PluginInfos.ContainsKey("com.github.zehsteam.TwitchChatAPI"))
			{
				if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
				{
					LethalConfigPresent = true;
				}
				MysteryDice.CustomLogger.LogInfo((object)"Dice Twitch Integration has been loaded!");
				TwitchHandler.doConfigStuff();
				TwitchHandler.Initialize();
				harmony.PatchAll();
				if (LethalConfigPresent)
				{
					ConfigManager.SetupLethalConfig();
				}
			}
		}
	}
	public class TwitchHandler
	{
		[CompilerGenerated]
		private sealed class <waitReset>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <waitReset>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					hasRan = true;
					Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch chatters:");
					<>2__current = (object)new WaitForSeconds(120f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					evnt = new HashSet<string>();
					hasRan = false;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static ConfigEntry<bool> enableSubs;

		public static ConfigEntry<bool> enableCheer;

		public static ConfigEntry<int> cheerMin;

		public static ConfigEntry<int> cheerGood;

		public static ConfigEntry<int> cheerGreat;

		public static ConfigEntry<int> cheerAwful;

		public static ConfigEntry<int> cheerBad;

		public static ConfigEntry<int> cheerMixed;

		public static ConfigEntry<bool> enableRaid;

		public static ConfigEntry<bool> enableChatEvents;

		public static ConfigEntry<int> chattersMin;

		public static HashSet<string> evnt = new HashSet<string>();

		public static bool hasRan = false;

		public static void Initialize()
		{
			try
			{
				API.OnMessage += OnMessageHandler;
				API.OnCheer += OnCheerHandler;
				API.OnSub += OnSubHandler;
				API.OnRaid += OnRaidHandler;
				Application.quitting += delegate
				{
					API.OnMessage -= OnMessageHandler;
					API.OnCheer -= OnCheerHandler;
					API.OnSub -= OnSubHandler;
					API.OnRaid -= OnRaidHandler;
				};
			}
			catch (Exception arg)
			{
				MysteryDice.CustomLogger.LogError((object)$"Failed to initialize TwitchIntegrationManager. {arg}");
			}
		}

		public static void doConfigStuff()
		{
			enableSubs = MysteryDice.BepInExConfig.Bind<bool>("Twitch", "Enable Sub", true, "If Twitch Subscription events are enabled");
			enableCheer = MysteryDice.BepInExConfig.Bind<bool>("Twitch", "Enable Cheer", true, "If Twitch Cheer events are enabled");
			enableChatEvents = MysteryDice.BepInExConfig.Bind<bool>("Twitch", "Enable Chat Events", true, "If Twitch Chat events are enabled ");
			chattersMin = MysteryDice.BepInExConfig.Bind<int>("Twitch", "Chatters Min", 5, "How many Chatters are required for an event to start");
			enableRaid = MysteryDice.BepInExConfig.Bind<bool>("Twitch", "Enable Raids", true, "If Twitch Raid events are enabled (Experimental so off by default)");
			cheerMin = MysteryDice.BepInExConfig.Bind<int>("Twitch", "Cheer Min", 50, "How many bits required before a dice event is triggered");
			cheerGreat = MysteryDice.BepInExConfig.Bind<int>("Twitch", "Cheer Great", 1, "The ones digit for spawning a Great Effect");
			cheerGood = MysteryDice.BepInExConfig.Bind<int>("Twitch", "Cheer Good", 2, "The ones digit for spawning a Good Effect");
			cheerMixed = MysteryDice.BepInExConfig.Bind<int>("Twitch", "Cheer Mixed", 3, "The ones digit for spawning a Mixed Effect");
			cheerBad = MysteryDice.BepInExConfig.Bind<int>("Twitch", "Cheer Bad", 4, "The ones digit for spawning a Bad Effect");
			cheerAwful = MysteryDice.BepInExConfig.Bind<int>("Twitch", "Cheer Awful", 5, "The ones digit for spawning a Awful Effect");
		}

		public static void OnMessageHandler(TwitchMessage message)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			TwitchUser user = ((TwitchMessage)(ref message)).User;
			if (((TwitchUser)(ref user)).Username == "slayer6409")
			{
				string text = ((TwitchMessage)(ref message)).Message.ToUpper();
				if (((TwitchMessage)(ref message)).Message.ToUpper().Contains("RANDOM") && ((TwitchMessage)(ref message)).Message.ToUpper().Contains("DICE"))
				{
					if (text.Contains("GOOD"))
					{
						Networker.Instance.QueueSelectTypeServerRPC((EffectType)3, "twitch");
					}
					else if (text.Contains("BAD"))
					{
						Networker.Instance.QueueSelectTypeServerRPC((EffectType)1, "twitch");
					}
					else if (text.Contains("AWFUL"))
					{
						Networker.Instance.QueueSelectTypeServerRPC((EffectType)0, "twitch");
					}
					else if (text.Contains("GREAT"))
					{
						Networker.Instance.QueueSelectTypeServerRPC((EffectType)4, "twitch");
					}
					else if (text.Contains("MIXED"))
					{
						Networker.Instance.QueueSelectTypeServerRPC((EffectType)2, "twitch");
					}
					else
					{
						Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch");
					}
				}
				else if (((TwitchMessage)(ref message)).Message.ToUpper() == "SUPERTEST")
				{
					Test();
				}
			}
			if (enableChatEvents.Value && ((TwitchMessage)(ref message)).Message.ToUpper().StartsWith("!EVENT"))
			{
				Debug.Log((object)"test");
				if (evnt.Count == 0)
				{
					Misc.SafeTipMessage("Dice Twitch event started", $"{chattersMin.Value - 1} more users needed to trigger an event! Do !event to join the event!");
				}
				HashSet<string> hashSet = evnt;
				user = ((TwitchMessage)(ref message)).User;
				hashSet.Add(((TwitchUser)(ref user)).Username);
				if (evnt.Count >= chattersMin.Value && !hasRan)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(waitReset());
				}
			}
		}

		[IteratorStateMachine(typeof(<waitReset>d__16))]
		public static IEnumerator waitReset()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <waitReset>d__16(0);
		}

		public static void Test()
		{
			Misc.SpawnEnemyForced(GetEnemies.Lasso, 4, true, false);
		}

		private static void OnSubHandler(TwitchSubEvent subEvent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Invalid comparison between Unknown and I4
			if (enableSubs.Value)
			{
				TwitchUser user = ((TwitchEvent)subEvent).User;
				string displayName = ((TwitchUser)(ref user)).DisplayName;
				int num = 0;
				if ((int)subEvent.Tier == 1)
				{
					num = 1;
				}
				else if ((int)subEvent.Tier == 2)
				{
					num = 2;
				}
				else if ((int)subEvent.Tier == 3)
				{
					num = 3;
				}
				if ((int)subEvent.Type == 3)
				{
					num *= subEvent.GiftCount;
				}
				for (int i = 0; i < num; i++)
				{
					Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch:" + displayName);
				}
			}
		}

		private static void OnCheerHandler(TwitchCheerEvent cheerEvent)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			TwitchUser user = ((TwitchEvent)cheerEvent).User;
			string displayName = ((TwitchUser)(ref user)).DisplayName;
			if (enableCheer.Value && cheerEvent.CheerAmount >= cheerMin.Value)
			{
				int num = cheerEvent.CheerAmount % 10;
				if (num == cheerAwful.Value)
				{
					Networker.Instance.QueueSelectTypeServerRPC((EffectType)0, displayName);
				}
				else if (num == cheerGood.Value)
				{
					Networker.Instance.QueueSelectTypeServerRPC((EffectType)3, displayName);
				}
				else if (num == cheerGreat.Value)
				{
					Networker.Instance.QueueSelectTypeServerRPC((EffectType)4, displayName);
				}
				else if (num == cheerBad.Value)
				{
					Networker.Instance.QueueSelectTypeServerRPC((EffectType)1, displayName);
				}
				else if (num == cheerMixed.Value)
				{
					Networker.Instance.QueueSelectTypeServerRPC((EffectType)2, displayName);
				}
				else
				{
					Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch:" + displayName);
				}
			}
		}

		private static void OnRaidHandler(TwitchRaidEvent raidEvent)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			TwitchUser user = ((TwitchEvent)raidEvent).User;
			string displayName = ((TwitchUser)(ref user)).DisplayName;
			if (enableRaid.Value)
			{
				int num = raidEvent.ViewerCount / 5;
				if (num > 5)
				{
					num = 5;
				}
				for (int i = 0; i < num; i++)
				{
					Networker.Instance.QueueRandomDiceEffectServerRPC("Twitch:" + displayName);
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "DiceTwitchIntegration";

		public const string PLUGIN_NAME = "DiceTwitchIntegration";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace DiceTwitchIntegration.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}

DiceWeatherRegistryCompat.dll

Decompiled 2 weeks ago

Download (18.5 KB)

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using DiceWeatherRegistryCompat.Effects;
using DiceWeatherRegistryCompat.NetcodePatcher;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MysteryDice;
using MysteryDice.Dice;
using MysteryDice.Effects;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using WeatherRegistry;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DiceWeatherRegistryCompat")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Dice Weather Registry Compatibility")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DiceWeatherRegistryCompat")]
[assembly: AssemblyTitle("DiceWeatherRegistryCompat")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 DiceWeatherRegistryCompat
{
	public class Networker : NetworkBehaviour
	{
		public static Networker Instance;

		public override void OnNetworkSpawn()
		{
			Instance = this;
			MysteryDice.CustomLogger.LogInfo((object)"WeatherReg OnNetworkSpawn");
			((NetworkBehaviour)this).OnNetworkSpawn();
			if (!((NetworkBehaviour)this).IsServer)
			{
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetWeatherServerRpc(string weather)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3171511287u, val, (RpcDelivery)0);
				bool flag = weather != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(weather, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3171511287u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string weather2 = weather;
				WeatherController.ChangeCurrentWeather(WeatherManager.Weathers.Find((Weather x) => x.name == weather2));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddWeatherServerRpc(string weather)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2812204045u, val, (RpcDelivery)0);
				bool flag = weather != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(weather, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2812204045u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string weather2 = weather;
				WeatherController.AddWeatherEffect(WeatherManager.Weathers.Find((Weather x) => x.name == weather2));
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3171511287u, new RpcReceiveHandler(__rpc_handler_3171511287), "SetWeatherServerRpc");
			((NetworkBehaviour)this).__registerRpc(2812204045u, new RpcReceiveHandler(__rpc_handler_2812204045), "AddWeatherServerRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_3171511287(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string weatherServerRpc = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref weatherServerRpc, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SetWeatherServerRpc(weatherServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2812204045(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string weather = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref weather, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddWeatherServerRpc(weather);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "Networker";
		}
	}
	[BepInPlugin("Slayer6409.DiceWeatherRegistryCompat", "DiceWeatherRegistryCompat", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__5_0;

			public static UnityAction <>9__5_1;

			internal void <addButtons>b__5_0()
			{
				DebugMenuStuff.clearMainViewport();
				setWeather();
			}

			internal void <addButtons>b__5_1()
			{
				DebugMenuStuff.clearMainViewport();
				AddWeather();
			}
		}

		public static AssetBundle LoadedAssets;

		public static GameObject NetworkerPrefab;

		private readonly Harmony harmony = new Harmony("Slayer6409.DiceWeatherRegistryCompat");

		private void Awake()
		{
			if (!Chainloader.PluginInfos.ContainsKey("mrov.WeatherRegistry"))
			{
				MysteryDice.CustomLogger.LogInfo((object)"WeatherRegistry not found disabling WeatherRegistry Compatability");
				return;
			}
			LoadedAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "mysterydiceweatherregcompat"));
			NetworkerPrefab = LoadedAssets.LoadAsset<GameObject>("Networker");
			NetworkerPrefab.AddComponent<Networker>();
			DebugMenuStuff.OnDebugMenuOpen += debugMenuOpened;
			DieBehaviour.SteveNames.Add(new AddWeather().Name);
			MysteryDice.RegisterNewEffect((IEffect)(object)new AddWeather(), false, false);
			DieBehaviour.SteveNames.Add(new ClearWeather().Name);
			MysteryDice.RegisterNewEffect((IEffect)(object)new ClearWeather(), false, false);
			DieBehaviour.SteveNames.Add(new RandomWeather().Name);
			MysteryDice.RegisterNewEffect((IEffect)(object)new RandomWeather(), false, false);
			NetcodeWeaver();
			harmony.PatchAll();
		}

		private void debugMenuOpened()
		{
			DebugMenuStuff.OnSpecialFunctionsAdded += addButtons;
		}

		private void addButtons(Transform scrollContent)
		{
			//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
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (!ButtonExists(scrollContent, "Set Weather"))
			{
				object obj = <>c.<>9__5_0;
				if (obj == null)
				{
					UnityAction val = delegate
					{
						DebugMenuStuff.clearMainViewport();
						setWeather();
					};
					<>c.<>9__5_0 = val;
					obj = (object)val;
				}
				CreateButton(scrollContent, "Set Weather", (UnityAction)obj);
			}
			if (ButtonExists(scrollContent, "Add Weather"))
			{
				return;
			}
			object obj2 = <>c.<>9__5_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					DebugMenuStuff.clearMainViewport();
					AddWeather();
				};
				<>c.<>9__5_1 = val2;
				obj2 = (object)val2;
			}
			CreateButton(scrollContent, "Add Weather", (UnityAction)obj2);
		}

		private bool ButtonExists(Transform parent, string text)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			foreach (Transform item in parent)
			{
				Transform val = item;
				TMP_Text component = ((Component)val.GetChild(0)).GetComponent<TMP_Text>();
				if ((Object)(object)component != (Object)null && component.text == text)
				{
					return true;
				}
			}
			return false;
		}

		private void CreateButton(Transform parent, string label, UnityAction onClick)
		{
			GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, parent);
			TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
			component.text = label;
			Button component2 = val.GetComponent<Button>();
			((UnityEvent)component2.onClick).AddListener(onClick);
		}

		public static void AddWeather()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			List<string> weathers = WeatherRegistryCompat.getWeathers();
			foreach (string weather in weathers)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, DebugMenuStuff.mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = weather;
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					Networker.Instance.AddWeatherServerRpc(weather);
					DebugMenuStuff.CloseSelectMenu(false);
				});
			}
		}

		public static void setWeather()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			List<string> weathers = WeatherRegistryCompat.getWeathers();
			foreach (string weather in weathers)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, DebugMenuStuff.mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = weather;
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					Networker.Instance.SetWeatherServerRpc(weather);
					DebugMenuStuff.CloseSelectMenu(false);
				});
			}
		}

		private static void NetcodeWeaver()
		{
			try
			{
				Type[] types = Assembly.GetExecutingAssembly().GetTypes();
				Type[] array = types;
				foreach (Type type in array)
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					MethodInfo[] array2 = methods;
					foreach (MethodInfo methodInfo in array2)
					{
						object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
						if (customAttributes.Length != 0)
						{
							methodInfo.Invoke(null, null);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Debug.Log((object)ex);
			}
		}
	}
	public class WeatherRegistryCompat : MonoBehaviour
	{
		public static List<string> getWeathers()
		{
			List<string> list = new List<string>();
			foreach (Weather weather in WeatherManager.Weathers)
			{
				list.Add(weather.name);
			}
			return list;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "DiceWeatherRegistryCompat";

		public const string PLUGIN_NAME = "DiceWeatherRegistryCompat";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace DiceWeatherRegistryCompat.Patches
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	public class GameNetworkManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void AddPrefab(ref GameNetworkManager __instance)
		{
			((Component)__instance).GetComponent<NetworkManager>().AddNetworkPrefab(Plugin.NetworkerPrefab);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void InstantiateNetworker(StartOfRound __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(Plugin.NetworkerPrefab, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(true);
			}
		}
	}
}
namespace DiceWeatherRegistryCompat.Effects
{
	public class AddWeather : IEffect
	{
		public string Name => "Add Weather";

		public EffectType Outcome => (EffectType)0;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Adds a weather to the day";

		public void Use()
		{
			List<string> list = WeatherRegistryCompat.getWeathers().ToList();
			Networker.Instance.AddWeatherServerRpc(list[Random.Range(0, list.Count)]);
		}
	}
	internal class ClearWeather : IEffect
	{
		public string Name => "Clear Weather";

		public EffectType Outcome => (EffectType)4;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Sunshiny Day";

		public void Use()
		{
			Networker.Instance.SetWeatherServerRpc("None");
		}
	}
	internal class RandomWeather : IEffect
	{
		public string Name => "Random Weather";

		public EffectType Outcome => (EffectType)1;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "New weather time!";

		public void Use()
		{
			List<string> list = WeatherRegistryCompat.getWeathers().ToList();
			Networker.Instance.SetWeatherServerRpc(list[Random.Range(0, list.Count)]);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace DiceWeatherRegistryCompat.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}

MysteryDice.dll

Decompiled 2 weeks ago

Download (2.2 MB)

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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BombCollar;
using CodeRebirth.src.Content.Enemies;
using CodeRebirth.src.Content.Maps;
using CodeRebirth.src.MiscScripts;
using Dawn;
using Dawn.Utils;
using DiversityRemastered;
using DiversityRemastered.Misc;
using GameNetcodeStuff;
using HarmonyLib;
using JetBrains.Annotations;
using KaimiraGames;
using LethalCompanyInputUtils.Api;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LethalLib.Extras;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using MoreCompany.Cosmetics;
using MysteryDice;
using MysteryDice.CompatThings;
using MysteryDice.Dice;
using MysteryDice.Effects;
using MysteryDice.Extensions;
using MysteryDice.Gal;
using MysteryDice.MiscStuff;
using MysteryDice.NetcodePatcher;
using MysteryDice.Patches;
using MysteryDice.Visual;
using Newtonsoft.Json;
using PathfindingLib.Jobs;
using PathfindingLib.Utilities;
using Surfaced;
using TMPro;
using TooManyEmotes;
using TooManyEmotes.Props;
using TooManyEmotes.UI;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.AI;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("CodeRebirth")]
[assembly: IgnoresAccessChecksTo("Surfaced")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
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;
		}
	}
}
public class TargetRandomPlayer : MonoBehaviour
{
	private NavMeshAgent agent;

	private PlayerControllerB target;

	public void Start()
	{
		agent = ((Component)this).gameObject.GetComponent<NavMeshAgent>();
		target = Misc.GetRandomAlivePlayer();
	}

	public void Update()
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)target == (Object)null || target.isPlayerDead)
		{
			target = Misc.GetRandomAlivePlayer();
		}
		agent.SetDestination(((Component)target).transform.position);
	}
}
public class Blinking : MonoBehaviour
{
	public float BlinkingTime;

	private float BlinkingTimer = 0f;

	private GameObject GlowSign;

	private GameObject NormalSign;

	private bool Stop = false;

	public bool Glow { get; private set; }

	private void Start()
	{
		BlinkingTime = 0.5f;
		Glow = false;
		NormalSign = ((Component)((Component)this).transform.Find("Emergency Sign")).gameObject;
		GlowSign = ((Component)((Component)this).transform.Find("Emergency Sign Glowing")).gameObject;
	}

	public void HideSigns()
	{
		Stop = true;
		NormalSign.SetActive(false);
		GlowSign.SetActive(false);
	}

	private void Update()
	{
		if (Stop)
		{
			return;
		}
		BlinkingTimer -= Time.deltaTime;
		if (BlinkingTimer <= 0f)
		{
			BlinkingTimer = BlinkingTime;
			if (Glow)
			{
				Glow = false;
				NormalSign.SetActive(true);
				GlowSign.SetActive(false);
			}
			else
			{
				Glow = true;
				NormalSign.SetActive(false);
				GlowSign.SetActive(true);
			}
		}
	}
}
public class ColorGradient : MonoBehaviour
{
	public Renderer CubeRenderer;

	public Renderer MoonRenderer;

	public Renderer SunRenderer;

	public Color NightColor = new Color(0.40392157f, 33f / 85f, 0.8862745f);

	public Color DayColor = new Color(1f, 0.81960785f, 0f);

	private float ColorTimer = 0f;

	private void Start()
	{
		CubeRenderer = ((Component)this).GetComponent<Renderer>();
		SunRenderer = ((Component)((Component)this).transform.Find("Sun")).GetComponent<Renderer>();
		MoonRenderer = ((Component)((Component)this).transform.Find("Moon")).GetComponent<Renderer>();
	}

	private void Update()
	{
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		ColorTimer -= Time.deltaTime;
		if (!(ColorTimer >= 0f))
		{
			ColorTimer = 1f;
			Color val = DayColor + (NightColor - DayColor) * TimeOfDay.Instance.normalizedTimeOfDay;
			CubeRenderer.material.SetColor("_BaseColor", val);
			CubeRenderer.material.SetColor("_EmissiveColor", val * 3f);
			float normalizedTimeOfDay = TimeOfDay.Instance.normalizedTimeOfDay;
			float num = 1f - normalizedTimeOfDay;
			MoonRenderer.material.SetColor("_BaseColor", new Color(1f, 1f, 1f, normalizedTimeOfDay));
			SunRenderer.material.SetColor("_BaseColor", new Color(1f, 1f, 1f, num));
			MoonRenderer.material.SetColor("_UnlitColor", new Color(1f, 1f, 1f, normalizedTimeOfDay));
			SunRenderer.material.SetColor("_UnlitColor", new Color(1f, 1f, 1f, num));
			MoonRenderer.material.SetColor("_MainColor", new Color(1f, 1f, 1f, normalizedTimeOfDay));
			SunRenderer.material.SetColor("_MainColor", new Color(1f, 1f, 1f, num));
		}
	}
}
public class CycleSigns : MonoBehaviour
{
	private class DiceVisuals
	{
		public Sprite Sprite;

		public Color ModelColor;

		public Color EmissionColor;

		public float Emission;

		public DiceVisuals(Sprite sprite, Color color, Color emissionColor, float emission)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Sprite = sprite;
			ModelColor = color;
			EmissionColor = emissionColor;
			Emission = emission;
		}
	}

	public float CycleTime = 1f;

	private float CurrentTimer = 0f;

	private int CurrentSprite = 0;

	private bool Stop = false;

	private SpriteRenderer SignSpriteRenderer;

	private SpriteRenderer SignSpriteRenderer2;

	private Renderer DiceRenderer;

	private List<DiceVisuals> Visuals = new List<DiceVisuals>();

	private void Start()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningJester, Color.yellow, Color.yellow, 100f));
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningBracken, Color.yellow, Color.yellow, 100f));
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningDeath, Color.red, Color.red, 100f));
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningLuck, Color.green, Color.green, 300f));
		SignSpriteRenderer = ((Component)((Component)this).transform.Find("Emergency Sign")).gameObject.GetComponent<SpriteRenderer>();
		SignSpriteRenderer2 = ((Component)((Component)this).transform.Find("Emergency Sign2")).gameObject.GetComponent<SpriteRenderer>();
		DiceRenderer = ((Component)this).gameObject.GetComponent<Renderer>();
	}

	private void Update()
	{
		if (!Stop)
		{
			CurrentTimer -= Time.deltaTime;
			if (CurrentTimer <= 0f)
			{
				CurrentTimer = CycleTime;
				CycleSprite();
			}
		}
	}

	private void CycleSprite()
	{
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		CurrentSprite++;
		if (CurrentSprite >= Visuals.Count)
		{
			CurrentSprite = 0;
		}
		SignSpriteRenderer.sprite = Visuals[CurrentSprite].Sprite;
		SignSpriteRenderer2.sprite = Visuals[CurrentSprite].Sprite;
		DiceRenderer.material.SetColor("_BaseColor", Visuals[CurrentSprite].ModelColor);
		DiceRenderer.material.SetColor("_EmissiveColor", Visuals[CurrentSprite].EmissionColor * Visuals[CurrentSprite].Emission);
	}

	public void HideSigns()
	{
		Stop = true;
		((Renderer)((Component)SignSpriteRenderer).GetComponent<SpriteRenderer>()).enabled = false;
		((Renderer)((Component)SignSpriteRenderer2).GetComponent<SpriteRenderer>()).enabled = false;
	}
}
namespace KaimiraGames
{
	public class WeightedList<T> : IEnumerable<T>, IEnumerable
	{
		private readonly List<T> _list = new List<T>();

		private readonly List<int> _weights = new List<int>();

		private readonly List<int> _probabilities = new List<int>();

		private readonly List<int> _alias = new List<int>();

		private readonly Random _rand;

		private int _totalWeight;

		private bool _areAllProbabilitiesIdentical = false;

		private int _minWeight;

		private int _maxWeight;

		public WeightErrorHandlingType BadWeightErrorHandling { get; set; } = WeightErrorHandlingType.SetWeightToOne;


		public int TotalWeight => _totalWeight;

		public int MinWeight => _minWeight;

		public int MaxWeight => _maxWeight;

		public IReadOnlyList<T> Items => _list.AsReadOnly();

		public T this[int index] => _list[index];

		public int Count => _list.Count;

		public WeightedList(Random rand = null)
		{
			_rand = rand ?? new Random();
		}

		public WeightedList(ICollection<WeightedListItem<T>> listItems, Random rand = null)
		{
			_rand = rand ?? new Random();
			foreach (WeightedListItem<T> listItem in listItems)
			{
				_list.Add(listItem._item);
				_weights.Add(listItem._weight);
			}
			Recalculate();
		}

		public T Next()
		{
			if (Count == 0)
			{
				return default(T);
			}
			int index = _rand.Next(Count);
			if (_areAllProbabilitiesIdentical)
			{
				return _list[index];
			}
			int num = _rand.Next(_totalWeight);
			return (num < _probabilities[index]) ? _list[index] : _list[_alias[index]];
		}

		public void AddWeightToAll(int weight)
		{
			if (weight + _minWeight <= 0 && BadWeightErrorHandling == WeightErrorHandlingType.ThrowExceptionOnAdd)
			{
				throw new ArgumentException($"Subtracting {-1 * weight} from all items would set weight to non-positive for at least one element.");
			}
			for (int i = 0; i < Count; i++)
			{
				_weights[i] = FixWeight(_weights[i] + weight);
			}
			Recalculate();
		}

		public void SubtractWeightFromAll(int weight)
		{
			AddWeightToAll(weight * -1);
		}

		public void SetWeightOfAll(int weight)
		{
			if (weight <= 0 && BadWeightErrorHandling == WeightErrorHandlingType.ThrowExceptionOnAdd)
			{
				throw new ArgumentException("Weight cannot be non-positive.");
			}
			for (int i = 0; i < Count; i++)
			{
				_weights[i] = FixWeight(weight);
			}
			Recalculate();
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		public void Add(T item, int weight)
		{
			_list.Add(item);
			_weights.Add(FixWeight(weight));
			Recalculate();
		}

		public void Add(ICollection<WeightedListItem<T>> listItems)
		{
			foreach (WeightedListItem<T> listItem in listItems)
			{
				_list.Add(listItem._item);
				_weights.Add(FixWeight(listItem._weight));
			}
			Recalculate();
		}

		public void Clear()
		{
			_list.Clear();
			_weights.Clear();
			Recalculate();
		}

		public void Contains(T item)
		{
			_list.Contains(item);
		}

		public int IndexOf(T item)
		{
			return _list.IndexOf(item);
		}

		public void Insert(int index, T item, int weight)
		{
			_list.Insert(index, item);
			_weights.Insert(index, FixWeight(weight));
			Recalculate();
		}

		public void Remove(T item)
		{
			int index = IndexOf(item);
			RemoveAt(index);
			Recalculate();
		}

		public void RemoveAt(int index)
		{
			_list.RemoveAt(index);
			_weights.RemoveAt(index);
			Recalculate();
		}

		public void SetWeight(T item, int newWeight)
		{
			SetWeightAtIndex(IndexOf(item), FixWeight(newWeight));
		}

		public int GetWeightOf(T item)
		{
			return GetWeightAtIndex(IndexOf(item));
		}

		public void SetWeightAtIndex(int index, int newWeight)
		{
			_weights[index] = FixWeight(newWeight);
			Recalculate();
		}

		public int GetWeightAtIndex(int index)
		{
			return _weights[index];
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("WeightedList<");
			stringBuilder.Append(typeof(T).Name);
			stringBuilder.Append(">: TotalWeight:");
			stringBuilder.Append(TotalWeight);
			stringBuilder.Append(", Min:");
			stringBuilder.Append(_minWeight);
			stringBuilder.Append(", Max:");
			stringBuilder.Append(_maxWeight);
			stringBuilder.Append(", Count:");
			stringBuilder.Append(Count);
			stringBuilder.Append(", {");
			for (int i = 0; i < _list.Count; i++)
			{
				stringBuilder.Append(_list[i].ToString());
				stringBuilder.Append(":");
				stringBuilder.Append(_weights[i].ToString());
				if (i < _list.Count - 1)
				{
					stringBuilder.Append(", ");
				}
			}
			stringBuilder.Append("}");
			return stringBuilder.ToString();
		}

		private void Recalculate()
		{
			_totalWeight = 0;
			_areAllProbabilitiesIdentical = false;
			_minWeight = 0;
			_maxWeight = 0;
			bool flag = true;
			_alias.Clear();
			_probabilities.Clear();
			List<int> list = new List<int>(Count);
			List<int> list2 = new List<int>(Count);
			List<int> list3 = new List<int>(Count);
			foreach (int weight in _weights)
			{
				if (flag)
				{
					_minWeight = (_maxWeight = weight);
					flag = false;
				}
				_minWeight = ((weight < _minWeight) ? weight : _minWeight);
				_maxWeight = ((_maxWeight < weight) ? weight : _maxWeight);
				_totalWeight += weight;
				list.Add(weight * Count);
				_alias.Add(0);
				_probabilities.Add(0);
			}
			if (_minWeight == _maxWeight)
			{
				_areAllProbabilitiesIdentical = true;
				return;
			}
			for (int i = 0; i < Count; i++)
			{
				if (list[i] < _totalWeight)
				{
					list2.Add(i);
				}
				else
				{
					list3.Add(i);
				}
			}
			while (list2.Count > 0 && list3.Count > 0)
			{
				int index = list2[list2.Count - 1];
				list2.RemoveAt(list2.Count - 1);
				int num = list3[list3.Count - 1];
				list3.RemoveAt(list3.Count - 1);
				_probabilities[index] = list[index];
				_alias[index] = num;
				int num3 = (list[num] = list[num] + list[index] - _totalWeight);
				if (num3 < _totalWeight)
				{
					list2.Add(num);
				}
				else
				{
					list3.Add(num);
				}
			}
			while (list3.Count > 0)
			{
				int index2 = list3[list3.Count - 1];
				list3.RemoveAt(list3.Count - 1);
				_probabilities[index2] = _totalWeight;
			}
		}

		internal static int FixWeightSetToOne(int weight)
		{
			return (weight <= 0) ? 1 : weight;
		}

		internal static int FixWeightExceptionOnAdd(int weight)
		{
			if (weight > 0)
			{
				return weight;
			}
			throw new ArgumentException("Weight cannot be non-positive");
		}

		private int FixWeight(int weight)
		{
			return (BadWeightErrorHandling == WeightErrorHandlingType.ThrowExceptionOnAdd) ? FixWeightExceptionOnAdd(weight) : FixWeightSetToOne(weight);
		}
	}
	public readonly struct WeightedListItem<T>
	{
		internal readonly T _item;

		internal readonly int _weight;

		public WeightedListItem(T item, int weight)
		{
			_item = item;
			_weight = weight;
		}
	}
	public enum WeightErrorHandlingType
	{
		SetWeightToOne,
		ThrowExceptionOnAdd
	}
}
namespace MysteryDice
{
	internal class ConfigManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static GenericButtonHandler <>9__1_0;

			internal void <setupLethalConfig>b__1_0()
			{
				Misc.ToggleAllScanPlayerNodes();
			}
		}

		public static void addConfig(ConfigEntry<bool> config)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(config, true);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
		}

		public static void setupLethalConfig()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0028: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0050: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0078: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00a0: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00c8: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_00f1: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_011a: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_013c: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			//IL_015e: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0180: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_01a2: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01c4: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01e6: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			//IL_0208: Expected O, but got Unknown
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Expected O, but got Unknown
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Expected O, but got Unknown
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Expected O, but got Unknown
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Expected O, but got Unknown
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Expected O, but got Unknown
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Expected O, but got Unknown
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Expected O, but got Unknown
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Expected O, but got Unknown
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Expected O, but got Unknown
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Expected O, but got Unknown
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Expected O, but got Unknown
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Expected O, but got Unknown
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Expected O, but got Unknown
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Expected O, but got Unknown
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Expected O, but got Unknown
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Expected O, but got Unknown
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Expected O, but got Unknown
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Expected O, but got Unknown
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Expected O, but got Unknown
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Expected O, but got Unknown
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Expected O, but got Unknown
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Expected O, but got Unknown
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Expected O, but got Unknown
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Expected O, but got Unknown
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Expected O, but got Unknown
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Expected O, but got Unknown
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Expected O, but got Unknown
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Expected O, but got Unknown
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Expected O, but got Unknown
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Expected O, but got Unknown
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Expected O, but got Unknown
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Expected O, but got Unknown
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Expected O, but got Unknown
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Expected O, but got Unknown
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Expected O, but got Unknown
			//IL_04c9: Expected O, but got Unknown
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Expected O, but got Unknown
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dd: Expected O, but got Unknown
			//IL_04de: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Expected O, but got Unknown
			//IL_04ef: Expected O, but got Unknown
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Expected O, but got Unknown
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Expected O, but got Unknown
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Expected O, but got Unknown
			//IL_0515: Expected O, but got Unknown
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Expected O, but got Unknown
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Expected O, but got Unknown
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_072c: Expected O, but got Unknown
			//IL_0751: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Expected O, but got Unknown
			ConfigEntry<float> minHyperShake = MysteryDice.minHyperShake;
			FloatSliderOptions val = new FloatSliderOptions();
			((BaseRangeOptions<float>)val).Min = 0f;
			((BaseRangeOptions<float>)val).Max = 100f;
			FloatSliderConfigItem val2 = new FloatSliderConfigItem(minHyperShake, val);
			ConfigEntry<float> maxHyperShake = MysteryDice.maxHyperShake;
			FloatSliderOptions val3 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val3).Min = 0f;
			((BaseRangeOptions<float>)val3).Max = 100f;
			FloatSliderConfigItem val4 = new FloatSliderConfigItem(maxHyperShake, val3);
			ConfigEntry<float> minNeckSpin = MysteryDice.minNeckSpin;
			FloatSliderOptions val5 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val5).Min = 0f;
			((BaseRangeOptions<float>)val5).Max = 100f;
			FloatSliderConfigItem val6 = new FloatSliderConfigItem(minNeckSpin, val5);
			ConfigEntry<float> rotationSpeedModifier = MysteryDice.rotationSpeedModifier;
			FloatSliderOptions val7 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val7).Min = 0f;
			((BaseRangeOptions<float>)val7).Max = 100f;
			FloatSliderConfigItem val8 = new FloatSliderConfigItem(rotationSpeedModifier, val7);
			ConfigEntry<float> maxNeckSpin = MysteryDice.maxNeckSpin;
			FloatSliderOptions val9 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val9).Min = 0f;
			((BaseRangeOptions<float>)val9).Max = 100f;
			FloatSliderConfigItem val10 = new FloatSliderConfigItem(maxNeckSpin, val9);
			ConfigEntry<float> eggExplodeTime = MysteryDice.eggExplodeTime;
			FloatSliderOptions val11 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val11).Min = 0f;
			((BaseRangeOptions<float>)val11).Max = 5f;
			FloatSliderConfigItem val12 = new FloatSliderConfigItem(eggExplodeTime, val11);
			ConfigEntry<float> soundVolume = MysteryDice.SoundVolume;
			FloatSliderOptions val13 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val13).Min = 0f;
			((BaseRangeOptions<float>)val13).Max = 1f;
			FloatSliderConfigItem val14 = new FloatSliderConfigItem(soundVolume, val13);
			ConfigEntry<int> minNeckBreakTimer = MysteryDice.minNeckBreakTimer;
			IntSliderOptions val15 = new IntSliderOptions();
			((BaseRangeOptions<int>)val15).Min = 0;
			((BaseRangeOptions<int>)val15).Max = 100;
			IntSliderConfigItem val16 = new IntSliderConfigItem(minNeckBreakTimer, val15);
			ConfigEntry<int> maxNeckBreakTimer = MysteryDice.maxNeckBreakTimer;
			IntSliderOptions val17 = new IntSliderOptions();
			((BaseRangeOptions<int>)val17).Min = 0;
			((BaseRangeOptions<int>)val17).Max = 100;
			IntSliderConfigItem val18 = new IntSliderConfigItem(maxNeckBreakTimer, val17);
			ConfigEntry<int> debugButtonAlpha = MysteryDice.DebugButtonAlpha;
			IntSliderOptions val19 = new IntSliderOptions();
			((BaseRangeOptions<int>)val19).Min = 0;
			((BaseRangeOptions<int>)val19).Max = 100;
			IntSliderConfigItem val20 = new IntSliderConfigItem(debugButtonAlpha, val19);
			ConfigEntry<int> debugMenuAccentAlpha = MysteryDice.DebugMenuAccentAlpha;
			IntSliderOptions val21 = new IntSliderOptions();
			((BaseRangeOptions<int>)val21).Min = 0;
			((BaseRangeOptions<int>)val21).Max = 100;
			IntSliderConfigItem val22 = new IntSliderConfigItem(debugMenuAccentAlpha, val21);
			ConfigEntry<int> debugMenuBackgroundAlpha = MysteryDice.DebugMenuBackgroundAlpha;
			IntSliderOptions val23 = new IntSliderOptions();
			((BaseRangeOptions<int>)val23).Min = 0;
			((BaseRangeOptions<int>)val23).Max = 100;
			IntSliderConfigItem val24 = new IntSliderConfigItem(debugMenuBackgroundAlpha, val23);
			ConfigEntry<int> debugMenuTextAlpha = MysteryDice.DebugMenuTextAlpha;
			IntSliderOptions val25 = new IntSliderOptions();
			((BaseRangeOptions<int>)val25).Min = 0;
			((BaseRangeOptions<int>)val25).Max = 100;
			IntSliderConfigItem val26 = new IntSliderConfigItem(debugMenuTextAlpha, val25);
			ConfigEntry<int> debugMenuFavoriteTextAlpha = MysteryDice.DebugMenuFavoriteTextAlpha;
			IntSliderOptions val27 = new IntSliderOptions();
			((BaseRangeOptions<int>)val27).Min = 0;
			((BaseRangeOptions<int>)val27).Max = 100;
			IntSliderConfigItem val28 = new IntSliderConfigItem(debugMenuFavoriteTextAlpha, val27);
			object obj = <>c.<>9__1_0;
			if (obj == null)
			{
				GenericButtonHandler val29 = delegate
				{
					Misc.ToggleAllScanPlayerNodes();
				};
				<>c.<>9__1_0 = val29;
				obj = (object)val29;
			}
			GenericButtonConfigItem val30 = new GenericButtonConfigItem("Clientside", "Toggle Controllers", "Hides/Shows the custom scannodes attached to people", "Toggle Scannodes", (GenericButtonHandler)obj);
			IntInputFieldConfigItem val31 = new IntInputFieldConfigItem(MysteryDice.EmergencyDiePrice, true);
			IntInputFieldConfigItem val32 = new IntInputFieldConfigItem(MysteryDice.brutalStartingScale, false);
			IntInputFieldConfigItem val33 = new IntInputFieldConfigItem(MysteryDice.brutalMaxScale, false);
			IntInputFieldConfigItem val34 = new IntInputFieldConfigItem(MysteryDice.brutalScaleType, false);
			BoolCheckBoxConfigItem val35 = new BoolCheckBoxConfigItem(MysteryDice.DieEmergencyAsScrap, true);
			IntInputFieldConfigItem val36 = new IntInputFieldConfigItem(BlameGlitch.minNum, false);
			IntInputFieldConfigItem val37 = new IntInputFieldConfigItem(BlameGlitch.maxNum, false);
			IntInputFieldConfigItem val38 = new IntInputFieldConfigItem(MysteryDice.hyperShakeTimer, false);
			IntInputFieldConfigItem val39 = new IntInputFieldConfigItem(MysteryDice.neckRotations, false);
			TextInputFieldConfigItem val40 = new TextInputFieldConfigItem(MysteryDice.DisplayResults);
			TextInputFieldConfigItem val41 = new TextInputFieldConfigItem(MysteryDice.debugChat);
			BoolCheckBoxConfigItem val42 = new BoolCheckBoxConfigItem(BlameGlitch.isInside, false);
			BoolCheckBoxConfigItem val43 = new BoolCheckBoxConfigItem(BlameGlitch.bothInsideOutside, false);
			BoolCheckBoxConfigItem val44 = new BoolCheckBoxConfigItem(MysteryDice.pussyMode, false);
			BoolCheckBoxConfigItem val45 = new BoolCheckBoxConfigItem(MysteryDice.DebugLogging, false);
			BoolCheckBoxConfigItem val46 = new BoolCheckBoxConfigItem(MysteryDice.randomSpinTime, true);
			BoolCheckBoxConfigItem val47 = new BoolCheckBoxConfigItem(MysteryDice.chronosUpdatedTimeOfDay, false);
			BoolCheckBoxConfigItem val48 = new BoolCheckBoxConfigItem(MysteryDice.useDiceOutside, false);
			BoolCheckBoxConfigItem val49 = new BoolCheckBoxConfigItem(MysteryDice.debugDice, false);
			BoolCheckBoxConfigItem val50 = new BoolCheckBoxConfigItem(MysteryDice.TwitchEnabled, true);
			BoolCheckBoxConfigItem val51 = new BoolCheckBoxConfigItem(MysteryDice.CopyrightFree, false);
			BoolCheckBoxConfigItem val52 = new BoolCheckBoxConfigItem(MysteryDice.allowChatCommands, true);
			BoolCheckBoxConfigItem val53 = new BoolCheckBoxConfigItem(MysteryDice.useNeckBreakTimer, false);
			BoolCheckBoxConfigItem val54 = new BoolCheckBoxConfigItem(MysteryDice.debugMenuShowsAll, false);
			BoolCheckBoxConfigItem val55 = new BoolCheckBoxConfigItem(MysteryDice.debugButton, true);
			BoolCheckBoxConfigItem val56 = new BoolCheckBoxConfigItem(MysteryDice.BetterDebugMenu, false);
			BoolCheckBoxConfigItem val57 = new BoolCheckBoxConfigItem(MysteryDice.Bald, false);
			BoolCheckBoxConfigItem val58 = new BoolCheckBoxConfigItem(MysteryDice.LockDebugUI, false);
			BoolCheckBoxConfigItem val59 = new BoolCheckBoxConfigItem(BlameGlitch.GlitchedMeteorShower, false);
			BoolCheckBoxConfigItem val60 = new BoolCheckBoxConfigItem(AlarmCurse.fireAlarm, false);
			BoolCheckBoxConfigItem val61 = new BoolCheckBoxConfigItem(AlarmCurse.HorribleVersion, false);
			BoolCheckBoxConfigItem val62 = new BoolCheckBoxConfigItem(MysteryDice.doDiceExplosion, false);
			BoolCheckBoxConfigItem val63 = new BoolCheckBoxConfigItem(MysteryDice.LoversOnStart, false);
			BoolCheckBoxConfigItem val64 = new BoolCheckBoxConfigItem(MysteryDice.insideJoke, false);
			BoolCheckBoxConfigItem val65 = new BoolCheckBoxConfigItem(MysteryDice.DebugMenuClosesAfter, false);
			BoolCheckBoxConfigItem val66 = new BoolCheckBoxConfigItem(MysteryDice.BrutalMode, false);
			BoolCheckBoxConfigItem val67 = new BoolCheckBoxConfigItem(MysteryDice.BrutalChat, false);
			BoolCheckBoxConfigItem val68 = new BoolCheckBoxConfigItem(MysteryDice.debugSpawnOnPlayer, false);
			BoolCheckBoxConfigItem val69 = new BoolCheckBoxConfigItem(MysteryDice.SuperBrutalMode, false);
			BoolCheckBoxConfigItem val70 = new BoolCheckBoxConfigItem(MysteryDice.yippeeUse, false);
			HexColorInputFieldConfigItem val71 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuTextColor, false);
			HexColorInputFieldConfigItem val72 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuFavoriteTextColor, false);
			HexColorInputFieldConfigItem val73 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuBackgroundColor, false);
			HexColorInputFieldConfigItem val74 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuAccentColor, false);
			HexColorInputFieldConfigItem val75 = new HexColorInputFieldConfigItem(MysteryDice.DebugButtonColor, false);
			BoolCheckBoxConfigItem val76 = new BoolCheckBoxConfigItem(MysteryDice.ConfigGalAutomatic, false);
			BoolCheckBoxConfigItem val77 = new BoolCheckBoxConfigItem(MysteryDice.ConfigOnlyOwnerDisablesGal, false);
			ConfigEntry<int> imFeelingLuckyCooldown = MysteryDice.ImFeelingLuckyCooldown;
			IntInputFieldOptions val78 = new IntInputFieldOptions();
			((BaseRangeOptions<int>)val78).Min = 10;
			((BaseRangeOptions<int>)val78).Max = 600;
			IntInputFieldConfigItem val79 = new IntInputFieldConfigItem(imFeelingLuckyCooldown, val78);
			ConfigEntry<int> onTheHouseCooldown = MysteryDice.OnTheHouseCooldown;
			IntInputFieldOptions val80 = new IntInputFieldOptions();
			((BaseRangeOptions<int>)val80).Min = 10;
			((BaseRangeOptions<int>)val80).Max = 600;
			IntInputFieldConfigItem val81 = new IntInputFieldConfigItem(onTheHouseCooldown, val80);
			ConfigEntry<int> devilDealCooldown = MysteryDice.DevilDealCooldown;
			IntInputFieldOptions val82 = new IntInputFieldOptions();
			((BaseRangeOptions<int>)val82).Min = 10;
			((BaseRangeOptions<int>)val82).Max = 600;
			IntInputFieldConfigItem val83 = new IntInputFieldConfigItem(devilDealCooldown, val82);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val49);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val48);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val66);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val67);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val69);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val32);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val33);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val34);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val71);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val26);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val72);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val28);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val73);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val24);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val74);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val64);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val22);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val75);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val20);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val56);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val47);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val46);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val44);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val53);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val14);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val40);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val51);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val38);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val12);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val65);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val70);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val6);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val10);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val8);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val16);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val18);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val76);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val77);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val79);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val81);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val83);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val39);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val42);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val43);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val36);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val37);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val54);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val55);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val68);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val41);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val50);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val45);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val57);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val31);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val63);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val35);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val62);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val59);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val60);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val58);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val61);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val30);
			if (MysteryDice.SurfacedPresent)
			{
				BoolCheckBoxConfigItem val84 = new BoolCheckBoxConfigItem(Flinger.beybladeMode, false);
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val84);
			}
			foreach (ConfigEntry<bool> effectConfig in DieBehaviour.effectConfigs)
			{
				BoolCheckBoxConfigItem val85 = new BoolCheckBoxConfigItem(effectConfig, true);
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val85);
			}
		}
	}
	internal static class CullFactorySoftCompat
	{
		private static readonly bool CullFactoryAvailable;

		private static readonly MethodInfo RefreshGrabbableMethod;

		private static readonly MethodInfo RefreshLightMethod;

		static CullFactorySoftCompat()
		{
			if (Chainloader.PluginInfos.TryGetValue("com.fumiko.CullFactory", out var value) && value.Metadata.Version >= new Version(1, 5, 0))
			{
				Type type = Type.GetType("CullFactory.Behaviours.API.DynamicObjectsAPI, CullFactory");
				if (type != null)
				{
					RefreshGrabbableMethod = type.GetMethod("RefreshGrabbableObjectPosition", BindingFlags.Static | BindingFlags.Public);
					RefreshLightMethod = type.GetMethod("RefreshLightPosition", BindingFlags.Static | BindingFlags.Public);
					CullFactoryAvailable = RefreshGrabbableMethod != null && RefreshLightMethod != null;
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void RefreshGrabbableObjectPosition(GrabbableObject item)
		{
			item.EnableItemMeshes(true);
			if (CullFactoryAvailable)
			{
				RefreshGrabbableMethod?.Invoke(null, new object[1] { item });
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void RefreshLightPosition(Light light)
		{
			if (CullFactoryAvailable)
			{
				RefreshLightMethod?.Invoke(null, new object[1] { light });
			}
		}
	}
	public class IngameKeybinds : LcInputActions
	{
		[InputAction("<Keyboard>/numpadMinus", Name = "DebugMenu")]
		public InputAction DebugMenu { get; set; } = null;


		[InputAction("<Keyboard>/space", Name = "FlyButton")]
		public InputAction FlyButton { get; set; } = null;


		[InputAction("<Keyboard>/ctrl", Name = "FlyDownButton")]
		public InputAction FlyDownButton { get; set; } = null;

	}
	public class Misc
	{
		public static Item GetItemByName(string itemName, bool matchCase = true)
		{
			StringComparison comparisonType = ((!matchCase) ? StringComparison.OrdinalIgnoreCase : StringComparison.CurrentCulture);
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				if (items.itemName.Equals(itemName, comparisonType))
				{
					return items;
				}
			}
			foreach (SpawnableItemWithRarity item in RoundManager.Instance.currentLevel.spawnableScrap)
			{
				if (item.spawnableItem.itemName.Equals(itemName, comparisonType))
				{
					return item.spawnableItem;
				}
			}
			return null;
		}

		public static void SpawnEnemy(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)Networker.Instance).IsHost)
			{
				return;
			}
			RoundManager instance = RoundManager.Instance;
			if (isInside)
			{
				if (isInvisible)
				{
					for (int i = 0; i < amount; i++)
					{
						EnemyVent val = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
						GameObject val2 = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, val.floorNode.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
						SetObjectInvisible(val2);
						val2.GetComponentInChildren<NetworkObject>().Spawn(true);
						instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
					}
				}
				else
				{
					for (int j = 0; j < amount; j++)
					{
						EnemyVent val3 = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
						instance.SpawnEnemyOnServer(val3.floorNode.position, val3.floorNode.eulerAngles.y, instance.currentLevel.Enemies.IndexOf(enemy));
					}
				}
			}
			else
			{
				for (int k = 0; k < amount; k++)
				{
					SpawnOutsideEnemy(enemy);
				}
			}
		}

		public static void SpawnEnemy(EnemyType enemy, int amount, bool isInside, bool isInvisible = false)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)Networker.Instance).IsHost)
			{
				return;
			}
			RoundManager instance = RoundManager.Instance;
			Vector3 position = instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position;
			EnemyVent val = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
			if (isInside)
			{
				position = val.floorNode.position;
			}
			for (int i = 0; i < amount; i++)
			{
				GameObject val2 = Object.Instantiate<GameObject>(enemy.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				if (isInvisible)
				{
					SetObjectInvisible(val2);
				}
				val2.GetComponentInChildren<NetworkObject>().Spawn(true);
				instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
			}
		}

		public static bool canDiceYet()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return false;
			}
			if (StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded)
			{
				return false;
			}
			return true;
		}

		public static int playerCount()
		{
			int num = 0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB player in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(player))
				{
					num++;
				}
			}
			return num;
		}

		public static void SetObjectInvisible(GameObject obj)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = obj.GetComponentsInChildren<Renderer>();
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					val2.shader = Shader.Find("Standard");
					val2.SetFloat("_Mode", 3f);
					val2.SetInt("_SrcBlend", 5);
					val2.SetInt("_DstBlend", 10);
					val2.SetInt("_ZWrite", 0);
					val2.DisableKeyword("_ALPHATEST_ON");
					val2.EnableKeyword("_ALPHABLEND_ON");
					val2.DisableKeyword("_ALPHAPREMULTIPLY_ON");
					val2.renderQueue = 3000;
					Color color = val2.color;
					color.a = 0.1f;
					val2.color = color;
				}
			}
		}

		public static PlayerControllerB getPlayerBySteamID(ulong steamID)
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerReal(val))
				{
					list.Add(val);
				}
			}
			return list.Where((PlayerControllerB x) => x.playerSteamId == steamID).FirstOrDefault();
		}

		public static void SpawnOutsideEnemy(SpawnableEnemyWithRarity enemy)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			GameObject[] source = GameObject.FindGameObjectsWithTag("OutsideAINode");
			source = source.OrderBy((GameObject x) => Vector3.Distance(x.transform.position, Vector3.zero)).ToArray();
			Vector3 position = instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position;
			position = instance.GetRandomNavMeshPositionInBoxPredictable(position, 30f, default(NavMeshHit), random, -1, 1f) + Vector3.up;
			GameObject val = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
		}

		public static List<GameObject> SpawnEnemy(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false, bool returnObject = false)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = new List<GameObject>();
			if (!((NetworkBehaviour)Networker.Instance).IsHost)
			{
				return list;
			}
			RoundManager instance = RoundManager.Instance;
			if (isInside)
			{
				for (int i = 0; i < amount; i++)
				{
					EnemyVent val = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
					GameObject val2 = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, val.floorNode.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
					if (isInvisible)
					{
						SetObjectInvisible(val2);
					}
					val2.GetComponentInChildren<NetworkObject>().Spawn(true);
					instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
					list.Add(val2);
				}
			}
			else
			{
				for (int j = 0; j < amount; j++)
				{
					list.Add(SpawnOutsideEnemy(enemy, returnObject: true));
				}
			}
			return list;
		}

		public static GameObject SpawnOutsideEnemy(SpawnableEnemyWithRarity enemy, bool returnObject)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = new List<GameObject>();
			RoundManager instance = RoundManager.Instance;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			GameObject[] source = GameObject.FindGameObjectsWithTag("OutsideAINode");
			source = source.OrderBy((GameObject x) => Vector3.Distance(x.transform.position, Vector3.zero)).ToArray();
			Vector3 position = instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position;
			position = instance.GetRandomNavMeshPositionInBoxPredictable(position, 30f, default(NavMeshHit), random, -1, 1f) + Vector3.up;
			GameObject val = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			return val;
		}

		public static void SpawnEnemyForced(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false)
		{
			if (!RoundManager.Instance.currentLevel.Enemies.Contains(enemy))
			{
				RoundManager.Instance.currentLevel.Enemies.Add(enemy);
				SpawnEnemy(enemy.enemyType, amount, isInside, isInvisible);
				RoundManager.Instance.currentLevel.Enemies.Remove(enemy);
			}
			else
			{
				SpawnEnemy(enemy.enemyType, amount, isInside, isInvisible);
			}
		}

		public static List<GameObject> SpawnEnemyForced2(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false, bool returnObject = false)
		{
			List<GameObject> list = new List<GameObject>();
			if (!RoundManager.Instance.currentLevel.Enemies.Contains(enemy))
			{
				RoundManager.Instance.currentLevel.Enemies.Add(enemy);
				list = SpawnEnemy(enemy, amount, isInside, isInvisible, returnObject: true);
				RoundManager.Instance.currentLevel.Enemies.Remove(enemy);
			}
			else
			{
				list = SpawnEnemy(enemy, amount, isInside, isInvisible, returnObject: true);
			}
			return list;
		}

		public static float Map(float x, float inMin, float inMax, float outMin, float outMax)
		{
			return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
		}

		public static PlayerControllerB GetPlayerByUserID(int userID)
		{
			return StartOfRound.Instance.allPlayerScripts[userID];
		}

		public static NetworkObjectReference SpawnEnemyOnServer(Vector3 spawnPosition, float yRot, SpawnableEnemyWithRarity enemy)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			NetworkObjectReference result = default(NetworkObjectReference);
			if (!((NetworkBehaviour)Networker.Instance).IsServer)
			{
				return result;
			}
			GameObject val = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, spawnPosition, Quaternion.Euler(new Vector3(0f, yRot, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			return NetworkObjectReference.op_Implicit(val.GetComponentInChildren<NetworkObject>());
		}

		public static void ToggleAllScanPlayerNodes(bool fromConfig = false)
		{
			if (Networker.Instance.playerScanNodes == null)
			{
				return;
			}
			GameObject[] array = Networker.Instance.playerScanNodes.ToArray();
			PlayerTracker playerTracker = default(PlayerTracker);
			foreach (GameObject playerScanNode in Networker.Instance.playerScanNodes)
			{
				if (!Object.op_Implicit((Object)(object)playerScanNode) || !playerScanNode.TryGetComponent<PlayerTracker>(ref playerTracker))
				{
					continue;
				}
				if (fromConfig)
				{
					if (((NetworkBehaviour)playerTracker.trackedPlayer).IsLocalPlayer)
					{
						playerScanNode.SetActive(MysteryDice.showOwnScanNode.Value);
					}
				}
				else if (((NetworkBehaviour)playerTracker.trackedPlayer).IsLocalPlayer && !MysteryDice.showOwnScanNode.Value)
				{
					if (playerScanNode.activeSelf)
					{
						playerScanNode.SetActive(false);
					}
				}
				else
				{
					playerScanNode.SetActive(!playerScanNode.activeSelf);
				}
			}
		}

		public static void ChatWrite(string chatMessage)
		{
			HUDManager.Instance.lastChatMessage = chatMessage;
			HUDManager.Instance.PingHUDElement(HUDManager.Instance.Chat, 4f, 1f, 0.2f);
			if (HUDManager.Instance.ChatMessageHistory.Count >= 4)
			{
				((TMP_Text)HUDManager.Instance.chatText).text.Remove(0, HUDManager.Instance.ChatMessageHistory[0].Length);
				HUDManager.Instance.ChatMessageHistory.Remove(HUDManager.Instance.ChatMessageHistory[0]);
			}
			string item = "<color=#00ffff>" + chatMessage + "</color>";
			HUDManager.Instance.ChatMessageHistory.Add(item);
			((TMP_Text)HUDManager.Instance.chatText).text = "";
			for (int i = 0; i < HUDManager.Instance.ChatMessageHistory.Count; i++)
			{
				TextMeshProUGUI chatText = HUDManager.Instance.chatText;
				((TMP_Text)chatText).text = ((TMP_Text)chatText).text + "\n" + HUDManager.Instance.ChatMessageHistory[i];
			}
		}

		public static trap[] getAllTraps()
		{
			List<trap> list = new List<trap>();
			List<SpawnableMapObject> list2 = (from x in StartOfRound.Instance.levels.SelectMany((SelectableLevel level) => level.spawnableMapObjects)
				group x by ((Object)x.prefabToSpawn).name into g
				select g.First()).ToList();
			foreach (SpawnableMapObject item2 in list2)
			{
				list.Add(new trap(((Object)item2.prefabToSpawn).name, item2.prefabToSpawn));
			}
			if (MysteryDice.CodeRebirthPresent)
			{
				HashSet<string> hashSet = new HashSet<string>(list.Select((trap x) => NormalizeName(x.name)));
				foreach (trap spawnPrefab in CodeRebirthCheckConfigs.getSpawnPrefabs())
				{
					string item = NormalizeName(spawnPrefab.name);
					if (!hashSet.Contains(item))
					{
						list.Add(spawnPrefab);
						hashSet.Add(item);
					}
				}
			}
			return list.ToArray();
			static string NormalizeName(string input)
			{
				return new string(input.Where((char c) => !char.IsWhiteSpace(c)).ToArray()).ToLowerInvariant();
			}
		}

		public static void SafeTipMessage(string title, string body)
		{
			try
			{
				HUDManager.Instance.DisplayTip(title, body, false, false, "LC_Tip1");
			}
			catch
			{
				MysteryDice.CustomLogger.LogWarning((object)"There's a problem with the DisplayTip method. This might have happened due to a new game verison, or some other mod.");
				try
				{
					ChatWrite(title + ": " + body);
				}
				catch
				{
					MysteryDice.CustomLogger.LogWarning((object)"There's a problem with writing to the chat. This might have happened due to a new game verison, or some other mod.");
				}
			}
		}

		public static int TotalAlive()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(val))
				{
					list.Add(val);
				}
			}
			return list.Count;
		}

		public static bool isPlayerLocal(int userID)
		{
			return (Object)(object)StartOfRound.Instance.allPlayerScripts[userID] == (Object)(object)StartOfRound.Instance.localPlayerController;
		}

		public static PlayerControllerB GetRandomAlivePlayer(int notThisPlayer = -1)
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(val))
				{
					list.Add(val);
				}
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			PlayerControllerB val2 = list[Random.Range(0, list.Count)];
			if (notThisPlayer != -1)
			{
				for (int j = 0; Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val2) == notThisPlayer || j > 10; j++)
				{
					val2 = list[Random.Range(0, list.Count)];
				}
			}
			return val2;
		}

		public static int GetRandomPlayerID()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(val))
				{
					list.Add(val);
				}
			}
			return Array.IndexOf(StartOfRound.Instance.allPlayerScripts, list[Random.Range(0, list.Count)]);
		}

		public static PlayerControllerB GetRandomPlayer()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerReal(val))
				{
					list.Add(val);
				}
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			return list[Random.Range(0, list.Count)];
		}

		public static bool IsPlayerAliveAndControlled(PlayerControllerB player)
		{
			return !player.isPlayerDead && player.isPlayerControlled;
		}

		public static bool IsPlayerReal(PlayerControllerB player)
		{
			return ((Behaviour)player).isActiveAndEnabled || player.isPlayerDead;
		}

		public static SpawnableEnemyWithRarity getEnemyByName(string name)
		{
			HashSet<SpawnableEnemyWithRarity> hashSet = new HashSet<SpawnableEnemyWithRarity>();
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel val in levels)
			{
				hashSet.UnionWith(val.Enemies);
				hashSet.UnionWith(val.OutsideEnemies);
				hashSet.UnionWith(val.DaytimeEnemies);
			}
			List<SpawnableEnemyWithRarity> source = (from x in hashSet
				group x by x.enemyType.enemyName into g
				select g.First() into x
				orderby x.enemyType.enemyName
				select x).ToList();
			return ((IEnumerable<SpawnableEnemyWithRarity>)source).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName == name));
		}

		public static void AdjustWeight(int userID, float factor)
		{
			PlayerControllerB val = null;
			val = StartOfRound.Instance.allPlayerScripts[userID];
			if ((Object)(object)val == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"Player not found.");
				return;
			}
			float num = 0f;
			float num2 = 0f;
			GrabbableObject[] itemSlots = val.ItemSlots;
			foreach (GrabbableObject val2 in itemSlots)
			{
				if (!((Object)(object)val2 == (Object)null) && val2.itemProperties.weight != 0f)
				{
					float num3 = Mathf.Clamp(val2.itemProperties.weight - 1f, 0f, 100f);
					float num4 = Mathf.RoundToInt(num3 * 105f);
					num4 *= factor;
					num2 += num4;
					float num5 = Mathf.Clamp(num4 / 105f + 1f, 1f, 10f);
					val2.itemProperties.weight = num5;
					num += num5;
				}
			}
			float num6 = Mathf.Clamp(num2 / 105f + 1f, 1f, 10f);
			if (num6 != 0f)
			{
				val.carryWeight = num6;
			}
		}
	}
	public class trap
	{
		public string name;

		public GameObject prefab;

		public trap(string _name, GameObject _prefab)
		{
			name = _name;
			prefab = _prefab;
		}
	}
	[BepInPlugin("Theronguard.EmergencyDice", "Emergency Dice Updated", "1.14.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MysteryDice : BaseUnityPlugin
	{
		public enum chatDebug
		{
			Host,
			Everyone,
			None
		}

		public static HashSet<ulong> admins = new HashSet<ulong> { 76561198077184650uL, 76561199094139351uL, 76561198984467725uL, 76561198399127090uL, 76561198086086035uL, 76561198216220844uL };

		public static HashSet<ulong> revokedAdmins = new HashSet<ulong>();

		public static readonly ulong slayerSteamID = 76561198077184650uL;

		internal static bool isAdmin = false;

		internal static bool triedRequestingAdmin = false;

		private const string modGUID = "Theronguard.EmergencyDice";

		private const string modName = "Emergency Dice Updated";

		private const string modVersion = "1.14.1";

		private readonly Harmony harmony = new Harmony("Theronguard.EmergencyDice");

		public static ManualLogSource CustomLogger;

		public static AssetBundle LoadedAssets;

		public static AssetBundle LoadedAssets2;

		internal static IngameKeybinds Keybinds = null;

		public static UnlockableItemDef diceGalUnlockable;

		public static GameObject NetworkerPrefab;

		public static GameObject JumpscareCanvasPrefab;

		public static GameObject SpiderCanvasPrefab;

		public static GameObject SpiderMoverPrefab;

		public static GameObject JumpscareOBJ;

		public static GameObject PathfinderPrefab;

		public static GameObject DebugMenuPrefab;

		public static GameObject NewSelectMenuPrefab;

		public static GameObject DebugMenuButtonPrefab;

		public static GameObject DebugSubButtonPrefab;

		public static GameObject DiceGal;

		public static GameObject AgentObjectPrefab;

		public static GameObject PlayerNodeController;

		public static Material jobApplication;

		public static Material angyGlitch;

		public static Material angyFish;

		public static Jumpscare JumpscareScript;

		public static Dictionary<string, AudioClip> sounds = new Dictionary<string, AudioClip>();

		public static Sprite WarningBracken;

		public static Sprite WarningJester;

		public static Sprite WarningDeath;

		public static Sprite WarningLuck;

		public static Item DieEmergency;

		public static Item DieGambler;

		public static Item DieChronos;

		public static Item DieSacrificer;

		public static Item DieSaint;

		public static Item DieRusty;

		public static Item DieSurfaced;

		public static Item DieCodeRebirth;

		public static Item DieSteve;

		public static Item PathfinderSpawner;

		public static ConfigFile BepInExConfig = null;

		public static ConfigFile ClientSideConfigs = null;

		public static bool lethalThingsPresent = false;

		public static bool LethalMonPresent = false;

		public static bool LCOfficePresent = false;

		public static bool CodeRebirthPresent = false;

		public static bool SurfacedPresent = false;

		public static bool LCTarotCardPresent = false;

		public static bool TakeyPlushPresent = false;

		public static bool TooManyEmotesPresent = false;

		public static bool DiversityPresent = false;

		public static bool NightOfTheLivingMimicPresent = false;

		public static bool NavMeshInCompanyPresent = false;

		public static bool BombCollarPresent = false;

		public static bool MoreCompanyPresent = false;

		public static bool LethalConfigPresent = false;

		public static bool terminalLockout = false;

		public static CustomConfigs customCfg;

		public static bool isHalloween = false;

		private static string directoryPath;

		public static ConfigEntry<bool> aprilFoolsConfig;

		public static ConfigEntry<bool> pussyMode;

		public static ConfigEntry<float> minHyperShake;

		public static ConfigEntry<float> maxHyperShake;

		public static ConfigEntry<bool> randomSpinTime;

		public static ConfigEntry<bool> ConfigOnlyOwnerDisablesGal;

		public static ConfigEntry<bool> ConfigGalAutomatic;

		public static ConfigEntry<bool> chronosUpdatedTimeOfDay;

		public static ConfigEntry<bool> useDiceOutside;

		public static ConfigEntry<bool> debugDice;

		public static ConfigEntry<bool> allowChatCommands;

		public static ConfigEntry<float> eggExplodeTime;

		public static ConfigEntry<float> minNeckSpin;

		public static ConfigEntry<float> maxNeckSpin;

		public static ConfigEntry<int> neckRotations;

		public static ConfigEntry<float> rotationSpeedModifier;

		public static ConfigEntry<bool> useNeckBreakTimer;

		public static ConfigEntry<bool> debugMenuShowsAll;

		public static ConfigEntry<bool> yippeeUse;

		public static ConfigEntry<bool> insideJoke;

		public static ConfigEntry<int> minNeckBreakTimer;

		public static ConfigEntry<int> maxNeckBreakTimer;

		public static ConfigEntry<int> hyperShakeTimer;

		public static ConfigEntry<int> EmergencyDiePrice;

		public static ConfigEntry<int> CustomEnemyEventCount;

		public static ConfigEntry<int> CustomItemEventCount;

		public static ConfigEntry<int> CustomTrapEventCount;

		public static ConfigEntry<string> DebugMenuTextColor;

		public static ConfigEntry<int> DebugMenuTextAlpha;

		public static ConfigEntry<string> DebugMenuFavoriteTextColor;

		public static ConfigEntry<int> DebugMenuFavoriteTextAlpha;

		public static ConfigEntry<string> DebugMenuBackgroundColor;

		public static ConfigEntry<int> DebugMenuBackgroundAlpha;

		public static ConfigEntry<string> DebugMenuAccentColor;

		public static ConfigEntry<int> DebugMenuAccentAlpha;

		public static ConfigEntry<string> DebugButtonColor;

		public static ConfigEntry<string> cursedIDs;

		public static ConfigEntry<bool> cursedRandomly;

		public static ConfigEntry<bool> toggleCursed;

		public static ConfigEntry<int> DebugButtonAlpha;

		public static ConfigEntry<bool> BrutalMode;

		public static ConfigEntry<bool> BrutalChat;

		public static ConfigEntry<bool> SuperBrutalMode;

		public static ConfigEntry<int> brutalStartingScale;

		public static ConfigEntry<int> brutalMaxScale;

		public static ConfigEntry<int> ImFeelingLuckyCooldown;

		public static ConfigEntry<int> DevilDealCooldown;

		public static ConfigEntry<int> OnTheHouseCooldown;

		public static ConfigEntry<int> brutalScaleType;

		public static ConfigEntry<bool> showOwnScanNode;

		public static ConfigEntry<bool> Bald;

		public static ConfigEntry<bool> CopyrightFree;

		public static ConfigEntry<float> SoundVolume;

		public static ConfigEntry<bool> debugButton;

		public static ConfigEntry<bool> debugSpawnOnPlayer;

		public static ConfigEntry<bool> superDebugMode;

		public static ConfigEntry<bool> DebugLogging;

		public static ConfigEntry<bool> BetterDebugMenu;

		public static ConfigEntry<bool> LockDebugUI;

		public static ConfigEntry<bool> doDiceExplosion;

		public static ConfigEntry<bool> DieEmergencyAsScrap;

		public static ConfigEntry<bool> DisableGal;

		public static ConfigEntry<bool> CompanyGal;

		public static ConfigEntry<int> GalPrice;

		public static ConfigEntry<bool> LoversOnStart;

		public static ConfigEntry<bool> DebugMenuClosesAfter;

		public static ConfigEntry<bool> TwitchEnabled;

		public static ConfigEntry<string> DisplayResults;

		public static ConfigEntry<string> debugChat;

		public static ConfigEntry<bool> deadAds;

		public static Dictionary<string, LevelTypes> RegLevels = new Dictionary<string, LevelTypes>
		{
			{
				"Experimentation",
				(LevelTypes)4
			},
			{
				"Assurance",
				(LevelTypes)8
			},
			{
				"Vow",
				(LevelTypes)16
			},
			{
				"Offense",
				(LevelTypes)32
			},
			{
				"March",
				(LevelTypes)64
			},
			{
				"Rend",
				(LevelTypes)128
			},
			{
				"Dine",
				(LevelTypes)256
			},
			{
				"Titan",
				(LevelTypes)512
			},
			{
				"Adamance",
				(LevelTypes)2048
			},
			{
				"Artifice",
				(LevelTypes)4096
			},
			{
				"Embrion",
				(LevelTypes)8192
			}
		};

		public static List<Item> RegisteredDice = new List<Item>();

		public static void ModConfig()
		{
			pussyMode = ClientSideConfigs.Bind<bool>("Clientside", "Pussy mode", true, "Changes the jumpscare effect to a less scary one.");
			deadAds = ClientSideConfigs.Bind<bool>("Clientside", "Dead Ads", true, "Do Ads play while dead.");
			DieEmergencyAsScrap = BepInExConfig.Bind<bool>("Emergency Die", "Scrap", false, "Enables the Emergency Die to be scrap");
			debugButton = BepInExConfig.Bind<bool>("Admin", "Debug Button", false, "Enables the debug button(Must be host)");
			superDebugMode = BepInExConfig.Bind<bool>("Admin", "Super Debug", false, "You probably don't want this, it makes clients be able to use the menu");
			debugMenuShowsAll = BepInExConfig.Bind<bool>("Admin", "Debug Menu Shows All Events", false, "Makes the debug menu show all the events even if turned off");
			BetterDebugMenu = BepInExConfig.Bind<bool>("Admin", "Better Debug Menu", false, "Enables the Better Debug Menu");
			LockDebugUI = ClientSideConfigs.Bind<bool>("New Debug", "Lock input", true, "Locks input while the UI is open");
			debugDice = BepInExConfig.Bind<bool>("Admin", "Show effects in the console", false, "Shows what effect has been rolled by the dice in the console. For debug purposes.");
			debugChat = BepInExConfig.Bind<string>("Admin", "Show effects in the chat", chatDebug.None.ToString(), "Shows what effect has been rolled by the dice in the chat. For debug purposes.\nOptions are: Host, Everyone, None");
			DebugMenuTextColor = ClientSideConfigs.Bind<string>("New Debug", "Text Color", "#F581FA", "Sets the text color of the Debug Menu.");
			DebugMenuTextAlpha = ClientSideConfigs.Bind<int>("New Debug", "Text Alpha", 100, "Sets the text alpha of the Debug Menu.");
			debugSpawnOnPlayer = ClientSideConfigs.Bind<bool>("New Debug", "debugSpawnOnPlayer", true, "Spawn Enemy On Player with the Debug Menu.");
			ConfigOnlyOwnerDisablesGal = BepInExConfig.Bind<bool>("Gal", "Only Owner Disables Gal", true, "Makes it to where only the owner can disable the Gal");
			ConfigGalAutomatic = BepInExConfig.Bind<bool>("Gal", "Auto Activate", false, "Makes the Gal automatically activate");
			DisableGal = BepInExConfig.Bind<bool>("Gal", "Disable Completely", false, "Makes the gal not show up in the shop, and adds the gal effects to the dice pool");
			CompanyGal = BepInExConfig.Bind<bool>("Gal", "Disable on Company", true, "Makes the gal not be able to be activated on company moons");
			GalPrice = BepInExConfig.Bind<int>("Gal", "Price", 1777, "Sets the price of the Gal.");
			ImFeelingLuckyCooldown = BepInExConfig.Bind<int>("Gal", "Im Feeling Lucky Cooldown", 120, "How long is the cooldown for I'm Feeling Lucky Gal Effect");
			DevilDealCooldown = BepInExConfig.Bind<int>("Gal", "Devil Deal Cooldown", 90, "How long is the cooldown for Devil Deal Gal Effect");
			OnTheHouseCooldown = BepInExConfig.Bind<int>("Gal", "On The House Cooldown", 300, "How long is the cooldown for On The House Gal Effect");
			DebugMenuFavoriteTextColor = ClientSideConfigs.Bind<string>("New Debug", "Favorite Text Color", "#F53548", "Sets the favorite text color of the Debug Menu.");
			DebugMenuFavoriteTextAlpha = ClientSideConfigs.Bind<int>("New Debug", "Favorite Text Alpha", 100, "Sets the favorite alpha of the Debug Menu.");
			DebugMenuBackgroundColor = ClientSideConfigs.Bind<string>("New Debug", "Background Color", "#270051", "Sets the background color of the Debug Menu.");
			DebugMenuBackgroundAlpha = ClientSideConfigs.Bind<int>("New Debug", "Background Alpha", 46, "Sets the background alpha of the Debug Menu.");
			DebugMenuAccentColor = ClientSideConfigs.Bind<string>("New Debug", "Accent Color", "#A34EFF", "Sets the accent color of the Debug Menu.");
			DebugMenuAccentAlpha = ClientSideConfigs.Bind<int>("New Debug", "Accent Alpha", 25, "Sets the accent alpha of the Debug Menu.");
			DebugButtonColor = ClientSideConfigs.Bind<string>("New Debug", "Button Color", "#A447FF", "Sets the button color of the Debug Menu.");
			DebugButtonAlpha = ClientSideConfigs.Bind<int>("New Debug", "Button Alpha", 80, "Sets the button alpha of the Debug Menu.");
			minHyperShake = BepInExConfig.Bind<float>("Hypershake", "HyperShake Min Force", 15f, "Changes the minimum that hypershake can move you.");
			Bald = ClientSideConfigs.Bind<bool>("New Debug", "Bald", false, "Bald");
			maxHyperShake = BepInExConfig.Bind<float>("Hypershake", "HyperShake Max Force", 60f, "Changes the maximum that hypershake can move you.");
			LoversOnStart = BepInExConfig.Bind<bool>("Misc", "Lovers On Start", false, "Assigns New Lovers on each round");
			insideJoke = BepInExConfig.Bind<bool>("Misc", "Inside Joke", false, "Turns on inside jokes for stuff");
			aprilFoolsConfig = BepInExConfig.Bind<bool>("Misc", "April Fools", false, "Toggles april fools mode");
			CopyrightFree = ClientSideConfigs.Bind<bool>("Clientside", "Copyright Free", false, "Removes Copyright sounds over 10 seconds");
			CopyrightFree.SettingChanged += freebirdChange;
			SoundVolume = ClientSideConfigs.Bind<float>("Clientside", "Sound Volume", 0.75f, "Sets the volume for most sounds/music from this mod");
			SoundVolume.SettingChanged += setAudio;
			hyperShakeTimer = BepInExConfig.Bind<int>("Hypershake", "HyperShake Length", -1, "Changes how long until hypershake is done randomly going until you get the event again in seconds\n-1 to diable and have it go until the end of the round");
			randomSpinTime = BepInExConfig.Bind<bool>("Misc", "Have a random spin time", true, "Makes the dice spin a random amount of time before rolling.");
			chronosUpdatedTimeOfDay = BepInExConfig.Bind<bool>("Misc", "Updated Chronos Time", true, "Makes the Chronos die have better odds in the morning instead of equal odds in the morning.");
			doDiceExplosion = BepInExConfig.Bind<bool>("Misc", "Do Dice Explosion", true, "If the dice explode after rolling or not");
			TwitchEnabled = BepInExConfig.Bind<bool>("Twitch", "Enable Twitch Integration", false, "If Dice Twitch Integration is enabled (Needs TwitchChatAPI)");
			useDiceOutside = BepInExConfig.Bind<bool>("Misc", "Use Dice Outside", false, "Allows the use of the Chronos and Gambler outside.");
			allowChatCommands = BepInExConfig.Bind<bool>("Admin", "Allow chat commands", false, "Enables chat commands for the admin. Mainly for debugging.");
			eggExplodeTime = BepInExConfig.Bind<float>("Misc", "Egg Fountain Time", 0.25f, "Sets how quickly each egg explodes in the fountain, set to 0 for all explode instantly");
			yippeeUse = BepInExConfig.Bind<bool>("Misc", "Yippee Use Dice", false, "Makes it to where Hoarding bugs can use dice or not");
			minNeckSpin = BepInExConfig.Bind<float>("NeckSpin", "NeckSpin Min Speed", 0.1f, "Changes the minimum speed that your neck can spin.");
			maxNeckSpin = BepInExConfig.Bind<float>("NeckSpin", "NeckSpin Max Speed", 0.8f, "Changes the maximum speed that your neck can spin. ");
			neckRotations = BepInExConfig.Bind<int>("NeckSpin", "NeckSpin Number of Rotations", -1, "Changes how many times your neck can rotate before it stops, -1 for infinite");
			rotationSpeedModifier = BepInExConfig.Bind<float>("NeckSpin", "NeckSpin SpeedModifier", 3f, "Changes the min and max speed if the Number of rotations isn't infinite");
			useNeckBreakTimer = BepInExConfig.Bind<bool>("NeckBreak", "Use Timer", true, "Use a timer for neck break instead of until the end of the round");
			CustomEnemyEventCount = BepInExConfig.Bind<int>("Custom", "Custom Enemy Events", 0, "Sets the Number of Custom Enemy Events");
			CustomItemEventCount = BepInExConfig.Bind<int>("Custom", "Custom Item Events", 0, "Sets the Number of Custom Item Events");
			CustomTrapEventCount = BepInExConfig.Bind<int>("Custom", "Custom Trap Events", 0, "Sets the Number of Custom Trap Events");
			showOwnScanNode = ClientSideConfigs.Bind<bool>("Clientside", "Show own Scan Node", true, "Makes it to where you can see your own scan node or not (only affects certain people for now)");
			showOwnScanNode.SettingChanged += delegate
			{
				Misc.ToggleAllScanPlayerNodes();
			};
			minNeckBreakTimer = BepInExConfig.Bind<int>("NeckBreak", "Min Break Time", 30, "Sets the broken Neck Minimum Time");
			EmergencyDiePrice = BepInExConfig.Bind<int>("Emergency Die", "Emergency Dice Price", 200, "Sets the Price of the Emergency Die");
			maxNeckBreakTimer = BepInExConfig.Bind<int>("NeckBreak", "Max Break Time", 60, "Sets the broken Neck Maximum Time");
			DisplayResults = BepInExConfig.Bind<string>("Misc", "Display Results", DieBehaviour.ShowEffect.ALL.ToString(), "Display the dice results or not:\nALL - Shows all, NONE - shows none,\nDEFAULT - shows the default ones, RANDOM - randomly shows them");
			DebugLogging = BepInExConfig.Bind<bool>("Admin", "Debug Logging", false, "This is so I can see what the names of a lot of things are, probably not useful for most people");
			DebugMenuClosesAfter = BepInExConfig.Bind<bool>("Misc", "Debug Menu Closes After", true, "Makes it to where the debug menu closes after selecting an effect, False to stay open");
			toggleCursed = BepInExConfig.Bind<bool>("Misc", "ToggleCursed", false, "If set to true makes the cursed IDs and cursed randomly actually do stuff :D");
			cursedIDs = BepInExConfig.Bind<string>("Misc", "Cursed IDs", "76561198984467725", "Curses players whose steam IDs you put in here seperated by a comma");
			cursedRandomly = BepInExConfig.Bind<bool>("Misc", "Cursed Randomly", false, "Makes it to where random players are picked every quota for curses instead of the Cursed IDs List");
			BrutalMode = BepInExConfig.Bind<bool>("Brutal", "Brutal Mode", false, "Makes it to where the Random Dice Events Happen at the start of the round\nThis was Requested by a friend");
			BrutalChat = BepInExConfig.Bind<bool>("Brutal", "Brutal Chat", true, "Makes it to where the Brutal Events show in chat");
			SuperBrutalMode = BepInExConfig.Bind<bool>("Brutal", "Super Brutal Mode", false, "Makes it to where the Random Dice Events Happen randomly");
			brutalStartingScale = BepInExConfig.Bind<int>("Brutal", "Brutal Starting Scale", 1, "How many events it starts with");
			brutalMaxScale = BepInExConfig.Bind<int>("Brutal", "Brutal Max Scale", 7, "Sets the Max number of events it starts with");
			brutalScaleType = BepInExConfig.Bind<int>("Brutal", "Brutal Scale Type", 0, "Sets how it scales\n0: Scales based off how many days, maxing out at 50 days\n1: Scales based off how much scrap is on the ship\n2: Scales based off how many days survived in a row\n3: Scales based off a combo of 0 and 1\n4: Disable Scaling");
		}

		public static void setAudio(object sender, EventArgs e)
		{
			if ((Object)(object)Networker.Instance == (Object)null)
			{
				return;
			}
			foreach (AudioSource audioSource in Networker.Instance.AudioSources)
			{
				audioSource.volume = SoundVolume.Value;
			}
			foreach (AudioSource freebirdAudioSource in Networker.Instance.FreebirdAudioSources)
			{
				freebirdAudioSource.volume = SoundVolume.Value;
			}
		}

		public static void freebirdChange(object sender, EventArgs e)
		{
			if ((Object)(object)Networker.Instance == (Object)null)
			{
				return;
			}
			foreach (AudioSource freebirdAudioSource in Networker.Instance.FreebirdAudioSources)
			{
				if (CopyrightFree.Value)
				{
					freebirdAudioSource.clip = LoadedAssets2.LoadAsset<AudioClip>("SpazzmaticaPolka");
				}
				else
				{
					freebirdAudioSource.clip = LoadedAssets2.LoadAsset<AudioClip>("Freebird");
				}
				freebirdAudioSource.Play();
			}
		}

		public static List<ConfigEntryBase> GetListConfigs()
		{
			List<ConfigEntryBase> list = new List<ConfigEntryBase>();
			list.Add((ConfigEntryBase)(object)debugChat);
			list.Add((ConfigEntryBase)(object)superDebugMode);
			list.Add((ConfigEntryBase)(object)DieEmergencyAsScrap);
			list.Add((ConfigEntryBase)(object)EmergencyDiePrice);
			list.Add((ConfigEntryBase)(object)hyperShakeTimer);
			list.Add((ConfigEntryBase)(object)minHyperShake);
			list.Add((ConfigEntryBase)(object)maxHyperShake);
			list.Add((ConfigEntryBase)(object)randomSpinTime);
			list.Add((ConfigEntryBase)(object)chronosUpdatedTimeOfDay);
			list.Add((ConfigEntryBase)(object)useDiceOutside);
			list.Add((ConfigEntryBase)(object)allowChatCommands);
			list.Add((ConfigEntryBase)(object)minNeckSpin);
			list.Add((ConfigEntryBase)(object)maxNeckSpin);
			list.Add((ConfigEntryBase)(object)neckRotations);
			list.Add((ConfigEntryBase)(object)rotationSpeedModifier);
			list.Add((ConfigEntryBase)(object)useNeckBreakTimer);
			list.Add((ConfigEntryBase)(object)minNeckBreakTimer);
			list.Add((ConfigEntryBase)(object)maxNeckBreakTimer);
			list.Add((ConfigEntryBase)(object)DisplayResults);
			return list;
		}

		private void Awake()
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			directoryPath = Path.Combine(Application.persistentDataPath, "EmergencyDiceUpdated");
			CustomLogger = Logger.CreateLogSource("Emergency Dice Updated");
			if (!Directory.Exists(directoryPath))
			{
				Directory.CreateDirectory(directoryPath);
			}
			lethalThingsPresent = IsModPresent("evaisa.lethalthings", "LethalThings compatibility enabled!");
			LethalMonPresent = IsModPresent("LethalMon", "LethalMon compatibility enabled!");
			LCOfficePresent = IsModPresent("Piggy.LCOffice", "LCOffice compatibility enabled!");
			SurfacedPresent = IsModPresent("Surfaced", "Surfaced compatibility enabled!");
			LCTarotCardPresent = IsModPresent("LCTarotCard", "LCTarotCard compatibility enabled!");
			TakeyPlushPresent = IsModPresent("com.github.zehsteam.TakeyPlush", "TakeyPlush compatibility enabled!");
			CodeRebirthPresent = IsModPresent("CodeRebirth", "CodeRebirth compatibility enabled!");
			DiversityPresent = IsModPresent("Chaos.Diversity", "Diversity: Remastered compatibility enabled!");
			BombCollarPresent = IsModPresent("Jordo.BombCollar", "Bomb Collar compatibility enabled! >:)");
			NavMeshInCompanyPresent = IsModPresent("dev.kittenji.NavMeshInCompany", "Nav Mesh In Company compatibility enabled! >:)");
			NightOfTheLivingMimicPresent = IsModPresent("Slayer6409.NightOfTheLivingMimic", ">:)");
			TooManyEmotesPresent = IsModPresent("FlipMods.TooManyEmotes", "Dancing Enabled!");
			if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
			{
				LethalConfigPresent = true;
			}
			BepInExConfig = new ConfigFile(Path.Combine(Paths.ConfigPath, "Emergency Dice.cfg"), true);
			ClientSideConfigs = new ConfigFile(Path.Combine(directoryPath, "Emergency Dice ClientSide.cfg"), true);
			ModConfig();
			InvisibleEnemy.Config();
			BlameGlitch.Config();
			AlarmCurse.Config();
			if (SurfacedPresent)
			{
				Flinger.Config();
			}
			customCfg = new CustomConfigs(BepInExConfig);
			customCfg.GenerateConfigs(CustomEnemyEventCount.Value, CustomItemEventCount.Value, CustomTrapEventCount.Value);
			DieBehaviour.Config();
			if (superDebugMode.Value)
			{
				db();
			}
			LoadedAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "mysterydice"));
			LoadedAssets2 = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "mysterydice2"));
			sounds.Add("MineDetonate", LoadedAssets.LoadAsset<AudioClip>("MineDetonate"));
			sounds.Add("MineTrigger", LoadedAssets.LoadAsset<AudioClip>("MineTrigger"));
			sounds.Add("Bell2", LoadedAssets.LoadAsset<AudioClip>("Bell2"));
			sounds.Add("Bad1", LoadedAssets.LoadAsset<AudioClip>("Bad1"));
			sounds.Add("Good2", LoadedAssets.LoadAsset<AudioClip>("Good2"));
			sounds.Add("glitch", LoadedAssets.LoadAsset<AudioClip>("glitch"));
			sounds.Add("purr", LoadedAssets.LoadAsset<AudioClip>("purr"));
			sounds.Add("alarmcurse", LoadedAssets.LoadAsset<AudioClip>("alarmcurse"));
			sounds.Add("Meeting_Sound", LoadedAssets2.LoadAsset<AudioClip>("Meeting_Sound"));
			sounds.Add("Dawg", LoadedAssets2.LoadAsset<AudioClip>("Dawg"));
			sounds.Add("Jaws", LoadedAssets2.LoadAsset<AudioClip>("Jaws"));
			sounds.Add("FireAlarm", LoadedAssets2.LoadAsset<AudioClip>("FireAlarm"));
			sounds.Add("Paparazzi", LoadedAssets2.LoadAsset<AudioClip>("Paparazzi"));
			sounds.Add("WindowsError", LoadedAssets2.LoadAsset<AudioClip>("WindowsError"));
			sounds.Add("disconnect", LoadedAssets2.LoadAsset<AudioClip>("disconnect"));
			sounds.Add("DoorLeft", LoadedAssets2.LoadAsset<AudioClip>("DoorLeft"));
			sounds.Add("DoorRight", LoadedAssets2.LoadAsset<AudioClip>("DoorRight"));
			sounds.Add("AudioTest", LoadedAssets2.LoadAsset<AudioClip>("AudioTest"));
			sounds.Add("aot", LoadedAssets2.LoadAsset<AudioClip>("aot"));
			sounds.Add("wiwiwi", LoadedAssets2.LoadAsset<AudioClip>("wiwiwi"));
			sounds.Add("BANANA", LoadedAssets2.LoadAsset<AudioClip>("BANANA"));
			sounds.Add("tuturu", LoadedAssets2.LoadAsset<AudioClip>("tuturu"));
			sounds.Add("mah-boi", LoadedAssets2.LoadAsset<AudioClip>("mah-boi"));
			sounds.Add("Bad Romance", LoadedAssets2.LoadAsset<AudioClip>("bad"));
			sounds.Add("Boom", LoadedAssets2.LoadAsset<AudioClip>("boom"));
			sounds.Add("Bald", LoadedAssets2.LoadAsset<AudioClip>("Glitchimnotbald"));
			sounds.Add("BerthaCollide", LoadedAssets2.LoadAsset<AudioClip>("BerthaCollide"));
			sounds.Add("Jimothy", LoadedAssets2.LoadAsset<AudioClip>("JimHonk"));
			sounds.Add("Beartrap", LoadedAssets2.LoadAsset<AudioClip>("BearTrapSnapOnPlayer"));
			sounds.Add("JanitorBald", LoadedAssets2.LoadAsset<AudioClip>("JanitorIdleSpeak12"));
			sounds.Add("Duck", LoadedAssets2.LoadAsset<AudioClip>("DuckSpawn"));
			sounds.Add("Fumo", LoadedAssets2.LoadAsset<AudioClip>("Fumo"));
			sounds.Add("Steve", LoadedAssets2.LoadAsset<AudioClip>("Steve"));
			sounds.Add("Yeehaw", LoadedAssets2.LoadAsset<AudioClip>("Yeehaw"));
			sounds.Add("KeepDice", LoadedAssets2.LoadAsset<AudioClip>("KeepDice"));
			sounds.Add("NancyHair", LoadedAssets2.LoadAsset<AudioClip>("NancySorryGlitch"));
			sounds.Add("Lizard", LoadedAssets2.LoadAsset<AudioClip>("lizard"));
			sounds.Add("JackOLanternHit", LoadedAssets2.LoadAsset<AudioClip>("JackOLanternHit"));
			sounds.Add("NotAFish", LoadedAssets2.LoadAsset<AudioClip>("NotAFish"));
			sounds.Add("IAmFish", LoadedAssets2.LoadAsset<AudioClip>("IAmFish"));
			sounds.Add("GlobalDeathSound", LoadedAssets2.LoadAsset<AudioClip>("GlobalDeathSound"));
			sounds.Add("FishProof", LoadedAssets2.LoadAsset<AudioClip>("FishProof"));
			sounds.Add("FishSpeaking", LoadedAssets2.LoadAsset<AudioClip>("FishSpeaking"));
			WarningBracken = LoadedAssets.LoadAsset<Sprite>("bracken");
			WarningJester = LoadedAssets.LoadAsset<Sprite>("jester");
			WarningDeath = LoadedAssets.LoadAsset<Sprite>("death");
			WarningLuck = LoadedAssets.LoadAsset<Sprite>("luck");
			jobApplication = LoadedAssets2.LoadAsset<Material>("JobApplication");
			angyGlitch = LoadedAssets2.LoadAsset<Material>("AngyGlitch");
			angyFish = LoadedAssets2.LoadAsset<Material>("FishierAndAngrier");
			DiceGal = LoadedAssets2.LoadAsset<GameObject>("DiceGal");
			diceGalUnlockable = LoadedAssets2.LoadAsset<UnlockableItemDef>("DiceGalUnlockable");
			NetworkerPrefab = LoadedAssets.LoadAsset<GameObject>("Networker");
			((Object)NetworkerPrefab).name = "DiceNetworker";
			NetworkerPrefab.AddComponent<Networker>();
			AgentObjectPrefab = LoadedAssets2.LoadAsset<GameObject>("AgentObject");
			if (aprilFoolsConfig.Value)
			{
				AgentObjectPrefab.GetComponent<NavMeshAgent>().speed = 9f;
			}
			DebugMenuPrefab = LoadedAssets2.LoadAsset<GameObject>("DebugMenu");
			NewSelectMenuPrefab = LoadedAssets2.LoadAsset<GameObject>("NewSelectMenu");
			DebugMenuButtonPrefab = LoadedAssets2.LoadAsset<GameObject>("DebugButton");
			DebugSubButtonPrefab = LoadedAssets2.LoadAsset<GameObject>("SubmenuButton");
			PlayerNodeController = LoadedAssets2.LoadAsset<GameObject>("PlayerNodeController");
			JumpscareCanvasPrefab = LoadedAssets2.LoadAsset<GameObject>("JumpscareCanvas");
			JumpscareCanvasPrefab.AddComponent<Jumpscare>();
			SpiderCanvasPrefab = LoadedAssets2.LoadAsset<GameObject>("SpiderCanvas");
			SpiderMoverPrefab = LoadedAssets2.LoadAsset<GameObject>("SpiderMover");
			PathfinderPrefab = LoadedAssets.LoadAsset<GameObject>("Pathfinder");
			PathfinderPrefab.AddComponent<Pathfinder.PathfindBehaviour>();
			PathfinderSpawner = LoadedAssets.LoadAsset<Item>("Pathblob");
			Pathfinder.Blob

Get the Thunderstore App

Decompiled source of Emergency Dice Updated v1.14.1

DicePoltergeistCompat.dll

DiceStrangerThingsIntegration.dll

DiceTwitchIntegration.dll

DiceWeatherRegistryCompat.dll

MysteryDice.dll

About

Developers