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.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using REPOLib.Commands;
using REPOLib.Modules;
using REPOPresents.Chance;
using REPOPresents.Chance.Impl;
using UnityEngine;
using UnityEngine.Events;

[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("REPOPresents")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0")]
[assembly: AssemblyProduct("REPOPresents")]
[assembly: AssemblyTitle("REPOPresents")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace REPOPresents
{
	public static class ConfigValues
	{
		internal static ConfigEntry<int> PresentSpawnRate;

		internal static ConfigEntry<bool> EnableMonsterPresents;

		internal static ConfigEntry<int> TallMonsterPresentSpawnRate;

		internal static ConfigEntry<bool> EnableChancePresents;

		internal static ConfigEntry<int> BigChancePresentSpawnRate;

		internal static ConfigEntry<bool> EnableOnlyGoodOutcomes;

		internal static ConfigEntry<bool> EnableDebug;

		internal static ConfigEntry<bool> EnableDebugLogs;

		public static void Configure(BaseUnityPlugin plugin)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			PresentSpawnRate = plugin.Config.Bind<int>("General", "Present Spawn Rate", 70, new ConfigDescription("The spawn rate of presents in %, can be used to reduce the spawning compared to other valuables at same volume type. (Recommended value = 70%)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			EnableMonsterPresents = plugin.Config.Bind<bool>("Monster Presents", "Enable Monster Presents", true, new ConfigDescription("Enable monster variants of specific presents. (Recommended value = true)", (AcceptableValueBase)null, Array.Empty<object>()));
			TallMonsterPresentSpawnRate = plugin.Config.Bind<int>("Monster Presents", "Tall Monster Present Spawn Rate", 50, new ConfigDescription("The spawn rate of the tall monster present in %. (Recommended value = 50%)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			EnableChancePresents = plugin.Config.Bind<bool>("Chance Presents", "Enable Chance Presents", true, new ConfigDescription("Enable chance variants of specific presents. (Recommended value = true)", (AcceptableValueBase)null, Array.Empty<object>()));
			BigChancePresentSpawnRate = plugin.Config.Bind<int>("Chance Presents", "Big Chance Present Spawn Rate", 50, new ConfigDescription("The spawn rate of the big chance present in %. (Recommended value = 50%)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			EnableOnlyGoodOutcomes = plugin.Config.Bind<bool>("Chance Presents", "Enable Good Outcomes Only", false, new ConfigDescription("Enable chance present to roll only good outcomes. (Recommended value = false)", (AcceptableValueBase)null, Array.Empty<object>()));
			EnableDebug = plugin.Config.Bind<bool>("Debug", "Enable Debug Mode", false, new ConfigDescription("Will replace all valuables with presents for testing :) (Recommended value = false)", (AcceptableValueBase)null, Array.Empty<object>()));
			EnableDebugLogs = plugin.Config.Bind<bool>("Debug", "Enable Debug Logs", false, new ConfigDescription("Log debug messages (Recommended value = false)", (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	public class GoofyEyes : MonoBehaviour
	{
		private static Vector3 CROUCH_EYE_MODIFIER = new Vector3(0f, -0.85f, 0f);

		private static Vector3 TUMBLE_EYE_MODIFIER = new Vector3(0f, -1.85f, 0f);

		public Transform eyeLeft;

		public Transform eyeRight;

		public Transform pupilLeft;

		public Transform pupilRight;

		[Space]
		public MeshRenderer[] eyeRenderers;

		public MeshRenderer[] pupilRenderers;

		[Space]
		public Transform lookAt;

		[Space]
		public SpringQuaternion springQuaternionLeft;

		public SpringQuaternion springQuaternionRight;

		private Vector3 lookAtIdle;

		private PlayerAvatar lockedInAvatar;

		private float coolDownClosestPlayer = 1f;

		private float pupilSizeMultiplierTarget = 1f;

		private float pupilSizeMultiplierTimer = 0f;

		private float pupilSizeMultiplierTimerStart = 0f;

		private float pupilSizeMultiplierPreviousTarget = 1f;

		private float pupilSizeMultiplier = 1f;

		private Material eyeMaterial;

		private Material pupilMaterial;

		private int materialHurtAmount;

		private int materialHurtColor;

		private void Awake()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			MeshRenderer[] array = eyeRenderers;
			foreach (MeshRenderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)eyeMaterial))
				{
					eyeMaterial = ((Renderer)val).material;
				}
				((Renderer)val).material = eyeMaterial;
			}
			MeshRenderer[] array2 = pupilRenderers;
			foreach (MeshRenderer val2 in array2)
			{
				if (!Object.op_Implicit((Object)(object)pupilMaterial))
				{
					pupilMaterial = ((Renderer)val2).material;
				}
				((Renderer)val2).material = pupilMaterial;
			}
			lookAtIdle = lookAt.position;
			materialHurtColor = Shader.PropertyToID("_ColorOverlay");
			materialHurtAmount = Shader.PropertyToID("_ColorOverlayAmount");
		}

		private void Update()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			if (coolDownClosestPlayer > 0f)
			{
				coolDownClosestPlayer -= Time.deltaTime;
			}
			else
			{
				PlayerAvatar val = null;
				float num = float.MaxValue;
				foreach (PlayerAvatar item in SemiFunc.PlayerGetAllPlayerAvatarWithinRange(10f, ((Component)this).gameObject.transform.position, false, default(LayerMask)))
				{
					float num2 = Vector3.Distance(((Component)this).gameObject.transform.position, ((Component)item).transform.position);
					if (num2 < num)
					{
						num = num2;
						val = item;
					}
				}
				lockedInAvatar = val;
				coolDownClosestPlayer = 3f;
			}
			if ((Object)(object)lockedInAvatar != (Object)null)
			{
				Vector3 val2 = Vector3.zero;
				if (lockedInAvatar.isCrouching || lockedInAvatar.isCrawling)
				{
					val2 = CROUCH_EYE_MODIFIER;
				}
				else if (lockedInAvatar.isTumbling)
				{
					val2 = TUMBLE_EYE_MODIFIER;
				}
				((Component)lookAt).transform.position = Vector3.Lerp(((Component)lockedInAvatar.playerAvatarVisuals.playerEyes.eyeLeft).transform.position + val2, ((Component)lockedInAvatar.playerAvatarVisuals.playerEyes.eyeRight).transform.position + val2, 0.5f);
			}
			else
			{
				((Component)lookAt).transform.position = lookAtIdle;
			}
			if (pupilSizeMultiplierTimer > 0f)
			{
				pupilSizeMultiplierTimer = Mathf.Max(pupilSizeMultiplierTimer - Time.fixedDeltaTime, 0f);
				pupilSizeMultiplier = Mathf.Lerp(pupilSizeMultiplierPreviousTarget, pupilSizeMultiplierTarget, (pupilSizeMultiplierTimerStart - pupilSizeMultiplierTimer) / pupilSizeMultiplierTimerStart);
			}
			else
			{
				pupilSizeMultiplier = pupilSizeMultiplierTarget;
			}
			pupilLeft.localScale = Vector3.one * pupilSizeMultiplier;
			pupilRight.localScale = Vector3.one * pupilSizeMultiplier;
			EyeLookAt(ref eyeRight, ref springQuaternionRight, _useSpring: true, 50f, 30f);
			EyeLookAt(ref eyeLeft, ref springQuaternionLeft, _useSpring: true, 50f, 30f);
		}

		private void EyeLookAt(ref Transform _eyeTransform, ref SpringQuaternion _springQuaternion, bool _useSpring, float _clampX, float _clamY)
		{
			//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_000f: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation = _eyeTransform.localRotation;
			Vector3 val = SemiFunc.ClampDirection(lookAt.position - ((Component)_eyeTransform).transform.position, lookAt.forward, _clampX);
			_eyeTransform.rotation = Quaternion.LookRotation(val);
			float num = _eyeTransform.localEulerAngles.y;
			if (num > _clamY && num < 180f)
			{
				num = _clamY;
			}
			else if (num < 360f - _clamY && num > 180f)
			{
				num = 360f - _clamY;
			}
			else if (num < 0f - _clamY)
			{
				num = 0f - _clamY;
			}
			_eyeTransform.localEulerAngles = new Vector3(_eyeTransform.localEulerAngles.x, num, _eyeTransform.localEulerAngles.z);
			Quaternion localRotation2 = _eyeTransform.localRotation;
			_eyeTransform.localRotation = localRotation;
			if (_useSpring)
			{
				_eyeTransform.localRotation = SemiFunc.SpringQuaternionGet(_springQuaternion, localRotation2, -1f);
			}
			else
			{
				_eyeTransform.localRotation = localRotation2;
			}
		}

		public void SetPupilSizeMultiplierTarget(float target, float time)
		{
			pupilSizeMultiplierPreviousTarget = pupilSizeMultiplierTarget;
			pupilSizeMultiplierTarget = target;
			pupilSizeMultiplierTimer = time;
			pupilSizeMultiplierTimerStart = time;
		}

		public void SetEyeColor(Color eyeColor, float num)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			eyeMaterial.SetFloat(materialHurtAmount, num);
			eyeMaterial.SetColor(materialHurtColor, eyeColor);
		}

		public void SetPupilColor(Color pupilColor, float num)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			pupilMaterial.SetFloat(materialHurtAmount, num);
			pupilMaterial.SetColor(materialHurtColor, pupilColor);
		}
	}
	[BepInPlugin("REPOPresents", "REPOPresents", "1.3.0")]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(ValuableDirector), "Spawn")]
		internal static class ValuableDirectorSpawnPatch
		{
			private static bool Prefix(ref GameObject _valuable, ValuableVolume _volume, string _path)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				if (ConfigValues.EnableDebug.Value)
				{
					GameObject debugObjectForType = Instance.GetDebugObjectForType(_volume.VolumeType);
					if ((Object)(object)debugObjectForType != (Object)null)
					{
						_valuable = debugObjectForType;
						return true;
					}
				}
				ValuablePresent component = _valuable.GetComponent<ValuablePresent>();
				ValuablePresentEnemy component2 = _valuable.GetComponent<ValuablePresentEnemy>();
				ValuablePresentChance component3 = _valuable.GetComponent<ValuablePresentChance>();
				if ((Object)(object)component != (Object)null || (Object)(object)component2 != (Object)null || (Object)(object)component3 != (Object)null)
				{
					int value = ConfigValues.PresentSpawnRate.Value;
					if ((Object)(object)component2 != (Object)null)
					{
						value = ConfigValues.TallMonsterPresentSpawnRate.Value;
					}
					else if ((Object)(object)component3 != (Object)null)
					{
						value = ConfigValues.BigChancePresentSpawnRate.Value;
					}
					float num = 1f - (float)value / 100f;
					if (Random.value < num)
					{
						List<GameObject> valuablesByVolumeType = ValuableUtil.GetValuablesByVolumeType(RunManager.instance.levelCurrent, _volume.VolumeType);
						if (valuablesByVolumeType.Count > 0)
						{
							GameObject val = valuablesByVolumeType[Random.Range(0, valuablesByVolumeType.Count)];
							if ((Object)(object)val != (Object)null)
							{
								DebugLog("Replaced " + ((Object)_valuable).name + " with " + ((Object)val).name);
								_valuable = val;
							}
						}
					}
				}
				return true;
			}

			private static void Postfix(GameObject _valuable)
			{
				DebugLog("Spawned : " + ((Object)_valuable).name);
			}
		}

		private static readonly string ENEMY_VALUABLE = "Valuable Present Tall (Enemy)";

		private static readonly string CHANCE_VALUABLE = "Valuable Present Big (Chance)";

		private static readonly string[] BUNDLED_VALUABLES = new string[7] { "Valuable Present Tiny", "Valuable Present Small", "Valuable Present Medium", "Valuable Present Big", "Valuable Present Tall", CHANCE_VALUABLE, ENEMY_VALUABLE };

		private readonly Harmony _harmony = new Harmony("REPOPresents");

		internal static ManualLogSource Logger;

		private Dictionary<string, GameObject> registeredPrefabs = new Dictionary<string, GameObject>();

		private Dictionary<Type, GameObject> debugVolumeTypes = new Dictionary<Type, GameObject>();

		internal static Plugin Instance { get; private set; }

		private void Awake()
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Logger = ((BaseUnityPlugin)this).Logger;
			ConfigValues.Configure((BaseUnityPlugin)(object)this);
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Instance).Info.Location), "presents_assets.file"));
			string[] bUNDLED_VALUABLES = BUNDLED_VALUABLES;
			foreach (string text in bUNDLED_VALUABLES)
			{
				if ((!(text == ENEMY_VALUABLE) || ConfigValues.EnableMonsterPresents.Value) && (!(text == CHANCE_VALUABLE) || ConfigValues.EnableChancePresents.Value))
				{
					GameObject val2 = val.LoadAsset<GameObject>(text);
					Valuables.RegisterValuable(val2);
					ValuableObject component = val2.GetComponent<ValuableObject>();
					if ((Object)(object)component != (Object)null && !debugVolumeTypes.ContainsKey(component.volumeType))
					{
						debugVolumeTypes.Add(component.volumeType, val2);
					}
					registeredPrefabs.Add(text, val2);
					Logger.LogInfo((object)("Registered: " + text));
				}
			}
			_harmony.PatchAll(typeof(ValuableDirectorSpawnPatch));
			Logger.LogInfo((object)"Plugin REPOPresents is loaded!");
		}

		public bool WasRegisteredBySelf(GameObject gameObject)
		{
			return registeredPrefabs.ContainsValue(gameObject);
		}

		public GameObject GetDebugObjectForType(Type type)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!debugVolumeTypes.ContainsKey(type))
			{
				return null;
			}
			return debugVolumeTypes[type];
		}

		public static void DebugLog(object data)
		{
			if (ConfigValues.EnableDebugLogs.Value)
			{
				Logger.LogInfo(data);
			}
		}
	}
	public class ValuablePresent : MonoBehaviour
	{
		private PhysGrabObject physGrabObject;

		private ValuableObject valuableObject;

		private ParticleSystem particles;

		private bool particlesPlaying;

		private List<GameObject> potentialItems;

		private bool wasReplaced = false;

		private void Awake()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			valuableObject = ((Component)this).GetComponent<ValuableObject>();
			physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
			particles = ((Component)this).GetComponentInChildren<ParticleSystem>();
			potentialItems = ValuableUtil.GetValuablesByVolumeType(RunManager.instance.levelCurrent, valuableObject.volumeType);
		}

		private void Update()
		{
			if ((Object)(object)particles != (Object)null)
			{
				if (physGrabObject.grabbed)
				{
					if (!particlesPlaying)
					{
						particles.Play();
						particlesPlaying = true;
					}
				}
				else if (particlesPlaying)
				{
					particles.Stop();
					particlesPlaying = false;
				}
			}
			if (physGrabObject.grabbedLocal)
			{
				PlayerAvatar instance = PlayerAvatar.instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.OverridePupilSize(3f, 4, 1f, 1f, 5f, 0.5f, 0.1f);
				}
			}
		}

		public GameObject FindReplacement()
		{
			if (potentialItems == null)
			{
				return null;
			}
			int num = 0;
			GameObject val = null;
			while ((Object)(object)val == (Object)null && potentialItems.Count > 0 && num < 5)
			{
				GameObject val2 = potentialItems[Random.Range(0, potentialItems.Count)];
				if (!Plugin.Instance.WasRegisteredBySelf(val2))
				{
					val = val2;
				}
				num++;
			}
			return val;
		}

		public void OnDestroy()
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)particles != (Object)null && particlesPlaying)
			{
				particles.Stop();
				particlesPlaying = false;
			}
			if (!SemiFunc.IsMasterClientOrSingleplayer() || wasReplaced)
			{
				return;
			}
			wasReplaced = true;
			GameObject val = FindReplacement();
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogError((object)"Failed to find suitable item");
				return;
			}
			ValuableObject val2 = Valuables.GetValuableByName(((Object)val).name);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = val.GetComponent<ValuableObject>();
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Logger.LogError((object)("Item is missing ValuableObject: " + ((Object)val).name));
					return;
				}
			}
			if (!SemiFunc.IsMultiplayer())
			{
				Object.Instantiate<GameObject>(val, ((Component)this).gameObject.transform.position, ((Component)this).gameObject.transform.rotation);
			}
			else
			{
				Valuables.SpawnValuable(val2, ((Component)this).gameObject.transform.position, ((Component)this).gameObject.transform.rotation);
			}
		}
	}
	public class ValuablePresentChance : MonoBehaviour
	{
		private static int MAX_ENTRY_ATTEMPTS = 5;

		private PhysGrabObject physGrabObject;

		private ValuablePresentChanceNetwork network;

		private ValuableObject valuableObject;

		private Type overriddenChanceEntry = null;

		private bool wasReplaced = false;

		[HideInInspector]
		public PlayerAvatar lastPlayerGrabbed;

		private void Awake()
		{
			physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
			network = ((Component)this).GetComponent<ValuablePresentChanceNetwork>();
			valuableObject = ((Component)this).GetComponent<ValuableObject>();
		}

		private void Update()
		{
			if (physGrabObject.grabbedLocal)
			{
				PlayerAvatar instance = PlayerAvatar.instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.OverridePupilSize(3f, 4, 1f, 1f, 5f, 0.5f, 0.1f);
				}
			}
			if ((Object)(object)physGrabObject.lastPlayerGrabbing != (Object)null && (Object)(object)physGrabObject.lastPlayerGrabbing != (Object)(object)lastPlayerGrabbed)
			{
				lastPlayerGrabbed = physGrabObject.lastPlayerGrabbing;
			}
		}

		public void OnDestroy()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() || wasReplaced)
			{
				return;
			}
			wasReplaced = true;
			if (valuableObject.dollarValueCurrent >= valuableObject.dollarValueOriginal * 0.15f)
			{
				Plugin.DebugLog("Not rolling chance due to not fully broken");
				return;
			}
			PlayerAvatar val = lastPlayerGrabbed;
			if ((Object)(object)val == (Object)null)
			{
				List<PlayerAvatar> list = SemiFunc.PlayerGetAllPlayerAvatarWithinRange(10f, ((Component)this).gameObject.transform.position, false, default(LayerMask));
				if (list.Count == 0)
				{
					Plugin.Logger.LogWarning((object)"Last player grab is null and no players within range");
					return;
				}
				val = list[0];
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Logger.LogWarning((object)"Last player grab is null and no players within range");
					return;
				}
				Plugin.DebugLog("Using roller from range " + val.playerName);
			}
			if ((Object)(object)network == (Object)null)
			{
				Plugin.Logger.LogError((object)"Network is null");
				return;
			}
			for (int i = 0; i < MAX_ENTRY_ATTEMPTS; i++)
			{
				IChanceEntry chanceEntry = ((!(overriddenChanceEntry != null)) ? GetRandomChanceEntry() : ((IChanceEntry)Activator.CreateInstance(overriddenChanceEntry)));
				if (chanceEntry == null)
				{
					Plugin.Logger.LogError((object)$"Failed to find chance entry (attempt {i})");
					continue;
				}
				if (!chanceEntry.Execute(val, network))
				{
					Plugin.Logger.LogWarning((object)$"Failed to execute chance entry {chanceEntry.GetType().Name} (attempt {i})");
					continue;
				}
				var (text, chatID, color) = chanceEntry.GetChatMessage();
				if (text != null)
				{
					network.PossessChat(val, chatID, text, color);
				}
				break;
			}
		}

		public void OverrideChanceEntry(Type chanceEntry)
		{
			overriddenChanceEntry = chanceEntry;
		}

		private static IChanceEntry GetRandomChanceEntry()
		{
			Dictionary<(ChanceRegistry.Outcome, Type), int> availableEntries = ChanceRegistry.GetAvailableEntries();
			int num = availableEntries.Values.Sum();
			int num2 = Random.Range(0, num);
			int num3 = 0;
			foreach (KeyValuePair<(ChanceRegistry.Outcome, Type), int> item in availableEntries)
			{
				num3 += item.Value;
				if (num2 < num3)
				{
					return (IChanceEntry)Activator.CreateInstance(item.Key.Item2);
				}
			}
			return null;
		}
	}
	public class ValuablePresentChanceNetwork : MonoBehaviour
	{
		private PhotonView photonView;

		private void Awake()
		{
			photonView = ((Component)this).GetComponent<PhotonView>();
		}

		public void PossessChat(PlayerAvatar player, PossessChatID chatID, string message, Color color)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_008f: 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_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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMultiplayer() && !player.photonView.IsMine)
			{
				photonView.RPC("PossessChatRPC", player.photonView.Owner, new object[5] { chatID, message, color.r, color.g, color.b });
			}
			else
			{
				PossessChatRPC(chatID, message, color.r, color.g, color.b);
			}
		}

		[PunRPC]
		public void PossessChatRPC(PossessChatID chatID, string message, float r, float g, float b)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ChatManager.instance.PossessChatScheduleStart(10);
			ChatManager.instance.PossessChat(chatID, message, 1f, new Color(r, g, b), 0f, false, 0, (UnityEvent)null);
			ChatManager.instance.PossessChatScheduleEnd();
		}

		public void Teleport(PlayerAvatar player, Vector3 position)
		{
			//IL_004e: 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)
			if (SemiFunc.IsMultiplayer() && !player.photonView.IsMine)
			{
				photonView.RPC("TeleportRPC", player.photonView.Owner, new object[1] { position });
			}
			else
			{
				TeleportRPC(position);
			}
		}

		[PunRPC]
		public void TeleportRPC(Vector3 position)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			((Component)PlayerController.instance).transform.position = position;
		}

		public void SetScale(int viewID, Vector3 scale)
		{
			//IL_0003: 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)
			SetScaleRPC(viewID, scale);
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("SetScaleRPC", (RpcTarget)1, new object[2] { viewID, scale });
			}
		}

		[PunRPC]
		public void SetScaleRPC(int viewID, Vector3 scale)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			PhotonView val = PhotonView.Find(viewID);
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).transform.localScale = new Vector3(((Component)val).transform.localScale.x * scale.x, ((Component)val).transform.localScale.y * scale.y, ((Component)val).transform.localScale.z * scale.z);
			}
		}
	}
	public class ValuablePresentChanceVariant : MonoBehaviour
	{
		public string valuableName;
	}
	public class ValuablePresentEnemy : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <SpawnEnemyAfterTime>d__22 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnemySetup enemySetup;

			public Vector3 position;

			public TimeSpan timeSpan;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds((float)timeSpan.TotalSeconds);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Enemies.SpawnEnemy(enemySetup, position, Quaternion.identity, 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();
			}
		}

		private const float PUPIL_SIZE_INTERVAL = 0.5f;

		private const float AGGRESSIVE_INTERVAL = 10f;

		private const float GRAB_INTERVAL = 45f;

		public Sound aggressive;

		private PhysGrabObject physGrabObject;

		private PhysGrabObjectImpactDetector physGrabObjectImpactDetector;

		private ValuableObject valuableObject;

		private GoofyEyes[] eyes;

		private Rigidbody rb;

		private bool isGrabActive = false;

		private bool isAggressive = false;

		private bool wasAggressiveDestroyed = false;

		private bool wasReplaced = false;

		private float grabTimer = 0f;

		private float timeToApplyForce = 0f;

		private List<EnemySetup> potentialEnemies;

		private void Awake()
		{
			physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
			physGrabObjectImpactDetector = ((Component)this).GetComponent<PhysGrabObjectImpactDetector>();
			valuableObject = ((Component)this).GetComponent<ValuableObject>();
			eyes = ((Component)this).GetComponentsInChildren<GoofyEyes>(true);
			rb = ((Component)this).GetComponent<Rigidbody>();
			potentialEnemies = FindPotentialEnemies();
		}

		private void Start()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			GoofyEyes[] array = eyes;
			foreach (GoofyEyes goofyEyes in array)
			{
				goofyEyes.SetEyeColor(Color.white, 1f);
			}
		}

		private void Update()
		{
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			if (physGrabObject.grabbed)
			{
				if (!isGrabActive && grabTimer <= 0f)
				{
					isGrabActive = true;
					grabTimer = 45f;
					GoofyEyes[] array = eyes;
					foreach (GoofyEyes goofyEyes in array)
					{
						goofyEyes.SetPupilSizeMultiplierTarget(3f, 0.5f);
					}
				}
				grabTimer = Mathf.Max(grabTimer - Time.fixedDeltaTime, 0f);
				if (isGrabActive && grabTimer <= 10f)
				{
					if (!isAggressive)
					{
						isAggressive = true;
						GoofyEyes[] array2 = eyes;
						foreach (GoofyEyes goofyEyes2 in array2)
						{
							goofyEyes2.SetPupilSizeMultiplierTarget(1f, 5f);
							goofyEyes2.SetEyeColor(Color.red, 1f);
						}
					}
					if (isAggressive)
					{
						GameDirector.instance.CameraImpact.ShakeDistance(1.5f, 1f, 6f, ((Component)this).transform.position, 0.02f);
					}
					if (grabTimer <= 0f)
					{
						isGrabActive = false;
						isAggressive = false;
						wasAggressiveDestroyed = true;
						grabTimer = 0f;
						GoofyEyes[] array3 = eyes;
						foreach (GoofyEyes goofyEyes3 in array3)
						{
							goofyEyes3.SetPupilSizeMultiplierTarget(1f, 0f);
							goofyEyes3.SetEyeColor(Color.white, 1f);
						}
						if (SemiFunc.IsMasterClientOrSingleplayer())
						{
							physGrabObjectImpactDetector.DestroyObject(true);
						}
					}
				}
			}
			else if (grabTimer > 0f)
			{
				isGrabActive = false;
				isAggressive = false;
				grabTimer = 0f;
				GoofyEyes[] array4 = eyes;
				foreach (GoofyEyes goofyEyes4 in array4)
				{
					goofyEyes4.SetPupilSizeMultiplierTarget(1f, 0.5f);
					goofyEyes4.SetEyeColor(Color.white, 1f);
				}
			}
			if (physGrabObject.grabbedLocal)
			{
				PlayerAvatar instance = PlayerAvatar.instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.OverridePupilSize(3f, 4, 1f, 1f, 5f, 0.5f, 0.1f);
				}
			}
			aggressive.PlayLoop(isAggressive, 1f, 1f, 1f);
		}

		private void FixedUpdate()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//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)
			//IL_0087: 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)
			if (SemiFunc.IsMasterClientOrSingleplayer() && isAggressive)
			{
				if (timeToApplyForce > 0f)
				{
					timeToApplyForce -= Time.deltaTime;
					return;
				}
				timeToApplyForce = 1f;
				float num = Random.Range(0.8f, 2f);
				rb.AddForce(Vector3.up * num, (ForceMode)1);
				Vector3 insideUnitSphere = Random.insideUnitSphere;
				Vector3 normalized = ((Vector3)(ref insideUnitSphere)).normalized;
				rb.AddTorque(normalized * 6f, (ForceMode)1);
			}
		}

		private List<EnemySetup> FindPotentialEnemies()
		{
			List<EnemySetup> list = new List<EnemySetup>();
			foreach (EnemySetup item in EnemyDirector.instance.enemiesDifficulty3)
			{
				if (!((Object)item).name.Contains("Group"))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public void OnDestroy()
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() || wasReplaced)
			{
				return;
			}
			wasReplaced = true;
			if (valuableObject.dollarValueCurrent >= valuableObject.dollarValueOriginal * 0.15f && !wasAggressiveDestroyed)
			{
				Plugin.DebugLog("Not spawning enemy due to not fully broken");
				return;
			}
			if (potentialEnemies.Count == 0)
			{
				Plugin.Logger.LogError((object)"No valid enemies to spawn");
				return;
			}
			EnemySetup val = potentialEnemies[Random.Range(0, potentialEnemies.Count)];
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogError((object)"Failed to find suitable enemy");
			}
			else
			{
				((MonoBehaviour)EnemyDirector.instance).StartCoroutine(SpawnEnemyAfterTime(val, ((Component)this).gameObject.transform.position, TimeSpan.FromSeconds(3.0)));
			}
		}

		[IteratorStateMachine(typeof(<SpawnEnemyAfterTime>d__22))]
		private static IEnumerator SpawnEnemyAfterTime(EnemySetup enemySetup, Vector3 position, TimeSpan timeSpan)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnEnemyAfterTime>d__22(0)
			{
				enemySetup = enemySetup,
				position = position,
				timeSpan = timeSpan
			};
		}
	}
	public class ValuablePresentEnemyVariant : MonoBehaviour
	{
		public string valuableName;
	}
	public static class ValuableUtil
	{
		public static List<GameObject> GetValuablesByVolumeType(Level level, Type volumeType)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected I4, but got Unknown
			List<GameObject> list = new List<GameObject>();
			foreach (LevelValuables valuablePreset in level.ValuablePresets)
			{
				Type val = volumeType;
				Type val2 = val;
				switch ((int)val2)
				{
				case 0:
					list.AddRange(valuablePreset.tiny);
					break;
				case 1:
					list.AddRange(valuablePreset.small);
					break;
				case 2:
					list.AddRange(valuablePreset.medium);
					break;
				case 3:
					list.AddRange(valuablePreset.big);
					break;
				case 4:
					list.AddRange(valuablePreset.wide);
					break;
				case 5:
					list.AddRange(valuablePreset.tall);
					break;
				case 6:
					list.AddRange(valuablePreset.veryTall);
					break;
				default:
					Plugin.Logger.LogError((object)("Unhandled volume type: " + ((object)(Type)(ref volumeType)).ToString()));
					break;
				}
			}
			return list;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "REPOPresents";

		public const string PLUGIN_NAME = "REPOPresents";

		public const string PLUGIN_VERSION = "1.3.0";
	}
}
namespace REPOPresents.Chance
{
	internal static class ChanceRegistry
	{
		public enum Outcome
		{
			Good,
			Bad
		}

		public static readonly Dictionary<(Outcome, Type), int> MULTIPLAYER = new Dictionary<(Outcome, Type), int>
		{
			{
				(Outcome.Good, typeof(HealRandomPlayer)),
				4
			},
			{
				(Outcome.Bad, typeof(HurtRandomPlayer)),
				4
			},
			{
				(Outcome.Bad, typeof(TeleportRandomPlayer)),
				4
			},
			{
				(Outcome.Good, typeof(ReviveRandomPlayer)),
				4
			},
			{
				(Outcome.Good, typeof(ReviveAllPlayers)),
				3
			}
		};

		public static readonly Dictionary<(Outcome, Type), int> SINGLEPLAYER = new Dictionary<(Outcome, Type), int>();

		public static readonly Dictionary<(Outcome, Type), int> SHARED = new Dictionary<(Outcome, Type), int>
		{
			{
				(Outcome.Good, typeof(HealRoller)),
				4
			},
			{
				(Outcome.Bad, typeof(HurtRoller)),
				4
			},
			{
				(Outcome.Bad, typeof(TeleportRoller)),
				4
			},
			{
				(Outcome.Good, typeof(SpawnRandomValuable)),
				4
			},
			{
				(Outcome.Bad, typeof(BreakRandomValuable)),
				3
			},
			{
				(Outcome.Good, typeof(IncreaseValuableWorth)),
				4
			},
			{
				(Outcome.Good, typeof(IncreaseAllValuableWorthTenPercent)),
				3
			},
			{
				(Outcome.Good, typeof(IncreaseAllValuableWorthTwentyPercent)),
				1
			},
			{
				(Outcome.Bad, typeof(DecreaseAllValuableWorthTenPercent)),
				3
			},
			{
				(Outcome.Bad, typeof(SpawnEnemy)),
				2
			},
			{
				(Outcome.Bad, typeof(SpawnMiniEnemy)),
				2
			},
			{
				(Outcome.Good, typeof(SpawnRandomUpgradeItem)),
				3
			},
			{
				(Outcome.Good, typeof(SpawnRandomHealthPack)),
				3
			},
			{
				(Outcome.Good, typeof(SpawnRandomDroneItem)),
				1
			}
		};

		public static readonly Dictionary<string, Type> NAME_TO_TYPED_ENTRY = new Dictionary<string, Type>
		{
			{
				"heal roller",
				typeof(HealRoller)
			},
			{
				"hurt roller",
				typeof(HurtRoller)
			},
			{
				"teleport roller",
				typeof(TeleportRoller)
			},
			{
				"heal random player",
				typeof(HealRandomPlayer)
			},
			{
				"hurt random player",
				typeof(HurtRandomPlayer)
			},
			{
				"teleport random player",
				typeof(TeleportRandomPlayer)
			},
			{
				"revive random player",
				typeof(ReviveRandomPlayer)
			},
			{
				"spawn random valuable",
				typeof(SpawnRandomValuable)
			},
			{
				"break random valuable",
				typeof(BreakRandomValuable)
			},
			{
				"increase valuable worth",
				typeof(IncreaseValuableWorth)
			},
			{
				"increase all valuable worth",
				typeof(IncreaseAllValuableWorthTenPercent)
			},
			{
				"increase all valuable worth 20",
				typeof(IncreaseAllValuableWorthTwentyPercent)
			},
			{
				"decrease all valuable worth",
				typeof(DecreaseAllValuableWorthTenPercent)
			},
			{
				"spawn enemy",
				typeof(SpawnEnemy)
			},
			{
				"spawn mini enemy",
				typeof(SpawnMiniEnemy)
			},
			{
				"nothing",
				typeof(Nothing)
			},
			{
				"spawn random upgrade",
				typeof(SpawnRandomUpgradeItem)
			},
			{
				"spawn random drone",
				typeof(SpawnRandomDroneItem)
			},
			{
				"spawn random health",
				typeof(SpawnRandomHealthPack)
			},
			{
				"revive all players",
				typeof(ReviveAllPlayers)
			}
		};

		public static Dictionary<(Outcome, Type), int> GetAvailableEntries()
		{
			Dictionary<(Outcome, Type), int> dictionary = SINGLEPLAYER;
			if (SemiFunc.IsMultiplayer() && PhotonNetwork.PlayerList.Length > 1)
			{
				dictionary = MULTIPLAYER;
			}
			Dictionary<(Outcome, Type), int> dictionary2 = new Dictionary<(Outcome, Type), int>();
			foreach (KeyValuePair<(Outcome, Type), int> item in dictionary)
			{
				if (!ConfigValues.EnableOnlyGoodOutcomes.Value || item.Key.Item1 == Outcome.Good)
				{
					dictionary2.Add(item.Key, item.Value);
				}
			}
			foreach (KeyValuePair<(Outcome, Type), int> item2 in SHARED)
			{
				if (!ConfigValues.EnableOnlyGoodOutcomes.Value || item2.Key.Item1 == Outcome.Good)
				{
					dictionary2.Add(item2.Key, item2.Value);
				}
			}
			return dictionary2;
		}
	}
	internal class ChanceUtil
	{
		public static PlayerAvatar GetRandomAlivePlayer()
		{
			List<PlayerAvatar> list = GameDirector.instance.PlayerList.Where((PlayerAvatar x) => (float)x.playerHealth.health > 0f).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			int index = Random.Range(0, list.Count);
			return list[index];
		}

		public static PlayerAvatar GetRandomAlivePlayerButExclude(PlayerAvatar exclude)
		{
			List<PlayerAvatar> list = GameDirector.instance.PlayerList.Where((PlayerAvatar x) => (float)x.playerHealth.health > 0f && (Object)(object)x != (Object)(object)exclude).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			int index = Random.Range(0, list.Count);
			return list[index];
		}

		public static PlayerAvatar GetRandomDeadPlayer()
		{
			List<PlayerAvatar> list = GameDirector.instance.PlayerList.Where((PlayerAvatar x) => (float)x.playerHealth.health <= 0f).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			int index = Random.Range(0, list.Count);
			return list[index];
		}

		public static Item GetRandomItemOfType(itemType itemType)
		{
			//IL_0007: 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)
			List<Item> list = StatsManager.instance.itemDictionary.Values.Where((Item i) => i.itemType == itemType).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			return list[Random.Range(0, list.Count)];
		}

		public static string RemoveSuffix(string original, string suffix)
		{
			if (original != null && suffix != null && original.EndsWith(suffix))
			{
				return original.Substring(0, original.Length - suffix.Length);
			}
			return original;
		}
	}
	internal interface IChanceEntry
	{
		bool Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network);

		(string, PossessChatID, Color) GetChatMessage();
	}
	public static class TestCommand
	{
		[CommandExecution("Test Chance Entry", "Test a specific chance entry by name.", true, true)]
		[CommandAlias("testchanceentry")]
		[CommandAlias("testchance")]
		[CommandAlias("tce")]
		public static void Execute(string args)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(args))
			{
				Plugin.Logger.LogWarning((object)"No args provided to command.");
				return;
			}
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				Plugin.Logger.LogWarning((object)"Only the host can test!");
				return;
			}
			Type chanceEntry = ChanceRegistry.NAME_TO_TYPED_ENTRY[args];
			if (chanceEntry == null)
			{
				Plugin.Logger.LogWarning((object)"Unable to find chance type");
				return;
			}
			Vector3 val = ((Component)PlayerAvatar.instance).transform.position + new Vector3(0f, 1f, 0f) + ((Component)PlayerAvatar.instance).transform.forward * 1f;
			ValuableObject val2 = default(ValuableObject);
			if (!Valuables.TryGetValuableThatContainsName("Valuable Present Big (Chance)", ref val2))
			{
				Plugin.Logger.LogWarning((object)"Spawn valuable failed.");
				return;
			}
			ChatManager.instance.ClearAllChatBatches();
			ChatManager.instance.ChatReset();
			GameObject gameObject = Valuables.SpawnValuable(val2, val, Quaternion.identity);
			Task.Delay(500).ContinueWith(delegate
			{
				ValuablePresentChance component = gameObject.GetComponent<ValuablePresentChance>();
				component.OverrideChanceEntry(chanceEntry);
				component.lastPlayerGrabbed = PlayerAvatar.instance;
				PhysGrabObject component2 = gameObject.GetComponent<PhysGrabObject>();
				component2.lastPlayerGrabbing = PlayerAvatar.instance;
				component2.grabbedTimer = 10f;
				PhysGrabObjectImpactDetector component3 = gameObject.GetComponent<PhysGrabObjectImpactDetector>();
				component3.DestroyObject(true);
			});
		}
	}
}
namespace REPOPresents.Chance.Impl
{
	internal class BreakRandomValuable : IChanceEntry
	{
		private string destroyedName = null;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			List<ValuableObject> valuableList = ValuableDirector.instance.valuableList;
			if (valuableList == null || valuableList.Count == 0)
			{
				return false;
			}
			ValuableObject val = valuableList[Random.Range(0, valuableList.Count)];
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			destroyedName = ((Object)val).name;
			PhysGrabObjectImpactDetector component = ((Component)val).GetComponent<PhysGrabObjectImpactDetector>();
			component.DestroyObject(true);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (destroyedName == null)
			{
				return ("Broken a random item!", (PossessChatID)3, Color.red);
			}
			return ("Broken a " + ChanceUtil.RemoveSuffix(destroyedName, "(Clone)").ToLower(), (PossessChatID)3, Color.red);
		}
	}
	internal class DecreaseAllValuableWorthTenPercent : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			List<ValuableObject> valuableList = ValuableDirector.instance.valuableList;
			if (valuableList == null || valuableList.Count == 0)
			{
				return false;
			}
			foreach (ValuableObject item in valuableList)
			{
				float num = item.dollarValueCurrent * 0.9f;
				item.dollarValueCurrent = Mathf.Round(num / 100f) * 100f;
				if (SemiFunc.IsMultiplayer())
				{
					item.photonView.RPC("DollarValueSetRPC", (RpcTarget)1, new object[1] { item.dollarValueCurrent });
				}
			}
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("Decreased all valuables by 10%!", (PossessChatID)4, Color.red);
		}
	}
	internal class HealRandomPlayer : IChanceEntry
	{
		private PlayerAvatar selected;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			selected = ChanceUtil.GetRandomAlivePlayerButExclude(roller);
			if ((Object)(object)selected == (Object)null)
			{
				return false;
			}
			selected.playerHealth.HealOther(selected.playerHealth.maxHealth, true);
			network.PossessChat(selected, (PossessChatID)0, roller.playerName + " has healed me!", Color.green);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return (selected.playerName + " has been healed!", (PossessChatID)0, Color.green);
		}
	}
	internal class HealRoller : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			roller.playerHealth.HealOther(roller.playerHealth.maxHealth, true);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("I have been healed!", (PossessChatID)0, Color.green);
		}
	}
	internal class HurtRandomPlayer : IChanceEntry
	{
		private PlayerAvatar selected;

		private int damage;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_004c: 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)
			damage = Random.Range(10, 50);
			selected = ChanceUtil.GetRandomAlivePlayerButExclude(roller);
			if ((Object)(object)selected == (Object)null)
			{
				return false;
			}
			selected.playerHealth.HurtOther(damage, new Vector3(0f, 0f), false, -1);
			network.PossessChat(selected, (PossessChatID)3, $"-{damage} health from {roller.playerName}", Color.red);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			return ($"-{damage} health for {selected.playerName}", (PossessChatID)4, Color.red);
		}
	}
	internal class HurtRoller : IChanceEntry
	{
		private int damage;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			damage = Random.Range(10, 50);
			roller.playerHealth.HurtOther(damage, new Vector3(0f, 0f), false, -1);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return ($"-{damage} health", (PossessChatID)3, Color.red);
		}
	}
	internal class IncreaseAllValuableWorthTenPercent : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			List<ValuableObject> valuableList = ValuableDirector.instance.valuableList;
			if (valuableList == null || valuableList.Count == 0)
			{
				return false;
			}
			foreach (ValuableObject item in valuableList)
			{
				float num = item.dollarValueCurrent * 1.1f;
				item.dollarValueCurrent = Mathf.Round(num / 100f) * 100f;
				item.dollarValueOriginal = Mathf.Max(item.dollarValueCurrent, item.dollarValueOriginal);
				if (SemiFunc.IsMultiplayer())
				{
					item.photonView.RPC("DollarValueSetRPC", (RpcTarget)1, new object[1] { item.dollarValueCurrent });
				}
			}
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("Increased all valuables by 10%!", (PossessChatID)0, Color.green);
		}
	}
	internal class IncreaseAllValuableWorthTwentyPercent : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			List<ValuableObject> valuableList = ValuableDirector.instance.valuableList;
			if (valuableList == null || valuableList.Count == 0)
			{
				return false;
			}
			foreach (ValuableObject item in valuableList)
			{
				float num = item.dollarValueCurrent * 1.2f;
				item.dollarValueCurrent = Mathf.Round(num / 100f) * 100f;
				item.dollarValueOriginal = Mathf.Max(item.dollarValueCurrent, item.dollarValueOriginal);
				if (SemiFunc.IsMultiplayer())
				{
					item.photonView.RPC("DollarValueSetRPC", (RpcTarget)1, new object[1] { item.dollarValueCurrent });
				}
			}
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("Increased all valuables by 20%!", (PossessChatID)0, Color.green);
		}
	}
	internal class IncreaseValuableWorth : IChanceEntry
	{
		private const int MAX_VALUE = 10000;

		private const int MIN_VALUE = 2000;

		private string selectedName = null;

		private int increasedValue = 0;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			List<ValuableObject> valuableList = ValuableDirector.instance.valuableList;
			if (valuableList == null || valuableList.Count == 0)
			{
				return false;
			}
			ValuableObject val = valuableList[Random.Range(0, valuableList.Count)];
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			increasedValue = Random.Range(2000, 10000);
			selectedName = ((Object)val).name;
			val.dollarValueCurrent += (float)increasedValue;
			val.DollarValueSetLogic();
			if (SemiFunc.IsMultiplayer())
			{
				val.photonView.RPC("DollarValueSetRPC", (RpcTarget)1, new object[1] { val.dollarValueCurrent });
			}
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (selectedName == null)
			{
				return ($"Increased a random item by ${increasedValue}!", (PossessChatID)0, Color.green);
			}
			return (string.Format("Increased {0} by ${1}", ChanceUtil.RemoveSuffix(selectedName, "(Clone)").ToLower(), increasedValue), (PossessChatID)0, Color.green);
		}
	}
	internal class Nothing : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (null, (PossessChatID)0, Color.white);
		}
	}
	internal class ReviveAllPlayers : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
			{
				if ((float)player.playerHealth.health <= 0f)
				{
					player.Revive(false);
				}
			}
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("Revived all dead players!", (PossessChatID)0, Color.green);
		}
	}
	internal class ReviveRandomPlayer : IChanceEntry
	{
		private PlayerAvatar selected;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			selected = ChanceUtil.GetRandomDeadPlayer();
			if ((Object)(object)selected == (Object)null)
			{
				return false;
			}
			selected.Revive(false);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return (selected.playerName + " has been revived!", (PossessChatID)0, Color.green);
		}
	}
	internal class SpawnEnemy : IChanceEntry
	{
		[CompilerGenerated]
		private sealed class <SpawnEnemyAfterTime>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnemySetup enemySetup;

			public Vector3 position;

			public TimeSpan timeSpan;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds((float)timeSpan.TotalSeconds);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Enemies.SpawnEnemy(enemySetup, position, Quaternion.identity, 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();
			}
		}

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			List<EnemySetup> list = new List<EnemySetup>();
			foreach (EnemySetup item in EnemyDirector.instance.enemiesDifficulty3)
			{
				if (!((Object)item).name.Contains("Group"))
				{
					list.Add(item);
				}
			}
			if (list.Count == 0)
			{
				return false;
			}
			EnemySetup val = list[Random.Range(0, list.Count)];
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			((MonoBehaviour)EnemyDirector.instance).StartCoroutine(SpawnEnemyAfterTime(val, ((Component)network).gameObject.transform.position, TimeSpan.FromSeconds(3.0)));
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("RUN! NOW!", (PossessChatID)3, Color.red);
		}

		[IteratorStateMachine(typeof(<SpawnEnemyAfterTime>d__2))]
		private static IEnumerator SpawnEnemyAfterTime(EnemySetup enemySetup, Vector3 position, TimeSpan timeSpan)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnEnemyAfterTime>d__2(0)
			{
				enemySetup = enemySetup,
				position = position,
				timeSpan = timeSpan
			};
		}
	}
	internal class SpawnMiniEnemy : IChanceEntry
	{
		[CompilerGenerated]
		private sealed class <SpawnEnemyAfterTime>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnemySetup enemySetup;

			public Vector3 position;

			public TimeSpan timeSpan;

			public ValuablePresentChanceNetwork network;

			private List<EnemyParent> <parts>5__1;

			private List<EnemyParent>.Enumerator <>s__2;

			private EnemyParent <item>5__3;

			private PhotonView <photonView>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<parts>5__1 = null;
				<>s__2 = default(List<EnemyParent>.Enumerator);
				<item>5__3 = null;
				<photonView>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds((float)timeSpan.TotalSeconds);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<parts>5__1 = Enemies.SpawnEnemy(enemySetup, position, Quaternion.identity, false);
					<>s__2 = <parts>5__1.GetEnumerator();
					try
					{
						while (<>s__2.MoveNext())
						{
							<item>5__3 = <>s__2.Current;
							<photonView>5__4 = ((Component)<item>5__3).GetComponent<PhotonView>();
							if ((Object)(object)<photonView>5__4 != (Object)null)
							{
								network.SetScale(<photonView>5__4.ViewID, new Vector3(0.5f, 0.5f, 0.5f));
							}
							<photonView>5__4 = null;
							<item>5__3 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__2).Dispose();
					}
					<>s__2 = default(List<EnemyParent>.Enumerator);
					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();
			}
		}

		private static readonly List<string> SPAWNABLES = new List<string> { "Head", "Robe", "Huntsman", "Reaper" };

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			string text = SPAWNABLES[Random.Range(0, SPAWNABLES.Count)];
			EnemySetup enemyThatContainsName = Enemies.GetEnemyThatContainsName(text);
			if ((Object)(object)enemyThatContainsName == (Object)null)
			{
				return false;
			}
			((MonoBehaviour)EnemyDirector.instance).StartCoroutine(SpawnEnemyAfterTime(enemyThatContainsName, ((Component)network).gameObject.transform.position, TimeSpan.FromSeconds(3.0), network));
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("RUN! SMALL!", (PossessChatID)3, Color.red);
		}

		[IteratorStateMachine(typeof(<SpawnEnemyAfterTime>d__3))]
		private static IEnumerator SpawnEnemyAfterTime(EnemySetup enemySetup, Vector3 position, TimeSpan timeSpan, ValuablePresentChanceNetwork network)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnEnemyAfterTime>d__3(0)
			{
				enemySetup = enemySetup,
				position = position,
				timeSpan = timeSpan,
				network = network
			};
		}
	}
	internal class SpawnRandomDroneItem : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//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)
			Item randomItemOfType = ChanceUtil.GetRandomItemOfType((itemType)0);
			if ((Object)(object)randomItemOfType == (Object)null)
			{
				return false;
			}
			Items.SpawnItem(randomItemOfType, ((Component)network).gameObject.transform.position, Quaternion.identity);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("A drone", (PossessChatID)0, Color.blue);
		}
	}
	internal class SpawnRandomHealthPack : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//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)
			Item randomItemOfType = ChanceUtil.GetRandomItemOfType((itemType)8);
			if ((Object)(object)randomItemOfType == (Object)null)
			{
				return false;
			}
			Items.SpawnItem(randomItemOfType, ((Component)network).gameObject.transform.position, Quaternion.identity);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("Some health", (PossessChatID)0, Color.green);
		}
	}
	internal class SpawnRandomUpgradeItem : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//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)
			Item randomItemOfType = ChanceUtil.GetRandomItemOfType((itemType)3);
			if ((Object)(object)randomItemOfType == (Object)null)
			{
				return false;
			}
			Items.SpawnItem(randomItemOfType, ((Component)network).gameObject.transform.position, Quaternion.identity);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("Shiny upgrade", (PossessChatID)0, Color.cyan);
		}
	}
	internal class SpawnRandomValuable : IChanceEntry
	{
		private static readonly List<Type> TYPES = new List<Type>
		{
			(Type)2,
			(Type)3,
			(Type)5
		};

		private Type type;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			type = TYPES[Random.Range(0, TYPES.Count)];
			List<GameObject> valuablesByVolumeType = ValuableUtil.GetValuablesByVolumeType(RunManager.instance.levelCurrent, type);
			if (valuablesByVolumeType.Count == 0)
			{
				return false;
			}
			GameObject val = valuablesByVolumeType[Random.Range(0, valuablesByVolumeType.Count)];
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			ValuableObject component = val.GetComponent<ValuableObject>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			Valuables.SpawnValuable(component, ((Component)network).gameObject.transform.position, ((Component)network).gameObject.transform.rotation);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			return ("A " + ((object)(Type)(ref type)).ToString().ToLower() + " item!", (PossessChatID)0, Color.white);
		}
	}
	internal class TeleportRandomPlayer : IChanceEntry
	{
		private PlayerAvatar selected;

		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			selected = ChanceUtil.GetRandomAlivePlayerButExclude(roller);
			if ((Object)(object)selected == (Object)null)
			{
				return false;
			}
			List<LevelPoint> list = SemiFunc.LevelPointsGetAll();
			if (list.Count == 0)
			{
				return false;
			}
			LevelPoint val = list[Random.Range(0, list.Count)];
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			network.Teleport(selected, ((Component)val).transform.position);
			network.PossessChat(selected, (PossessChatID)3, roller.playerName + " has teleported me!", Color.red);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return (selected.playerName + " has been teleported!", (PossessChatID)4, Color.red);
		}
	}
	internal class TeleportRoller : IChanceEntry
	{
		bool IChanceEntry.Execute(PlayerAvatar roller, ValuablePresentChanceNetwork network)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			List<LevelPoint> list = SemiFunc.LevelPointsGetAll();
			if (list.Count == 0)
			{
				return false;
			}
			LevelPoint val = list[Random.Range(0, list.Count)];
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			network.Teleport(roller, ((Component)val).transform.position);
			return true;
		}

		(string, PossessChatID, Color) IChanceEntry.GetChatMessage()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ("Teleported :(", (PossessChatID)0, Color.red);
		}
	}
}