using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Photon.Pun;
using Photon.Realtime;
using REPOLib.Modules;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Lego0_77")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+babe8086e1d28698f7505ad8e53ce0cf3975adc5")]
[assembly: AssemblyProduct("ChaosMod")]
[assembly: AssemblyTitle("ChaosMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal delegate TResult <>f__AnonymousDelegate0<T1, T2, TResult>(T1 arg1, T2 arg2 = 1);
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ChaosMod
{
	public class AdManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <InAnimation>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AdManager <>4__this;

			private float <time>5__2;

			private Func<float, float> <ease>5__3;

			private float <startX>5__4;

			private float <endX>5__5;

			private float <ogY>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: 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)
				int num = <>1__state;
				AdManager adManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__2 = 0f;
					<ease>5__3 = delegate(float x)
					{
						float num3 = 1.70158f;
						float num4 = num3 + 1f;
						return 1f + num4 * Mathf.Pow(x - 1f, 3f) + num3 * Mathf.Pow(x - 1f, 2f);
					};
					<startX>5__4 = 1230f;
					<endX>5__5 = 690f;
					<ogY>5__6 = ((Component)adManager).transform.localPosition.y;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__2 < 1f)
				{
					float num2 = <ease>5__3(<time>5__2);
					((Component)adManager).transform.localPosition = new Vector3(<startX>5__4 + num2 * (<endX>5__5 - <startX>5__4), <ogY>5__6, 0f);
					<time>5__2 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((Component)adManager).transform.localPosition = new Vector3(<endX>5__5, <ogY>5__6, 0f);
				adManager.playerImage.SetActive(true);
				adManager.video.Play();
				((Component)adManager.SkipButton).gameObject.SetActive(true);
				adManager.spawned = true;
				adManager.skipTimer = 6f;
				((TMP_Text)adManager.SkipText).text = "Video Ends\nafter 5 seconds";
				adManager.skipPressed = 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();
			}
		}

		[CompilerGenerated]
		private sealed class <OutAnimation>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AdManager <>4__this;

			private float <time>5__2;

			private Func<float, float> <ease>5__3;

			private float <startX>5__4;

			private float <endX>5__5;

			private float <ogY>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				AdManager adManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__2 = 0f;
					<ease>5__3 = (float x) => (x != 0f) ? Mathf.Pow(2f, 10f * x - 10f) : 0f;
					<startX>5__4 = 690f;
					<endX>5__5 = 1230f;
					<ogY>5__6 = ((Component)adManager).transform.localPosition.y;
					adManager.video.Stop();
					adManager.playerImage.SetActive(false);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__2 < 1f)
				{
					float num2 = <ease>5__3(<time>5__2);
					((Component)adManager).transform.localPosition = new Vector3(Mathf.Lerp(<startX>5__4, <endX>5__5, num2), <ogY>5__6, 0f);
					<time>5__2 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((Component)adManager).transform.localPosition = new Vector3(<endX>5__5, <ogY>5__6, 0f);
				((Component)adManager.SkipButton).gameObject.SetActive(false);
				adManager.spawned = 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 TextMeshProUGUI ADText;

		private Button SkipButton;

		private TextMeshProUGUI SkipText;

		private VideoPlayer video;

		private GameObject playerImage;

		public List<VideoClip> clips;

		private bool spawned;

		private float skipTimer = 6f;

		private bool skipPressed;

		private void SetupComponents()
		{
			if ((Object)(object)video == (Object)null)
			{
				video = ((Component)this).GetComponent<VideoPlayer>();
			}
			Transform[] componentsInChildren = ((Component)this).GetComponentsInChildren<Transform>();
			Transform[] array = componentsInChildren;
			foreach (Transform val in array)
			{
				switch (((Object)val).name)
				{
				case "Skip Button":
					SkipButton = ((Component)val).GetComponent<Button>();
					break;
				case "Skip Text":
					SkipText = ((Component)val).GetComponent<TextMeshProUGUI>();
					break;
				case "Tab Text":
					ADText = ((Component)val).GetComponent<TextMeshProUGUI>();
					break;
				case "Video":
					playerImage = ((Component)val).gameObject;
					break;
				}
			}
		}

		private void Start()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			SetupComponents();
			((TMP_Text)ADText).text = "AD";
			((UnityEvent)SkipButton.onClick).AddListener((UnityAction)delegate
			{
				if (skipTimer <= 0f)
				{
					skipPressed = true;
				}
			});
			playerImage.SetActive(false);
			((Component)SkipButton).gameObject.SetActive(false);
			video.Stop();
		}

		public void SetVideo()
		{
			video.Stop();
			video.clip = clips[Random.Range(0, clips.Count)];
			video.Prepare();
			video.Stop();
		}

		public float GetLength()
		{
			return (float)video.length;
		}

		[ContextMenu("보이기")]
		public void Show()
		{
			((MonoBehaviour)this).StartCoroutine(InAnimation());
		}

		[ContextMenu("숨기기")]
		public void Hide()
		{
			((MonoBehaviour)this).StartCoroutine(OutAnimation());
		}

		[IteratorStateMachine(typeof(<InAnimation>d__15))]
		private IEnumerator InAnimation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InAnimation>d__15(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<OutAnimation>d__16))]
		private IEnumerator OutAnimation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OutAnimation>d__16(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			if (spawned)
			{
				if (skipTimer > 0f)
				{
					skipTimer -= Time.unscaledDeltaTime;
				}
				skipTimer = Mathf.Max(skipTimer, 0f);
				if (skipTimer <= 0f)
				{
					((TMP_Text)SkipText).text = (skipPressed ? "no you cant" : "Skip AD");
				}
				else
				{
					((TMP_Text)SkipText).text = $"Video Ends\nafter {Mathf.FloorToInt(skipTimer)} seconds";
				}
			}
		}
	}
	public class ChaosController : MonoBehaviour
	{
		internal PhotonView view;

		public static ChaosController instance;

		internal List<Modifier> events = new List<Modifier>();

		internal float eventTimer;

		internal float timeScale = 1f;

		private List<Action<Modifier>> stackedEvtActions = new List<Action<Modifier>>();

		private TextMeshProUGUI DebugText => ChaosMod.Instance.DebugText;

		private void Start()
		{
			instance = this;
			view = ((Component)this).GetComponent<PhotonView>();
			eventTimer = ChaosMod.MaxEventTimer;
		}

		[PunRPC]
		private void StartEventTimerRPC(float time, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			eventTimer = time;
		}

		public void RunActionOnEventSafe(Action<Modifier> action)
		{
			if (!stackedEvtActions.Exists((Action<Modifier> act) => action == act))
			{
				stackedEvtActions.Add(action);
			}
		}

		private void StartTimer(float time)
		{
			//IL_002c: 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)
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				view.RPC("StartEventTimerRPC", (RpcTarget)0, new object[1] { time });
			}
			else
			{
				StartEventTimerRPC(time);
			}
		}

		[PunRPC]
		internal void SendEventRPC(int eventIndex, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			List<Modifier> list = Modifiers.Events;
			if (Modifiers.DebugEvents.Count > 0)
			{
				list = Modifiers.DebugEvents;
			}
			if (SemiFunc.RunIsShop())
			{
				list = Modifiers.ShopEvents;
			}
			if (eventIndex >= 0 && eventIndex < list.Count)
			{
				Modifier modifier = list[eventIndex];
				Modifier modifier2 = modifier.Clone();
				if (!modifier2.isOnce)
				{
					modifier2.minTimer = modifier.minTimer;
					modifier2.maxTimer = modifier.maxTimer;
				}
				events.Add(modifier2);
				modifier2.Start();
				ChaosMod.Instance.MakeText(modifier2.GetName(), modifier2.timerSelf);
			}
		}

		[PunRPC]
		private void AddTimeToEventRPC(int eventIndex, float time, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			if (eventIndex >= 0 && eventIndex < events.Count)
			{
				events[eventIndex].timerSelf += time;
				if ((Object)(object)ChaosMod.Instance.eventTimerBars[eventIndex] != (Object)null)
				{
					ChaosMod.Instance.eventTimerBars[eventIndex].SetTime(events[eventIndex].timerSelf);
				}
			}
		}

		private void RandomEvent()
		{
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: 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_022e: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			for (int i = 0; i < 100; i++)
			{
				try
				{
					int num = 0;
					Modifier tempMod = null;
					if (SemiFunc.RunIsLevel())
					{
						if (Modifiers.DebugEvents.Count > 0)
						{
							num = Random.Range(0, Modifiers.DebugEvents.Count);
							tempMod = Modifiers.DebugEvents[num];
						}
						else
						{
							num = Random.Range(0, Modifiers.Events.Count);
							tempMod = Modifiers.Events[num];
						}
					}
					bool flag = Modifiers.CheckExcludes(tempMod.Instance);
					bool flag2 = Random.Range(0f, 1f) <= Mathf.Clamp01(tempMod.Instance.options.chance);
					bool flag3 = tempMod.isOnce || tempMod.timerSelf <= 0f;
					bool multiplayerOnly = tempMod.Instance.options.multiplayerOnly;
					bool singleplayerOnly = tempMod.Instance.options.singleplayerOnly;
					bool enabled = tempMod.enabled;
					bool flag4 = true;
					if ((multiplayerOnly && !GameManager.Multiplayer()) || (singleplayerOnly && GameManager.Multiplayer()))
					{
						flag4 = false;
					}
					if (ChaosMod.IsDebug)
					{
						MonoBehaviour.print((object)$"!isExcludedMod: {!flag} && chanceChoosen: {flag2} && hasTimerDoneOrIsOnce: {flag3} && isMultiplayerOnly: {multiplayerOnly} && !excludeOptions: {!enabled}");
					}
					if (!(!flag && flag2 && flag3 && flag4 && enabled))
					{
						continue;
					}
					if (!tempMod.isOnce)
					{
						Modifier modifier = events.Find((Modifier mod) => mod.name == tempMod.name && !mod.isOnce && mod.timerSelf > 0f);
						if (modifier != null)
						{
							if (GameManager.Multiplayer())
							{
								view.RPC("AddTimeToEventRPC", (RpcTarget)0, new object[2]
								{
									events.IndexOf(modifier),
									modifier.GetTime()
								});
							}
							else
							{
								AddTimeToEventRPC(events.IndexOf(modifier), modifier.GetTime());
							}
							return;
						}
					}
					if (GameManager.Multiplayer())
					{
						view.RPC("SendEventRPC", (RpcTarget)0, new object[1] { num });
					}
					else
					{
						SendEventRPC(num);
					}
					return;
				}
				catch (Exception ex)
				{
					ChaosMod.Logger.LogError((object)(ex.Message + "\n" + ex.StackTrace));
				}
			}
			ChaosMod.Logger.LogWarning((object)"적절한 이벤트를 찾지 못했습니다.");
		}

		public static Modifier FindModWithName(string name)
		{
			Modifier modifier = Modifiers.Events.Find((Modifier m) => m.GetName() == name);
			if (modifier == null)
			{
				if (ChaosMod.IsDebug)
				{
					ChaosMod.Logger.LogWarning((object)("이벤트 이름 '" + name + "'은 존재하지 않습니다."));
				}
				return null;
			}
			return modifier.Clone();
		}

		[PunRPC]
		private void OnEventFinishedRPC(string evtName, bool resetText = true, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			try
			{
				Modifier modifier = FindModWithName(evtName);
				if (modifier != null)
				{
					if (ChaosMod.IsDebug)
					{
						ChaosMod.Logger.LogMessage((object)("모드 마침: " + modifier.name));
					}
					if (!modifier.isOnce)
					{
						modifier.OnFinished();
					}
					if (resetText)
					{
						ChaosMod.Instance.ResetText();
					}
				}
			}
			catch (Exception ex)
			{
				ChaosMod.Logger.LogError((object)(ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void OnEventFinished(string modName, bool resetText)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (GameManager.Multiplayer())
				{
					view.RPC("OnEventFinishedRPC", (RpcTarget)0, new object[2] { modName, resetText });
				}
				else
				{
					OnEventFinishedRPC(modName, resetText);
				}
			}
		}

		private void Update()
		{
			if (!ChaosMod.Generated)
			{
				if (events.Count > 0)
				{
					foreach (Modifier @event in events)
					{
						OnEventFinished(@event.GetName(), resetText: false);
					}
					events.Clear();
				}
				if (Modifiers.Excludes.Count > 0)
				{
					Modifiers.Excludes.Clear();
				}
				if (SemiFunc.IsMasterClientOrSingleplayer() && eventTimer != ChaosMod.MaxEventTimer)
				{
					StartTimer(ChaosMod.MaxEventTimer);
				}
				return;
			}
			if (!ChaosMod.DISABLE_TIMER)
			{
				if (eventTimer > 0f)
				{
					eventTimer = Mathf.Max(0f, eventTimer - Time.unscaledDeltaTime * timeScale);
				}
				else if (SemiFunc.IsMasterClientOrSingleplayer())
				{
					StartTimer(ChaosMod.MaxEventTimer);
					RandomEvent();
				}
			}
			foreach (Modifier event2 in events)
			{
				if (event2 == null)
				{
					continue;
				}
				if (event2.timerSelf > 0f)
				{
					event2.timerSelf -= Time.unscaledDeltaTime;
				}
				else if (event2.timerSelf > -10f)
				{
					event2.timerSelf = -10f;
					if (!event2.isOnce)
					{
						OnEventFinished(event2.GetName(), resetText: true);
					}
					bool flag = !event2.isOnce && event2.timerSelf <= 0f;
					int item = events.IndexOf(event2);
					if (!ChaosMod.Instance.EventToRemove.Contains(item) && flag)
					{
						ChaosMod.Instance.EventToRemove.Add(item);
					}
					if (!ChaosMod.Instance.TextToRemove.Contains(item) && flag)
					{
						ChaosMod.Instance.TextToRemove.Add(item);
					}
				}
				event2.Update();
			}
			if (stackedEvtActions.Count > 0)
			{
				foreach (Modifier event3 in events)
				{
					foreach (Action<Modifier> stackedEvtAction in stackedEvtActions)
					{
						stackedEvtAction(event3);
					}
				}
				stackedEvtActions.Clear();
			}
			if (ChaosMod.IsDebug)
			{
				string text = "디버깅 전용 텍스트";
				text += $"\n살아있는 이벤트 개수: {events.Count}";
				text += $"\n지울 예정인 이벤트 개수: {ChaosMod.Instance.EventToRemove.Count}";
				text += $"\n살아있는 텍스트 개수: {ChaosMod.Instance.texts.Count}";
				text += $"\n지울 예정인 텍스트 개수: {ChaosMod.Instance.TextToRemove.Count}";
				((TMP_Text)DebugText).text = text;
			}
			if (ChaosMod.Instance.EventToRemove.Count <= 0)
			{
				return;
			}
			IOrderedEnumerable<int> orderedEnumerable = from i in ChaosMod.Instance.EventToRemove.Distinct()
				orderby i descending
				select i;
			foreach (int item2 in orderedEnumerable)
			{
				if (item2 >= 0 && item2 < events.Count)
				{
					if (!events[item2].finihshed && !events[item2].isOnce)
					{
						OnEventFinished(events[item2].GetName(), resetText: false);
					}
					if (ChaosMod.IsDebug)
					{
						ChaosMod.Logger.LogMessage((object)("이벤트 삭제됨: " + events[item2].name));
					}
					events.RemoveAt(item2);
					ChaosMod.Instance.ResetText();
				}
			}
			ChaosMod.Instance.EventToRemove.Clear();
		}

		[PunRPC]
		internal void GrenadeStunExplosionRPC(int viewID)
		{
			GameObject gameObject = ((Component)PhotonView.Find(viewID)).gameObject;
			ItemGrenade component = gameObject.GetComponent<ItemGrenade>();
			component.tickTime = 0f;
			Util.GetInternalVar(component, "isActive").SetValue(component, true);
		}
	}
	[BepInPlugin("Lego0_77.ChaosMod", "ChaosMod", "1.4")]
	public class ChaosMod : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass43_0
		{
			public string evt_enabled;

			public string evt_chance;

			public string range;

			public string evt_duration;

			public string float_maxValue;

			public string seconds;

			public ChaosMod <>4__this;

			public string options_general;

			public string timebarColor;

			public string dizz;

			public string family;

			public string dev;

			public string timer;

			internal void <MakeOptions>b__0(Modifier mod)
			{
				List<OptionsMenuController.OptionItem> list = new List<OptionsMenuController.OptionItem>
				{
					new OptionsMenuController.OptionItem(mod.GetDesc(), OptionsMenuController.OptionType.Description),
					new OptionsMenuController.OptionItem(evt_enabled, OptionsMenuController.OptionType.Checkbox),
					new OptionsMenuController.OptionItem(evt_chance, OptionsMenuController.OptionType.Value, 0f, 100f),
					new OptionsMenuController.OptionItem(range + ": 0.0 ~ 100.0", OptionsMenuController.OptionType.Description)
				};
				if (!mod.isOnce)
				{
					list.Add(new OptionsMenuController.OptionItem(evt_duration, OptionsMenuController.OptionType.Range, 1f, float.MaxValue));
					list.Add(new OptionsMenuController.OptionItem(range + ": 1.0 ~ " + float_maxValue + " (" + seconds + ")", OptionsMenuController.OptionType.Description));
				}
				<>4__this.options.AddOption(mod.GetName(), list);
				<>4__this.options.SetValue(mod.GetName() + ":" + evt_enabled, mod.enabled, notify: false);
				<>4__this.options.SetValue(mod.GetName() + ":" + evt_chance, mod.options.chance * 100f, notify: false);
				if (!mod.isOnce)
				{
					<>4__this.options.SetValue(mod.GetName() + ":" + evt_duration, new float[2] { mod.minTimer, mod.maxTimer }, notify: false);
				}
			}

			internal void <MakeOptions>b__1(OptionsMenuController.OptionType type, string key, object value)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				if (key.StartsWith(options_general))
				{
					string text = key.Substring(options_general.Length + 1);
					if (text == timebarColor)
					{
						Color color = (Color)value;
						((Graphic)<>4__this.barImg).color = color;
						<>4__this.hasChanges = true;
					}
					else if (text == dizz)
					{
						<>4__this.dizzyness = (bool)value;
						<>4__this.hasChanges = true;
					}
					else if (text == family)
					{
						<>4__this.familyFriendly = (bool)value;
						<>4__this.hasChanges = true;
					}
					else if (text == dev)
					{
						<>4__this.DevMode = (bool)value;
						<>4__this.hasChanges = true;
					}
					else if (text == timer)
					{
						MaxEventTimer = (float)value;
						<>4__this.hasChanges = true;
					}
					return;
				}
				foreach (Modifier @event in Modifiers.Events)
				{
					string name = @event.GetName();
					if (key.StartsWith(name))
					{
						string text2 = key.Substring(name.Length + 1);
						if (text2 == evt_enabled)
						{
							@event.enabled = (bool)value;
						}
						else if (text2 == evt_chance)
						{
							@event.options.chance = (float)value / 100f;
						}
						else if (text2 == evt_duration)
						{
							float[] array = (float[])value;
							@event.minTimer = array[0];
							@event.maxTimer = array[1];
						}
						<>4__this.hasChanges = true;
						break;
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <MakeOptions>d__43 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ChaosMod <>4__this;

			private <>c__DisplayClass43_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_029f: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ChaosMod chaosMod = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass43_0();
					<>8__1.<>4__this = <>4__this;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<>8__1.options_general = Language.GetText("options_general");
					<>8__1.timebarColor = Language.GetText("options_gauge_color");
					<>8__1.dizz = Language.GetText("options_dizziness");
					<>8__1.family = Language.GetText("options_family_friendly");
					<>8__1.dev = Language.GetText("options_dev_mode");
					<>8__1.timer = Language.GetText("options_timer");
					chaosMod.options.AddOption(<>8__1.options_general, new List<OptionsMenuController.OptionItem>
					{
						new OptionsMenuController.OptionItem(<>8__1.timer, OptionsMenuController.OptionType.Value, 5f, 120f),
						new OptionsMenuController.OptionItem(Language.GetText("options_timer_desc"), OptionsMenuController.OptionType.Description),
						new OptionsMenuController.OptionItem(<>8__1.timebarColor, OptionsMenuController.OptionType.Color),
						new OptionsMenuController.OptionItem(Language.GetText("options_gauge_color_desc"), OptionsMenuController.OptionType.Description),
						new OptionsMenuController.OptionItem(<>8__1.dizz, OptionsMenuController.OptionType.Checkbox),
						new OptionsMenuController.OptionItem(Language.GetText("options_dizziness_desc"), OptionsMenuController.OptionType.Description),
						new OptionsMenuController.OptionItem(<>8__1.family, OptionsMenuController.OptionType.Checkbox),
						new OptionsMenuController.OptionItem(Language.GetText("options_family_friendly_desc"), OptionsMenuController.OptionType.Description),
						new OptionsMenuController.OptionItem(<>8__1.dev, OptionsMenuController.OptionType.Checkbox),
						new OptionsMenuController.OptionItem(Language.GetText("options_dev_mode_desc"), OptionsMenuController.OptionType.Description)
					});
					chaosMod.options.SetValue(<>8__1.options_general + ":" + <>8__1.timebarColor, new Color(48f / 85f, 0f, 0f), notify: false);
					chaosMod.options.SetValue(<>8__1.options_general + ":" + <>8__1.dizz, enabled: false, notify: false);
					chaosMod.options.SetValue(<>8__1.options_general + ":" + <>8__1.family, enabled: false, notify: false);
					chaosMod.options.SetValue(<>8__1.options_general + ":" + <>8__1.dev, enabled: false, notify: false);
					chaosMod.options.SetValue(<>8__1.options_general + ":" + <>8__1.timer, MaxEventTimer, notify: false);
					string text = Language.GetText("options_lvl_evts");
					<>8__1.evt_enabled = Language.GetText("options_evts_enabled");
					<>8__1.evt_chance = Language.GetText("options_evts_chance");
					<>8__1.evt_duration = Language.GetText("options_evts_range");
					<>8__1.range = Language.GetText("options_range");
					<>8__1.float_maxValue = Language.GetText("infinity");
					<>8__1.seconds = Language.GetText("options_seconds");
					chaosMod.options.AddCategory(text);
					Modifiers.Init(delegate(Modifier mod)
					{
						List<OptionsMenuController.OptionItem> list = new List<OptionsMenuController.OptionItem>
						{
							new OptionsMenuController.OptionItem(mod.GetDesc(), OptionsMenuController.OptionType.Description),
							new OptionsMenuController.OptionItem(<>8__1.evt_enabled, OptionsMenuController.OptionType.Checkbox),
							new OptionsMenuController.OptionItem(<>8__1.evt_chance, OptionsMenuController.OptionType.Value, 0f, 100f),
							new OptionsMenuController.OptionItem(<>8__1.range + ": 0.0 ~ 100.0", OptionsMenuController.OptionType.Description)
						};
						if (!mod.isOnce)
						{
							list.Add(new OptionsMenuController.OptionItem(<>8__1.evt_duration, OptionsMenuController.OptionType.Range, 1f, float.MaxValue));
							list.Add(new OptionsMenuController.OptionItem(<>8__1.range + ": 1.0 ~ " + <>8__1.float_maxValue + " (" + <>8__1.seconds + ")", OptionsMenuController.OptionType.Description));
						}
						<>8__1.<>4__this.options.AddOption(mod.GetName(), list);
						<>8__1.<>4__this.options.SetValue(mod.GetName() + ":" + <>8__1.evt_enabled, mod.enabled, notify: false);
						<>8__1.<>4__this.options.SetValue(mod.GetName() + ":" + <>8__1.evt_chance, mod.options.chance * 100f, notify: false);
						if (!mod.isOnce)
						{
							<>8__1.<>4__this.options.SetValue(mod.GetName() + ":" + <>8__1.evt_duration, new float[2] { mod.minTimer, mod.maxTimer }, notify: false);
						}
					});
					chaosMod.LoadAndApplySettings();
					chaosMod.options.onValueChanged.AddListener((UnityAction<OptionsMenuController.OptionType, string, object>)delegate(OptionsMenuController.OptionType type, string key, object value)
					{
						//IL_0034: Unknown result type (might be due to invalid IL or missing references)
						//IL_0039: Unknown result type (might be due to invalid IL or missing references)
						//IL_0045: Unknown result type (might be due to invalid IL or missing references)
						if (key.StartsWith(<>8__1.options_general))
						{
							string text2 = key.Substring(<>8__1.options_general.Length + 1);
							if (text2 == <>8__1.timebarColor)
							{
								Color color = (Color)value;
								((Graphic)<>8__1.<>4__this.barImg).color = color;
								<>8__1.<>4__this.hasChanges = true;
							}
							else if (text2 == <>8__1.dizz)
							{
								<>8__1.<>4__this.dizzyness = (bool)value;
								<>8__1.<>4__this.hasChanges = true;
							}
							else if (text2 == <>8__1.family)
							{
								<>8__1.<>4__this.familyFriendly = (bool)value;
								<>8__1.<>4__this.hasChanges = true;
							}
							else if (text2 == <>8__1.dev)
							{
								<>8__1.<>4__this.DevMode = (bool)value;
								<>8__1.<>4__this.hasChanges = true;
							}
							else if (text2 == <>8__1.timer)
							{
								MaxEventTimer = (float)value;
								<>8__1.<>4__this.hasChanges = true;
							}
							return;
						}
						foreach (Modifier @event in Modifiers.Events)
						{
							string name = @event.GetName();
							if (key.StartsWith(name))
							{
								string text3 = key.Substring(name.Length + 1);
								if (text3 == <>8__1.evt_enabled)
								{
									@event.enabled = (bool)value;
								}
								else if (text3 == <>8__1.evt_chance)
								{
									@event.options.chance = (float)value / 100f;
								}
								else if (text3 == <>8__1.evt_duration)
								{
									float[] array = (float[])value;
									@event.minTimer = array[0];
									@event.maxTimer = array[1];
								}
								<>8__1.<>4__this.hasChanges = true;
								break;
							}
						}
					});
					Logger.LogInfo((object)"Settings are created!");
					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();
			}
		}

		internal static readonly bool DISABLE_TIMER = false;

		internal static float MaxEventTimer = 20f;

		internal HashSet<EnemyParent> spawnedEnemys = new HashSet<EnemyParent>();

		internal bool DevMode;

		internal Canvas UICanvas;

		internal RectTransform barRect;

		internal PhotonView view;

		internal AudioSource EnemyAS;

		internal AudioSource RumbleAS;

		internal AudioSource AudioSource;

		internal AudioSource ClubSource;

		internal PostProcessVolume shaderOverlay;

		internal ConfigEntry<KeyCode> ConfigOptionsMenu;

		internal List<GameObject> PrefabToAddNetwork = new List<GameObject>();

		private float canvasHeight;

		private float canvasWidth;

		internal GameObject timeBar;

		internal RectTransform textGroup;

		internal AssetBundle assets;

		internal TextMeshProUGUI DebugText;

		internal Image barImg;

		internal OptionsMenuController options;

		private RawImage FakeCursor;

		private const string CONFIG_HEADER = "CHAOS_MOD_CONFIG";

		private const int CONFIG_VERSION = 1;

		internal bool photonViewInited;

		internal GameObject carObject;

		internal CrazyCarAIScript car;

		internal AdManager adViewer;

		internal GameObject adObject;

		internal bool dizzyness = true;

		internal bool familyFriendly;

		private bool hasChanges;

		private bool godModOn;

		internal ChaosController controller;

		private float text_height = 40f;

		internal TMP_FontAsset pretendard;

		internal List<TextLerp> texts = new List<TextLerp>();

		internal List<EventTimerBar> eventTimerBars = new List<EventTimerBar>();

		internal List<int> EventToRemove = new List<int>();

		internal List<int> TextToRemove = new List<int>();

		private bool didReset;

		internal static ChaosMod Instance { get; private set; } = null;


		internal static bool IsDebug
		{
			get
			{
				bool flag = false;
				return Instance.DevMode || flag;
			}
		}

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		public static bool Generated
		{
			get
			{
				if (LevelGenerator.Instance.Generated && !SemiFunc.IsMainMenu() && SemiFunc.RunIsLevel())
				{
					return !SemiFunc.RunIsArena();
				}
				return false;
			}
		}

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Language.Load((CultureInfo.CurrentCulture.Name == "ko-KR") ? "ko" : "en-us");
			ConfigOptionsMenu = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "Option Key", (KeyCode)285, "AAAAAAAAAAAAAAAAAA");
			Patch();
			Logger.LogInfo((object)(((BaseUnityPlugin)this).Info.Metadata.Name + " has loaded!"));
		}

		internal void Patch()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0025: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Start()
		{
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Expected O, but got Unknown
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Expected O, but got Unknown
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			string pluginDirectory = Util.GetPluginDirectory("assets");
			Logger.LogInfo((object)("에셋 번들을 '" + pluginDirectory + "'에서 불러옵니다."));
			assets = AssetBundle.LoadFromFile(pluginDirectory);
			if ((Object)(object)assets == (Object)null)
			{
				Logger.LogError((object)"에셋 번들 로드에 실패했습니다. 폰트가 깨지거나 몇 개의 에셋이 보이지 않을 수 있습니다.");
			}
			else
			{
				pretendard = assets.LoadAsset<TMP_FontAsset>("Pretendard-Bold SDF");
				if ((Object)(object)pretendard == (Object)null)
				{
					Logger.LogError((object)"폰트 로드에 실패했습니다. 폰트가 깨질 수 있습니다.");
				}
			}
			GameObject val = Object.Instantiate<GameObject>(assets.LoadAsset<GameObject>("Chaos Controller"));
			UICanvas = val.GetComponent<Canvas>();
			EnemyAS = ((Component)val.transform.Find("Audio Source").Find("Enemy Sound Source")).GetComponent<AudioSource>();
			EnemyAS.outputAudioMixerGroup = AudioManager.instance.SoundMasterGroup;
			RumbleAS = ((Component)val.transform.Find("Audio Source").Find("Rumble Sound Source")).GetComponent<AudioSource>();
			RumbleAS.outputAudioMixerGroup = AudioManager.instance.SoundMasterGroup;
			AudioSource = ((Component)val.transform.Find("Audio Source").Find("Master Sound Source")).GetComponent<AudioSource>();
			AudioSource.outputAudioMixerGroup = AudioManager.instance.SoundMasterGroup;
			ClubSource = ((Component)val.transform.Find("Audio Source").Find("Club Music Source")).GetComponent<AudioSource>();
			ClubSource.outputAudioMixerGroup = AudioManager.instance.MusicMasterGroup;
			GameObject val2 = Object.Instantiate<GameObject>(Resources.Load<GameObject>("valuables/04 big/Valuable Museum Boombox"), new Vector3(9E+09f, 0f, 0f), Quaternion.identity);
			val2.SetActive(false);
			ClubSource.clip = val2.GetComponent<ValuableBoombox>().soundBoomboxMusic.Sounds[0];
			Object.Destroy((Object)(object)val2);
			Rect rect = ((RectTransform)((Component)UICanvas).transform).rect;
			canvasHeight = ((Rect)(ref rect)).height;
			rect = ((RectTransform)((Component)UICanvas).transform).rect;
			canvasWidth = ((Rect)(ref rect)).width;
			Object.DontDestroyOnLoad((Object)(object)UICanvas);
			ThinkFast.scout = ((Component)val.transform.Find("Scout TF2")).GetComponent<Image>();
			ThinkFast.text1 = ((Component)val.transform.Find("Upper Text")).gameObject;
			ThinkFast.text2 = ((Component)val.transform.Find("Lower Text")).gameObject;
			timeBar = ((Component)val.transform.Find("Time Bar")).gameObject;
			barImg = ((Component)timeBar.transform.Find("FG")).GetComponent<Image>();
			barRect = (RectTransform)((Component)barImg).transform;
			textGroup = (RectTransform)((Component)val.transform.Find("Modifier Text Group")).transform;
			timeBar.SetActive(false);
			((Component)ThinkFast.scout).gameObject.SetActive(false);
			ThinkFast.text1.SetActive(false);
			ThinkFast.text2.SetActive(false);
			((TMP_Text)ThinkFast.text1.GetComponent<TextMeshProUGUI>()).text = Language.GetText("evt_text_think_fast");
			((TMP_Text)ThinkFast.text2.GetComponent<TextMeshProUGUI>()).text = Language.GetText("evt_text_chucklenuts");
			SceneManager.sceneLoaded += OnSceneChange;
			photonViewInited = false;
			DebugText = ((Component)val.transform.Find("Debug Text")).GetComponent<TextMeshProUGUI>();
			if (IsDebug)
			{
				((TMP_Text)DebugText).font = pretendard;
				((TMP_Text)DebugText).text = "";
				((TMP_Text)DebugText).fontSize = 20f;
			}
			((Component)DebugText).gameObject.SetActive(IsDebug);
			GameObject val3 = Object.Instantiate<GameObject>(assets.LoadAsset<GameObject>("Settings"), ((Component)UICanvas).transform, false);
			options = val3.AddComponent<OptionsMenuController>();
			FakeCursor = ((Component)val3.transform.Find("Mouse Cursor")).GetComponent<RawImage>();
			RawImage component = ((Component)GameObject.Find("Cursor").transform.GetChild(0)).GetComponent<RawImage>();
			FakeCursor.texture = component.texture;
			((Graphic)FakeCursor).material = ((Graphic)component).material;
			((Component)FakeCursor).gameObject.SetActive(false);
			((Graphic)FakeCursor).rectTransform.sizeDelta = new Vector2(64f, 55.5f);
			((Graphic)FakeCursor).raycastTarget = false;
			((Graphic)FakeCursor).rectTransform.pivot = new Vector2(0f, 1f);
			Logger.LogMessage((object)"Setup Done. '-'");
			((MonoBehaviour)this).StartCoroutine(MakeOptions());
		}

		[IteratorStateMachine(typeof(<MakeOptions>d__43))]
		private IEnumerator MakeOptions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MakeOptions>d__43(0)
			{
				<>4__this = this
			};
		}

		private void LoadAndApplySettings()
		{
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			string pluginDirectory = Util.GetPluginDirectory("settings.bytes");
			if (!File.Exists(pluginDirectory))
			{
				Logger.LogWarning((object)"Settings File not found. Making a new one.");
				File.WriteAllText(pluginDirectory, "");
				return;
			}
			using FileStream input = new FileStream(pluginDirectory, FileMode.Open);
			using BinaryReader binaryReader = new BinaryReader(input);
			try
			{
				if (binaryReader.ReadString() != "CHAOS_MOD_CONFIG")
				{
					Logger.LogError((object)Language.GetText("exception_config_invaild_header"));
					return;
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)(ex.GetBaseException()?.ToString() + ": " + ex.Message + "\n" + ex.StackTrace));
				if (ex.GetBaseException() is EndOfStreamException)
				{
					Logger.LogMessage((object)Language.GetText("exception_endofstream_config_1"));
					Logger.LogMessage((object)Language.GetText("exception_endofstream_config_2"));
				}
				return;
			}
			if (binaryReader.ReadInt32() > 1)
			{
				Logger.LogError((object)Language.GetText("exception_config_version_match"));
				return;
			}
			Color color = default(Color);
			for (int i = 0; i < binaryReader.ReadInt32(); i++)
			{
				string name = binaryReader.ReadString();
				switch (binaryReader.ReadString())
				{
				case "bool":
					options.SetValue(name, binaryReader.ReadBoolean());
					break;
				case "float":
					options.SetValue(name, binaryReader.ReadSingle());
					break;
				case "range":
					options.SetValue(name, new float[2]
					{
						binaryReader.ReadSingle(),
						binaryReader.ReadSingle()
					});
					break;
				case "color":
					((Color)(ref color))..ctor(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
					options.SetValue(name, color);
					break;
				}
			}
		}

		private void SaveSettings()
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"Trying to save settings...");
			using FileStream output = new FileStream(Util.GetPluginDirectory("settings.bytes"), FileMode.Create);
			using BinaryWriter binaryWriter = new BinaryWriter(output);
			binaryWriter.Write("CHAOS_MOD_CONFIG");
			binaryWriter.Write(1);
			binaryWriter.Write(options.datas.Count);
			foreach (KeyValuePair<string, object> data in options.datas)
			{
				binaryWriter.Write(data.Key);
				if (data.Value is bool value)
				{
					binaryWriter.Write("bool");
					binaryWriter.Write(value);
				}
				else if (data.Value is float value2)
				{
					binaryWriter.Write("float");
					binaryWriter.Write(value2);
				}
				else if (data.Value is float[] array)
				{
					binaryWriter.Write("range");
					binaryWriter.Write(array[0]);
					binaryWriter.Write(array[1]);
				}
				else if (data.Value is Color val)
				{
					binaryWriter.Write("color");
					binaryWriter.Write(val.r);
					binaryWriter.Write(val.g);
					binaryWriter.Write(val.b);
				}
			}
			binaryWriter.Flush();
			Logger.LogInfo((object)"Done!");
		}

		private void OnSceneChange(Scene scene, LoadSceneMode mode)
		{
			photonViewInited = false;
		}

		internal bool InitPhotonView()
		{
			NetworkManager val = Object.FindAnyObjectByType<NetworkManager>();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if ((Object)(object)controller == (Object)null)
			{
				if (!((Component)val).gameObject.TryGetComponent<ChaosController>(ref controller))
				{
					controller = ((Component)val).gameObject.AddComponent<ChaosController>();
				}
				if (!GameManager.Multiplayer())
				{
					view = null;
					photonViewInited = false;
					return false;
				}
			}
			if (!godModOn && IsDebug && !DevMode && (Object)(object)SemiFunc.PlayerAvatarLocal() != (Object)null)
			{
				godModOn = true;
				PlayerAvatar val2 = SemiFunc.PlayerAvatarLocal();
				Util.GetInternalVar(val2.playerHealth, "godMode").SetValue(val2.playerHealth, true);
			}
			if (!GameManager.Multiplayer())
			{
				return false;
			}
			if ((Object)(object)view == (Object)null)
			{
				view = ((Component)val).GetComponent<PhotonView>();
				if (IsDebug)
				{
					Logger.LogMessage((object)("PhotonView ID: " + view.ViewID));
				}
				photonViewInited = (Object)(object)view != (Object)null;
			}
			return photonViewInited;
		}

		public TextMeshProUGUI MakeText(string text, float time)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0034: 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_0066: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(text.ToLower().Trim());
			val.transform.parent = (Transform)(object)textGroup;
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0.5f);
			val2.anchorMax = new Vector2(1f, 0.5f);
			val2.offsetMin = new Vector2(0f, (0f - text_height) / 2f);
			val2.offsetMax = new Vector2(0f, text_height / 2f);
			TextLerp textLerp = val.AddComponent<TextLerp>();
			((TMP_Text)textLerp).text = text;
			((TMP_Text)textLerp).font = pretendard;
			((TMP_Text)textLerp).fontSize = 30f;
			((TMP_Text)textLerp).rectTransform.anchoredPosition = Vector2.zero;
			((Vector2)(ref textLerp.targetPosition)).Set(0f, 0f);
			((TMP_Text)textLerp).horizontalAlignment = (HorizontalAlignmentOptions)1;
			((TMP_Text)textLerp).verticalAlignment = (VerticalAlignmentOptions)512;
			texts.Add(textLerp);
			if (Mathf.Max(0f, time) > 0f)
			{
				GameObject val3 = new GameObject("Time Text");
				val3.transform.parent = val.transform;
				RectTransform val4 = val3.AddComponent<RectTransform>();
				EventTimerBar eventTimerBar = val3.AddComponent<EventTimerBar>();
				val4.anchoredPosition = Vector2.zero;
				((Vector2)(ref eventTimerBar.targetPosition)).Set(100f, 0f);
				eventTimerBar.SetTime(time);
				((TMP_Text)eventTimerBar).font = pretendard;
				((TMP_Text)eventTimerBar).fontSize = 30f;
				((TMP_Text)eventTimerBar).horizontalAlignment = (HorizontalAlignmentOptions)1;
				((TMP_Text)eventTimerBar).verticalAlignment = (VerticalAlignmentOptions)512;
				eventTimerBars.Add(eventTimerBar);
			}
			else
			{
				eventTimerBars.Add(null);
			}
			ResetText();
			return (TextMeshProUGUI)(object)textLerp;
		}

		public void ResetText()
		{
			//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)
			try
			{
				int num = 0;
				for (int i = 0; i < texts.Count; i++)
				{
					float num2 = 0f;
					bool flag = true;
					if (i >= 0 && i < controller.events.Count && controller.events[i] != null)
					{
						num2 = controller.events[i].timerSelf;
						flag = num2 <= 0f && !controller.events[i].isOnce;
					}
					if (!flag)
					{
						num++;
					}
				}
				int num3 = 0;
				for (int num4 = texts.Count - 1; num4 >= 0; num4--)
				{
					if (!EventToRemove.Contains(num4))
					{
						TextLerp textLerp = texts[num4];
						EventTimerBar eventTimerBar = eventTimerBars[num4];
						float num5 = text_height * (float)num3;
						if (num5 >= 375f * controller.timeScale && controller.events[num4].timerSelf <= 0f)
						{
							EventToRemove.Add(num4);
							TextToRemove.Add(num4);
						}
						else
						{
							textLerp.targetPosition = new Vector2(textLerp.targetPosition.x, num5);
						}
						num3++;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("텍스트의 위치를 리셋하던 중 오류가 발생했습니다: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		public bool RemoveText(TextLerp text)
		{
			int num = texts.IndexOf(text);
			if (num == -1)
			{
				if (IsDebug)
				{
					Logger.LogWarning((object)("텍스트 \"" + ((TMP_Text)text).text + "\"의 인덱스를 찾지 못했습니다."));
				}
				return false;
			}
			return RemoveText(num);
		}

		public bool RemoveText(int index)
		{
			if (index >= 0 && index < texts.Count)
			{
				TextLerp textLerp = texts[index];
				Object.Destroy((Object)(object)((Component)textLerp).gameObject);
				EventTimerBar eventTimerBar = eventTimerBars[index];
				if ((Object)(object)eventTimerBar != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)eventTimerBar).gameObject);
				}
				texts.RemoveAt(index);
				eventTimerBars.RemoveAt(index);
				return true;
			}
			return false;
		}

		private void Update()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			if (timeBar.activeSelf != Generated)
			{
				timeBar.SetActive(Generated);
			}
			if (Input.GetKeyDown(ConfigOptionsMenu.Value))
			{
				if (options.isShown)
				{
					((Component)FakeCursor).gameObject.SetActive(false);
					options.Hide();
					if (hasChanges)
					{
						hasChanges = false;
						SaveSettings();
					}
				}
				else
				{
					options.Show();
					((Component)FakeCursor).gameObject.SetActive(true);
				}
			}
			((Transform)((Graphic)FakeCursor).rectTransform).position = Input.mousePosition;
			if (!Generated)
			{
				if (texts.Count > 0)
				{
					for (int j = 0; j < texts.Count; j++)
					{
						Object.Destroy((Object)(object)texts[j]);
					}
					texts.Clear();
				}
				if (eventTimerBars.Count > 0)
				{
					for (int k = 0; k < eventTimerBars.Count; k++)
					{
						Object.Destroy((Object)(object)eventTimerBars[k]);
					}
					eventTimerBars.Clear();
				}
				photonViewInited = false;
				if (IsDebug)
				{
					((TMP_Text)DebugText).text = "";
				}
				if (!didReset)
				{
					didReset = true;
					godModOn = false;
					ModVars.Reset();
				}
				return;
			}
			if (didReset)
			{
				didReset = false;
			}
			if ((Object)(object)view == (Object)null || (Object)(object)controller == (Object)null)
			{
				photonViewInited = InitPhotonView();
			}
			barRect.offsetMax = new Vector2(SemiFunc.Remap(0f, MaxEventTimer, 0f, 0f - canvasWidth, controller.eventTimer), barRect.offsetMax.y);
			if (TextToRemove.Count <= 0)
			{
				return;
			}
			IOrderedEnumerable<int> orderedEnumerable = from i in TextToRemove.Distinct()
				orderby i descending
				select i;
			foreach (int item in orderedEnumerable)
			{
				if (item >= 0 && item < texts.Count)
				{
					RemoveText(item);
				}
			}
			TextToRemove.Clear();
		}
	}
	public static class Commands
	{
		private static ChaosController cont => ChaosMod.Instance.controller;
	}
	public class CrazyCarAIScript : MonoBehaviour, IOnEventCallback
	{
		public PhotonView photonView;

		public List<Vector3> waypoints = new List<Vector3>();

		public List<Sprite> exp_sprites = new List<Sprite>();

		public float exp_anim_frame = 0.05f;

		public AudioClip honk;

		private MapCustom mapCustom;

		private AudioSource src;

		private AudioSource exp_src;

		private SpriteRenderer exp_rend;

		private List<Transform> FrontWheels = new List<Transform>();

		private List<Transform> BackWheels = new List<Transform>();

		private List<Light> frontLights = new List<Light>();

		private List<Light> backLights = new List<Light>();

		private List<Light> allLights = new List<Light>();

		private NavMeshAgent agent;

		private ParticleSystem spawnParticles;

		private Transform root;

		private Vector3 startPos;

		private Vector3 startEuler;

		private HurtCollider hurt;

		private string[] hitMessages = new string[15]
		{
			"Wow, great driving.", "Nice driving, really.", "You're a real pro driver?", "Wow, did you get your license from a cereal box?", "10 out of 10 driving skills.", "Nice driving, genius.", "Wow, great driving.", "Did you get your license in a lucky draw?", "Ever heard of a turn signal?", "Call an Ambulance!",
			"This driver must be the reason for those warning signs.", "Was that a human driving or a blindfolded chimp?", "That’s supposed to be a human driving? A dog could’ve done a better job.", "That driver must be the reason for those warning signs.", "YOU DRIVE LIKE YOU'RE PLAYING GRAND THEFT AUTO."
		};

		private bool yapping;

		private UnityEvent chat_callback;

		internal bool setupDone;

		internal bool isSpawned;

		private float rotateTimer;

		private float lastYRotation;

		private float rotationSpeed;

		private float lastAgentSpeed;

		private float curSpeedDelta;

		private int curAnimFrame;

		private float curAnimTime;

		private bool playAnimation;

		private bool needsToDestroy;

		private float honkTimer;

		private Vector3 targetPos;

		private Vector3 targetRot;

		private bool hasPosData;

		private void SetupComponents()
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			if ((Object)(object)agent == (Object)null)
			{
				agent = ((Component)this).GetComponent<NavMeshAgent>();
			}
			if ((Object)(object)agent == (Object)null)
			{
				ChaosMod.Logger.LogError((object)"NavMeshAgent가 없습니다.");
				return;
			}
			if ((Object)(object)src == (Object)null)
			{
				src = ((Component)this).GetComponent<AudioSource>();
			}
			if ((Object)(object)src == (Object)null)
			{
				ChaosMod.Logger.LogError((object)"AudioSource가 없습니다.");
				return;
			}
			src.outputAudioMixerGroup = AudioManager.instance.SoundMasterGroup;
			if ((Object)(object)photonView == (Object)null)
			{
				photonView = ((Component)this).GetComponent<PhotonView>();
			}
			if ((Object)(object)photonView == (Object)null)
			{
				ChaosMod.Logger.LogError((object)"PhotonView가 없습니다.");
				return;
			}
			if (chat_callback == null)
			{
				chat_callback = new UnityEvent();
				chat_callback.AddListener((UnityAction)delegate
				{
					yapping = false;
				});
			}
			if ((Object)(object)hurt == (Object)null)
			{
				hurt = ((Component)this).GetComponent<HurtCollider>();
				hurt.onImpactPlayer.AddListener((UnityAction)delegate
				{
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					if (GameManager.Multiplayer() && !yapping)
					{
						yapping = true;
						ChatManager.instance.PossessChatScheduleStart(int.MaxValue);
						ChatManager.instance.PossessChat((PossessChatID)2, hitMessages[Random.Range(0, hitMessages.Length)], 4f, Color.red, 0f, false, 0, chat_callback);
						ChatManager.instance.PossessChatScheduleEnd();
					}
				});
			}
			if ((Object)(object)mapCustom == (Object)null)
			{
				mapCustom = ((Component)this).GetComponent<MapCustom>();
			}
			if ((Object)(object)mapCustom == (Object)null)
			{
				ChaosMod.Logger.LogError((object)"MapCustom가 없습니다.");
				return;
			}
			Transform[] componentsInChildren = ((Component)this).GetComponentsInChildren<Transform>();
			Transform[] array = componentsInChildren;
			foreach (Transform val in array)
			{
				if (((Object)val).name.Contains("Front Wheel"))
				{
					FrontWheels.Add(val);
				}
				else if (((Object)val).name.Contains("Back Wheel"))
				{
					BackWheels.Add(val);
				}
				else if (((Object)val).name.Contains("Front Light"))
				{
					Light component = ((Component)val).GetComponent<Light>();
					frontLights.Add(component);
					allLights.Add(component);
				}
				else if (((Object)val).name.Contains("Back Light"))
				{
					Light component2 = ((Component)val).GetComponent<Light>();
					backLights.Add(component2);
					allLights.Add(component2);
				}
				else if (((Object)val).name == "root")
				{
					root = val;
				}
				else if (((Object)val).name.Contains("Spawn"))
				{
					spawnParticles = ((Component)val).GetComponent<ParticleSystem>();
				}
				else if (((Object)val).name.Contains("Explosion"))
				{
					exp_src = ((Component)val).GetComponent<AudioSource>();
					exp_src.outputAudioMixerGroup = AudioManager.instance.SoundMasterGroup;
					exp_rend = ((Component)val).GetComponent<SpriteRenderer>();
				}
			}
		}

		internal void Start()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			SetupComponents();
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				LevelPoint[] array = Object.FindObjectsByType<LevelPoint>((FindObjectsSortMode)0);
				foreach (LevelPoint val in array)
				{
					waypoints.Add(((Component)val).transform.position);
				}
			}
			((Collider)((Component)this).GetComponent<BoxCollider>()).enabled = false;
			((Behaviour)hurt).enabled = false;
			isSpawned = false;
			agent.isStopped = false;
			((Component)root).gameObject.SetActive(false);
			((Behaviour)agent).enabled = SemiFunc.IsMasterClientOrSingleplayer();
			if (SemiFunc.IsMultiplayer() && PhotonNetwork.IsMasterClient)
			{
				photonView.TransferOwnership(PhotonNetwork.LocalPlayer);
			}
			MonoBehaviour.print((object)("agent.enabled: " + ((Behaviour)agent).enabled + ", Transform View: " + (object)((Component)this).GetComponent<PhotonTransformView>()));
			setupDone = true;
		}

		[PunRPC]
		private void SpawnRPC()
		{
			//IL_0053: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.Multiplayer())
			{
				int num = (ChaosMod.Instance.familyFriendly ? 1 : 0);
			}
			exp_src.Stop();
			playAnimation = false;
			exp_rend.sprite = null;
			curAnimFrame = 0;
			isSpawned = true;
			src.Play();
			startPos = ((Component)this).transform.position;
			startEuler = ((Component)this).transform.eulerAngles;
			spawnParticles.Play();
			((Component)root).gameObject.SetActive(true);
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				agent.isStopped = false;
			}
			((Collider)((Component)this).GetComponent<BoxCollider>()).enabled = true;
			((Behaviour)hurt).enabled = true;
			GoToNextPoint();
			PhotonNetwork.AddCallbackTarget((object)this);
		}

		public void Spawn()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (GameManager.Multiplayer())
				{
					photonView.RPC("SpawnRPC", (RpcTarget)0, Array.Empty<object>());
				}
				else
				{
					SpawnRPC();
				}
			}
		}

		[PunRPC]
		private void DespawnRPC(bool slient = false)
		{
			if (!slient)
			{
				exp_src.Play();
				curAnimTime = 0f;
				playAnimation = true;
			}
			else
			{
				PhotonNetwork.RemoveCallbackTarget((object)this);
			}
			((Behaviour)hurt).enabled = false;
			isSpawned = false;
		}

		public void Despawn(bool slient = false)
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (GameManager.Multiplayer())
				{
					photonView.RPC("DespawnRPC", (RpcTarget)0, new object[1] { slient });
				}
				else
				{
					DespawnRPC(slient);
				}
			}
		}

		[PunRPC]
		private void HonkRPC()
		{
			if (isSpawned || !(honkTimer > 0f))
			{
				honkTimer = 1f;
				exp_src.PlayOneShot(honk, 0.4f);
			}
		}

		private void Honk()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (GameManager.Multiplayer())
				{
					photonView.RPC("HonkRPC", (RpcTarget)0, Array.Empty<object>());
				}
				else
				{
					HonkRPC();
				}
			}
		}

		public void GoToNextPoint()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if ((waypoints.Count != 0 || isSpawned) && SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (Random.Range(0, 100) <= 25)
				{
					List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
					SetDestination(((Component)list[Random.Range(0, list.Count)]).transform.position);
				}
				else
				{
					SetDestination(waypoints[Random.Range(0, waypoints.Count)]);
				}
			}
		}

		private void Hide()
		{
			src.Stop();
			((Component)root).gameObject.SetActive(false);
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				agent.isStopped = true;
			}
			((Collider)((Component)this).GetComponent<BoxCollider>()).enabled = false;
		}

		private void OnDestroy()
		{
			if (GameManager.Multiplayer() || SemiFunc.IsMasterClient())
			{
				PhotonNetwork.RemoveCallbackTarget((object)this);
			}
		}

		[PunRPC]
		private void SetDestinationRPC(float x, float y, float z)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				agent.destination = new Vector3(x, y, z);
			}
			lastYRotation = ((Component)this).transform.eulerAngles.y;
		}

		private void SetDestination(Vector3 pos)
		{
			//IL_0052: 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_005e: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (GameManager.Multiplayer())
				{
					photonView.RPC("SetDestinationRPC", (RpcTarget)0, new object[3] { pos.x, pos.y, pos.z });
				}
				else
				{
					SetDestinationRPC(pos.x, pos.y, pos.z);
				}
			}
		}

		private void Update()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			if (honkTimer > 0f)
			{
				honkTimer -= Time.deltaTime;
			}
			if ((Object)(object)exp_rend == (Object)null)
			{
				SetupComponents();
			}
			((Component)exp_rend).transform.LookAt(((Component)Camera.main).transform, Vector3.up);
			if (spawnParticles.isPlaying)
			{
				((Component)spawnParticles).transform.position = startPos;
				((Component)spawnParticles).transform.eulerAngles = startEuler;
			}
			if (SemiFunc.IsMasterClientOrSingleplayer() && agent.isOnNavMesh && !agent.pathPending && agent.remainingDistance <= 1f && isSpawned)
			{
				GoToNextPoint();
			}
			if (playAnimation)
			{
				if (curAnimTime > 0f)
				{
					curAnimTime -= Time.unscaledDeltaTime;
				}
				else
				{
					curAnimTime = exp_anim_frame;
					exp_rend.sprite = exp_sprites[curAnimFrame];
					if (curAnimFrame == 5)
					{
						Hide();
					}
					curAnimFrame = Mathf.Clamp(curAnimFrame + 1, 0, exp_sprites.Count - 1);
				}
			}
			if (!isSpawned && (Object)(object)mapCustom != (Object)null)
			{
				mapCustom.Hide();
			}
			Vector3 velocity = agent.velocity;
			float num = ((Vector3)(ref velocity)).magnitude * 4f;
			float num2 = num - lastAgentSpeed;
			lastAgentSpeed = num;
			curSpeedDelta = Mathf.Floor(num2 * 100f) / 100f;
			if (Mathf.Abs(curSpeedDelta) <= 0.01f)
			{
				curSpeedDelta = 0f;
			}
			src.pitch = num / agent.speed + 1f;
			float num3 = Mathf.Sign(curSpeedDelta);
			foreach (Light backLight in backLights)
			{
				if (num3 >= 0f)
				{
					backLight.intensity = 0.5f;
				}
				else if (num3 < 0f)
				{
					backLight.intensity = 1f;
				}
			}
			float y = ((Component)this).transform.eulerAngles.y;
			float num4 = Mathf.DeltaAngle(lastYRotation, y);
			rotationSpeed = num4 / Time.deltaTime;
			lastYRotation = y;
			rotateTimer += Time.deltaTime * num;
			float num5 = ((Component)this).transform.eulerAngles.y - 90f;
			foreach (Transform frontWheel in FrontWheels)
			{
				frontWheel.eulerAngles = new Vector3(frontWheel.eulerAngles.x, num5 + Mathf.Clamp(rotationSpeed / agent.angularSpeed * 45f, -45f, 45f), 0f - rotateTimer);
			}
			foreach (Transform backWheel in BackWheels)
			{
				backWheel.eulerAngles = new Vector3(backWheel.eulerAngles.x, backWheel.eulerAngles.y, 0f - rotateTimer);
			}
			if (SemiFunc.IsNotMasterClient())
			{
				if (hasPosData)
				{
					((Component)this).transform.position = targetPos;
					((Component)this).transform.eulerAngles = targetRot;
				}
				hasPosData = false;
			}
		}

		private Transform GetParentTransformByNameContains(Transform start, string name)
		{
			Transform parent = ((Component)start).transform.parent;
			while (!((Object)parent).name.Contains(name) && (Object)(object)parent.parent != (Object)null)
			{
				parent = parent.parent;
			}
			return parent;
		}

		private void FixedUpdate()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//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_003f: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0074: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() || !isSpawned)
			{
				return;
			}
			Vector3 val = ((Component)this).transform.position + ((Component)this).transform.forward * 7.5f + Vector3.up * 3f;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(1.25f, 1.25f, 0.5f);
			Vector3 forward = ((Component)this).transform.forward;
			float num = 20f;
			RaycastHit val3 = default(RaycastHit);
			if (Physics.BoxCast(val, val2, forward, ref val3, ((Component)this).transform.rotation, num))
			{
				Transform parentTransformByNameContains = GetParentTransformByNameContains(((RaycastHit)(ref val3)).transform, "Player");
				if ((Object)(object)parentTransformByNameContains != (Object)null && ((Object)parentTransformByNameContains).name.Contains("Player"))
				{
					SetDestination(((RaycastHit)(ref val3)).transform.position);
					if (honkTimer <= 0f)
					{
						Honk();
					}
				}
			}
			if (SemiFunc.IsMultiplayer())
			{
				PhotonNetwork.RaiseEvent((byte)1, (object)((Component)agent).transform.position, new RaiseEventOptions
				{
					Receivers = (ReceiverGroup)0
				}, SendOptions.SendUnreliable);
				PhotonNetwork.RaiseEvent((byte)2, (object)((Component)agent).transform.eulerAngles, new RaiseEventOptions
				{
					Receivers = (ReceiverGroup)0
				}, SendOptions.SendUnreliable);
			}
		}

		public void OnEvent(EventData photonEvent)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (photonEvent.Code == 1)
			{
				targetPos = (Vector3)photonEvent.CustomData;
				hasPosData = true;
			}
			if (photonEvent.Code == 2)
			{
				targetRot = (Vector3)photonEvent.CustomData;
				hasPosData = true;
			}
		}
	}
	public class SpawnMonster : Modifier
	{
		private string monsterPrefabPath = "enemies";

		private GameObject[] monsters;

		public int count = 1;

		public SpawnMonster(int count)
			: base("evt_spawn_monsters", "evt_spawn_monsters_desc")
		{
			this.count = count;
			isOnce = true;
			ID = 1;
			monsters = Resources.LoadAll<GameObject>(monsterPrefabPath);
		}

		public override string GetName()
		{
			return Language.GetText(name).Replace("%f", count.ToString());
		}

		public override void Start()
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			if (ChaosMod.IsDebug)
			{
				ChaosMod.Logger.LogInfo((object)("Spawn " + count + " enemys"));
			}
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			LevelPoint[] array = Object.FindObjectsByType<LevelPoint>((FindObjectsSortMode)0);
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is SpawnMonster && !Modifiers.Excludes.Contains(@event.Instance))
				{
					Modifiers.Excludes.Add(@event.Instance);
				}
			}
			int num = 0;
			List<EnemySetup> enemiesDifficulty = EnemyDirector.instance.enemiesDifficulty1;
			List<EnemySetup> enemiesDifficulty2 = EnemyDirector.instance.enemiesDifficulty2;
			List<EnemySetup> enemiesDifficulty3 = EnemyDirector.instance.enemiesDifficulty3;
			List<EnemySetup> list = new List<EnemySetup>(enemiesDifficulty.Count + enemiesDifficulty2.Count + enemiesDifficulty3.Count);
			list.AddRange(enemiesDifficulty);
			list.AddRange(enemiesDifficulty2);
			list.AddRange(enemiesDifficulty3);
			List<EnemySetup> list2 = list;
			foreach (EnemySetup item in list2)
			{
				if (num >= count)
				{
					break;
				}
				if (Random.Range(0f, 1f) <= 0.6f)
				{
					continue;
				}
				List<EnemyParent> list3 = Enemies.SpawnEnemy(item, ((Component)array[Random.Range(0, array.Length)]).transform.position, Quaternion.identity, false);
				foreach (EnemyParent item2 in list3)
				{
					if (!ChaosMod.Instance.spawnedEnemys.Contains(item2))
					{
						ChaosMod.Instance.spawnedEnemys.Add(item2);
					}
				}
				ChaosMod.Logger.LogInfo((object)("적 스폰됨: " + ((Object)item).name));
				num++;
			}
		}

		public override Modifier Clone()
		{
			return new SpawnMonster(count)
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class Tumble : Modifier
	{
		public Tumble()
			: base("evt_tumble", "evt_tumble_desc")
		{
			isOnce = true;
			ID = 2;
		}

		public override void Start()
		{
			base.Start();
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PlayerTumble[] array = Object.FindObjectsByType<PlayerTumble>((FindObjectsSortMode)0);
				foreach (PlayerTumble val in array)
				{
					val.TumbleSet(true, false);
					val.TumbleOverrideTime(Random.Range(2f, 3f));
				}
			}
		}

		public override Modifier Clone()
		{
			return new Tumble
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class GameSpeed : Modifier
	{
		public float mult = 1f;

		public GameSpeed(float mult)
			: base("evt_game_speed", "evt_game_speed_desc")
		{
			minTimer = 20f;
			maxTimer = 25f;
			this.mult = mult;
			ID = 3;
		}

		public override string GetName()
		{
			return Language.GetText(name).Replace("%f", mult.ToString());
		}

		public override void Start()
		{
			base.Start();
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is GameSpeed)
				{
					Modifiers.Excludes.Add(@event.Instance);
				}
			}
			Time.timeScale = mult;
		}

		public override void OnFinished()
		{
			base.OnFinished();
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is GameSpeed)
				{
					Modifiers.Excludes.Remove(@event.Instance);
				}
			}
			while (Time.timeScale != 1f)
			{
				Time.timeScale = 1f;
			}
		}

		public override Modifier Clone()
		{
			return new GameSpeed(mult)
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class KillAllMonsters : Modifier
	{
		public KillAllMonsters()
			: base("evt_kill_all_monsters", "evt_kill_all_monsters_desc")
		{
			isOnce = true;
			ID = 4;
		}

		public override void Start()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			EnemyHealth[] array = Object.FindObjectsByType<EnemyHealth>((FindObjectsSortMode)0);
			foreach (EnemyHealth val in array)
			{
				val.Hurt(int.MaxValue, Vector3.zero);
			}
		}

		public override Modifier Clone()
		{
			return new KillAllMonsters
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class QuakeFOV : Modifier
	{
		public QuakeFOV()
			: base("evt_quake_fov", "evt_quake_fov_desc")
		{
			minTimer = 20f;
			maxTimer = 30f;
			ID = 5;
		}

		public override void Update()
		{
			base.Update();
			CameraZoom.Instance.OverrideZoomSet(ChaosMod.Instance.dizzyness ? 150f : 90f, 0.5f, 0.5f, 1f, ((Component)ChaosMod.Instance).gameObject, 10);
		}

		public override Modifier Clone()
		{
			return new QuakeFOV
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class BrokeAllDoor : Modifier
	{
		public BrokeAllDoor()
			: base("evt_break_all_door", "evt_break_all_door_desc")
		{
			isOnce = true;
			ID = 6;
		}

		public override void Start()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			if (ModVars.brokeAllDoor_didRun)
			{
				HingeJoint[] array = Object.FindObjectsByType<HingeJoint>((FindObjectsSortMode)0);
				foreach (HingeJoint val in array)
				{
					((Component)val).GetComponent<PhysGrabObjectImpactDetector>().BreakHeavy(Vector3.zero, true, 0f);
				}
				return;
			}
			ModVars.brokeAllDoor_didRun = true;
			HingeJoint[] array2 = Object.FindObjectsByType<HingeJoint>((FindObjectsSortMode)0);
			foreach (HingeJoint val2 in array2)
			{
				Rigidbody component = ((Component)val2).GetComponent<Rigidbody>();
				component.AddForce(Vector3.forward * 5000f, (ForceMode)1);
			}
		}

		public override Modifier Clone()
		{
			BrokeAllDoor brokeAllDoor = new BrokeAllDoor();
			if (ModVars.brokeAllDoor_didRun)
			{
				base.Instance.name = "문 확인사살";
				base.Instance.options.oncePerLevel = true;
			}
			brokeAllDoor.isClone = true;
			brokeAllDoor.Instance = this;
			return brokeAllDoor;
		}
	}
	public class MonsterSound : Modifier
	{
		public MonsterSound()
			: base("evt_hallucination", "evt_hallucination_desc")
		{
			isOnce = true;
			ID = 7;
		}

		public override void Start()
		{
			base.Start();
			AudioClip val = null;
			float num = 1f;
			float num2 = 1f;
			bool flag = false;
			EnemyParent[] array = Object.FindObjectsByType<EnemyParent>((FindObjectsSortMode)0);
			foreach (EnemyParent val2 in array)
			{
				if (Random.Range(0f, 1f) <= 0.5f)
				{
					switch (((Object)val2).name)
					{
					case "Clown":
					{
						EnemyBeamerAnim componentInChildren16 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyBeamerAnim>(true);
						val = componentInChildren16.soundAttackIntro.Sounds[0];
						num = componentInChildren16.soundAttackIntro.Volume;
						flag = true;
						break;
					}
					case "Animal":
					{
						EnemyAnimalAnim componentInChildren15 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyAnimalAnim>(true);
						val = componentInChildren15.noticeSound.Sounds[Random.Range(0, componentInChildren15.noticeSound.Sounds.Length)];
						num = 0.3f;
						flag = true;
						break;
					}
					case "Chef":
						flag = true;
						break;
					case "Cleanup Crew":
					{
						EnemyBombThrowerAnim componentInChildren14 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyBombThrowerAnim>(true);
						val = componentInChildren14.soundTorsoHeadsScream.Sounds[0];
						num = 0.45f;
						flag = true;
						break;
					}
					case "Apex Predator":
					{
						EnemyDuckAnim componentInChildren13 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyDuckAnim>(true);
						val = componentInChildren13.noticeSound.Sounds[Random.Range(0, componentInChildren13.noticeSound.Sounds.Length)];
						num = 0.4f;
						flag = true;
						break;
					}
					case "Elsa":
					{
						EnemyElsaAnim componentInChildren12 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyElsaAnim>(true);
						val = componentInChildren12.barkSmallSound.Sounds[Random.Range(0, componentInChildren12.barkSmallSound.Sounds.Length)];
						num = 0.375f + Random.Range(0f, 0.02f);
						num2 += Random.Range(0f, 0.1f);
						flag = true;
						break;
					}
					case "Mentalist":
					{
						EnemyFloaterAnim componentInChildren11 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyFloaterAnim>(true);
						val = componentInChildren11.sfxMoveLong.Sounds[Random.Range(0, componentInChildren11.sfxMoveLong.Sounds.Length)];
						num = 0.3f + Random.Range(0f, 0.05f);
						num2 += Random.Range(0f, 0.1f);
						flag = true;
						break;
					}
					case "Gnome":
					{
						EnemyGnomeAnim componentInChildren10 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyGnomeAnim>(true);
						val = componentInChildren10.soundNotice.Sounds[Random.Range(0, componentInChildren10.soundNotice.Sounds.Length)];
						num = 0.2f + Random.Range(0f, 0.05f);
						num2 += Random.Range(0f, 0.05f);
						flag = true;
						break;
					}
					case "Headman":
					{
						EnemyHeadAnimationSystem componentInChildren9 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyHeadAnimationSystem>(true);
						val = componentInChildren9.ChaseBegin.Sounds[0];
						num = componentInChildren9.ChaseBegin.Volume;
						flag = true;
						break;
					}
					case "Headgrab":
					{
						EnemyHeadGrabberAnim componentInChildren8 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyHeadGrabberAnim>(true);
						val = componentInChildren8.soundNotice.Sounds[0];
						num = 0.4f;
						break;
					}
					case "Heart Hugger":
					{
						EnemyHeartHugger componentInChildren7 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyHeartHugger>(true);
						val = componentInChildren7.soundGrow.Sounds[Random.Range(0, componentInChildren7.soundGrow.Sounds.Length)];
						num = 0.5f + Random.Range(0f, 0.1f);
						num2 += Random.Range(0f, 0.1f);
						flag = true;
						break;
					}
					case "Hidden":
					{
						EnemyHiddenAnim componentInChildren6 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyHiddenAnim>(true);
						val = componentInChildren6.soundBreatheInFast.Sounds[Random.Range(0, componentInChildren6.soundBreatheInFast.Sounds.Length)];
						num = 0.1f + Random.Range(0f, 0.02f);
						num2 += Random.Range(0f, 0.1f);
						flag = true;
						break;
					}
					case "Huntsman":
					{
						EnemyHunterAnim componentInChildren5 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyHunterAnim>(true);
						val = componentInChildren5.aimStartClips[Random.Range(0, componentInChildren5.aimStartClips.Length)];
						num = 0.5f;
						flag = true;
						break;
					}
					case "Trudge":
					{
						EnemySlowWalkerAnim componentInChildren4 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemySlowWalkerAnim>(true);
						val = componentInChildren4.sfxNoticeVoice.Sounds[Random.Range(0, componentInChildren4.sfxNoticeVoice.Sounds.Length)];
						num = 0.5f + Random.Range(0f, 0.1f);
						num2 += Random.Range(0f, 0.1f);
						flag = true;
						break;
					}
					case "Tick":
					{
						EnemyTickAnim componentInChildren3 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyTickAnim>(true);
						val = componentInChildren3.noticeSound.Sounds[Random.Range(0, componentInChildren3.noticeSound.Sounds.Length)];
						num = 0.5f + Random.Range(0f, 0.1f);
						num2 += Random.Range(0f, 0.1f);
						flag = true;
						break;
					}
					case "Bella":
					{
						EnemyTricycle componentInChildren2 = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyTricycle>(true);
						val = componentInChildren2.audioBell.Sounds[Random.Range(0, componentInChildren2.audioBell.Sounds.Length)];
						num = 0.8f;
						flag = true;
						break;
					}
					case "Rugrat":
					{
						EnemyValuableThrowerAnim componentInChildren = ((Component)((Component)val2).transform).GetComponentInChildren<EnemyValuableThrowerAnim>(true);
						val = componentInChildren.noticeSound.Sounds[0];
						num = 0.4f + Random.Range(0f, 0.05f);
						num2 += Random.Range(0f, 0.1f);
						flag = true;
						break;
					}
					}
				}
				if (flag)
				{
					break;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				ChaosMod.Instance.EnemyAS.pitch = num2;
				ChaosMod.Instance.EnemyAS.PlayOneShot(val, num);
			}
		}

		public override Modifier Clone()
		{
			return new MonsterSound
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class AddHealth : Modifier
	{
		public int amount;

		public AddHealth(int amount)
			: base("체력 추가", "evt_health_desc")
		{
			this.amount = amount;
			name = ((amount >= 0) ? "+" : "") + $"{amount} HP";
			isOnce = true;
			options.oncePerLevel = true;
			ID = 8;
		}

		public override string GetName()
		{
			return name;
		}

		public override void Start()
		{
			base.Start();
			if (amount == 0)
			{
				return;
			}
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PlayerHealth[] array = Object.FindObjectsByType<PlayerHealth>((FindObjectsSortMode)0);
				foreach (PlayerHealth val in array)
				{
					if (Mathf.Sign((float)amount) < 0f)
					{
						val.Hurt(Mathf.Abs(amount), true, -1);
					}
					else
					{
						val.Heal(Mathf.Abs(amount), true);
					}
				}
			}
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is AddHealth)
				{
					Modifiers.Excludes.Add(@event);
				}
			}
		}

		public override Modifier Clone()
		{
			return new AddHealth(amount)
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class HideHealthUI : Modifier
	{
		public HideHealthUI()
			: base("evt_hide_health", "evt_hide_health_desc")
		{
			minTimer = 20f;
			maxTimer = 35f;
			ID = 9;
		}

		public override void Update()
		{
			base.Update();
			HealthUI instance = HealthUI.instance;
			((SemiUI)instance).Hide();
		}

		public override void OnFinished()
		{
			base.OnFinished();
			HealthUI instance = HealthUI.instance;
			((SemiUI)instance).Show();
		}

		public override Modifier Clone()
		{
			return new HideHealthUI
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class HideSprintUI : Modifier
	{
		public HideSprintUI()
			: base("evt_hide_sprint", "evt_hide_sprint_desc")
		{
			minTimer = 20f;
			maxTimer = 35f;
			ID = 10;
		}

		public override void Update()
		{
			base.Update();
			EnergyUI instance = EnergyUI.instance;
			((SemiUI)instance).Hide();
		}

		public override void OnFinished()
		{
			base.OnFinished();
			HealthUI instance = HealthUI.instance;
			((SemiUI)instance).Show();
		}

		public override Modifier Clone()
		{
			return new HideSprintUI
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class DisablePostProcessing : Modifier
	{
		public static GameObject post;

		public DisablePostProcessing()
			: base("evt_disable_post_processing", "evt_disable_post_processing_desc")
		{
			minTimer = 30f;
			maxTimer = 60f;
			ID = 11;
		}

		public override void Start()
		{
			base.Start();
			if ((Object)(object)post == (Object)null)
			{
				post = ((Component)((Component)Object.FindAnyObjectByType<PostProcessing>()).transform.parent).gameObject;
			}
			post.SetActive(false);
		}

		public override Modifier Clone()
		{
			return new DisablePostProcessing
			{
				isClone = true,
				Instance = this
			};
		}

		public override void OnFinished()
		{
			base.OnFinished();
			post.SetActive(true);
		}
	}
	public class JointAreDoors : Modifier
	{
		public JointAreDoors()
			: base("evt_show_all_drawers_in_map", "evt_show_all_drawers_in_map_desc")
		{
			isOnce = true;
			options.oncePerLevel = true;
			ID = 12;
		}

		public override void Start()
		{
			base.Start();
			DirtFinderMapDoorTarget val = Object.FindAnyObjectByType<DirtFinderMapDoorTarget>();
			if ((Object)(object)val == (Object)null)
			{
				if (ChaosMod.IsDebug)
				{
					ChaosMod.Logger.LogWarning((object)"DirtFinderMapDoorTarget을 찾지 못하였습니다.");
				}
				return;
			}
			HingeJoint[] array = Object.FindObjectsByType<HingeJoint>((FindObjectsSortMode)0);
			DirtFinderMapDoor val3 = default(DirtFinderMapDoor);
			foreach (HingeJoint val2 in array)
			{
				if (!((Component)val2).TryGetComponent<DirtFinderMapDoor>(ref val3))
				{
					DirtFinderMapDoor val4 = ((Component)val2).gameObject.AddComponent<DirtFinderMapDoor>();
					val4.DoorPrefab = ((Component)val).gameObject;
				}
			}
		}

		public override Modifier Clone()
		{
			return new JointAreDoors
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class DuckMadness : Modifier
	{
		private string rubberDuckPath = "items/Item Rubber Duck";

		private GameObject rubberDuckPrefab;

		public List<ItemRubberDuck> ducks = new List<ItemRubberDuck>();

		public DuckMadness()
			: base("evt_crazy_ducks", "evt_crazy_ducks_desc")
		{
			minTimer = 25f;
			maxTimer = 30f;
			ID = 13;
			rubberDuckPrefab = Resources.Load<GameObject>(rubberDuckPath);
			if ((Object)(object)rubberDuckPrefab == (Object)null)
			{
				ChaosMod.Logger.LogError((object)"rubberDuckPrefab이 존재하지 않습니다!");
			}
		}

		public override void Start()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			if (!Modifiers.Excludes.Contains(base.Instance))
			{
				Modifiers.Excludes.Add(base.Instance);
			}
			List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
			foreach (PlayerAvatar item in list)
			{
				Vector3 val = ((Component)item).transform.position + Vector3.up;
				Quaternion rotation = ((Component)item).transform.rotation;
				for (int i = 0; i < 9 - list.Count; i++)
				{
					GameObject val2 = null;
					val2 = ((!GameManager.Multiplayer()) ? Object.Instantiate<GameObject>(rubberDuckPrefab, val, rotation) : PhotonNetwork.Instantiate(rubberDuckPath, val, rotation, (byte)0, (object[])null));
					Rigidbody component = val2.GetComponent<Rigidbody>();
					component.isKinematic = false;
					component.AddForce(val2.transform.forward * 100f);
					val2.GetComponent<ItemBattery>().autoDrain = false;
					val2.GetComponent<ItemBattery>().batteryActive = false;
					ItemRubberDuck component2 = val2.GetComponent<ItemRubberDuck>();
					((DuckMadness)base.Instance).ducks.Add(component2);
				}
			}
		}

		public override void Update()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0060: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			base.Update();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			foreach (ItemRubberDuck duck in ((DuckMadness)base.Instance).ducks)
			{
				PhysGrabObject component = ((Component)duck).GetComponent<PhysGrabObject>();
				Rigidbody component2 = ((Component)duck).GetComponent<Rigidbody>();
				component2.AddForce(((Component)duck).transform.forward * 100f);
				Vector3 velocity = component2.velocity;
				if (((Vector3)(ref velocity)).magnitude > 500f)
				{
					velocity = component2.velocity;
					component2.velocity = ((Vector3)(ref velocity)).normalized * 500f;
				}
				if (component.playerGrabbing.Count <= 0 || !SemiFunc.IsMasterClientOrSingleplayer())
				{
					continue;
				}
				foreach (PhysGrabber item in component.playerGrabbing)
				{
					if (!((Object)(object)item == (Object)null))
					{
						if (!GameManager.Multiplayer())
						{
							item.ReleaseObject(((Component)duck).GetComponent<PhotonView>().ViewID, 0.1f);
							continue;
						}
						item.photonView.RPC("ReleaseObjectRPC", (RpcTarget)0, new object[3]
						{
							false,
							((Component)duck).GetComponent<PhotonView>().ViewID,
							0.1f
						});
					}
				}
			}
		}

		public override void OnFinished()
		{
			base.OnFinished();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			for (int i = 0; i < ((DuckMadness)base.Instance).ducks.Count; i++)
			{
				GameObject gameObject = ((Component)((DuckMadness)base.Instance).ducks[i]).gameObject;
				if (!((Object)(object)gameObject == (Object)null))
				{
					if (GameManager.Multiplayer())
					{
						PhotonNetwork.Destroy(gameObject);
					}
					else
					{
						Object.Destroy((Object)(object)gameObject);
					}
				}
			}
			((DuckMadness)base.Instance).ducks.Clear();
			if (Modifiers.Excludes.Contains(base.Instance))
			{
				Modifiers.Excludes.Remove(base.Instance);
			}
		}

		public override Modifier Clone()
		{
			return new DuckMadness
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class SayRandomThnings : Modifier
	{
		public static string[] tries = new string[35]
		{
			"What the fuck did you just fucking say about me, you little bitch?", "You're suck at this game.", "git gud", "goo goo ga ga.", "AAAAAAAAAAAAAAAAAAAAAAAA", "OOOOOOOOOOOOOOOOOO", "I love you.", "I hate you.", "go fuck yourself.", "That monster I fucking hate",
			"That robot I fucking hate", "I love this game.", "You are an idiot.", "Do you have one digit IQ?", "son of a bitch.", "jaundice", "goo goo ga ga?", "I have nothing to say.", "I ran out of ideas.", "I LOOOVEEEE",
			"75000 DOLLARS?? OH MY GOSH", "I feel so REPO!", "Tung Tung Tung Tung Tung Tung Tung Tung Tung Sahur", "Brr Brr Patapim", "adorable", "I hate everything.", "The cake is a lie.", "This is Certified hood classic.", "This is the part where he kills you.", "skill issue",
			"CHICKEN JOCKEY", "skibidi", "I. AM. STEVE.", "THanks for playing my mod!", "six sevennn"
		};

		public static string[] familyfriendly = new string[25]
		{
			"You're doing great!", "You're good at this game.", "goo goo ga ga.", "AAAAAAAAAAAAAAAAAAAAAAAA", "OOOOOOOOOOOOOOOOOO", "I love you.", "I hate that monster.", "I love this game.", "jaundice", "goo goo ga ga?",
			"I have nothing to say.", "I ran out of ideas.", "I LOOOVEEEE", "75000 DOLLARS?? OH MY GOSH", "I feel so REPO!", "Tung Tung Tung Tung Tung Tung Tung Tung Tung Sahur", "Brr Brr Patapim", "adorable", "The cake is a lie.", "This is Certified hood classic.",
			"This is the part where he kills you!", "CHICKEN JOCKEY", "skibidi", "I. AM. STEVE.", "Thanks for playing my mod!"
		};

		public SayRandomThnings()
			: base("evt_say_random_thing", "evt_say_random_thing_desc")
		{
			isOnce = true;
			options.multiplayerOnly = true;
			ID = 14;
		}

		public override void Start()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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)
			base.Start();
			ChatManager instance = ChatManager.instance;
			string text = tries[Random.Range(0, tries.Length)];
			if (ChaosMod.Instance.familyFriendly)
			{
				string[] array = new string[6] { "fuck", "fucking", "suck", "bitch", "idiot", "kill" };
				string[] array2 = array;
				foreach (string text2 in array2)
				{
					if (text.Contains(text2))
					{
						text = text.Replace(text2, "(REDACTED)");
					}
				}
			}
			instance.PossessChatScheduleStart(4);
			instance.PossessChat((PossessChatID)0, text, 1.75f, Color.Lerp(Color.yellow, new Color(0f, 0.5f, 1f), Random.Range(0f, 1f)), 0f, false, 0, (UnityEvent)null);
			instance.PossessChatScheduleEnd();
		}

		public override Modifier Clone()
		{
			return new SayRandomThnings
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class ShakeScreen : Modifier
	{
		[CompilerGenerated]
		private sealed class <AudioFadeIn>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private AudioSource <src>5__2;

			private Func<float, float> <ease>5__3;

			private float <step>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<src>5__2 = null;
				<ease>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<src>5__2 = ChaosMod.Instance.RumbleAS;
					<src>5__2.volume = 0f;
					<src>5__2.Play();
					<ease>5__3 = (float t) => Mathf.Pow(t, 3.322f);
					<step>5__4 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<step>5__4 < 1f)
				{
					<src>5__2.volume = <ease>5__3(<step>5__4);
					<step>5__4 += Time.unscaledDeltaTime;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				}
				<src>5__2.volume = 1f;
				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();
			}
		}

		[CompilerGenerated]
		private sealed class <AudioFadeOut>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private AudioSource <src>5__2;

			private Func<float, float> <ease>5__3;

			private float <step>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<src>5__2 = null;
				<ease>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<src>5__2 = ChaosMod.Instance.RumbleAS;
					<src>5__2.volume = 1f;
					<ease>5__3 = (float t) => Mathf.Pow(0f - t, 3.322f) + 1f;
					<step>5__4 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<step>5__4 < 1f)
				{
					<src>5__2.volume = <ease>5__3(<step>5__4);
					<step>5__4 += Time.unscaledDeltaTime;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				}
				<src>5__2.volume = 0f;
				<src>5__2.Stop();
				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 ShakeScreen()
			: base("evt_earthquake", "evt_earthquake_desc")
		{
			minTimer = 15f;
			maxTimer = 20f;
			ID = 15;
		}

		public override Modifier Clone()
		{
			return new ShakeScreen
			{
				isClone = true,
				Instance = this
			};
		}

		public override void Start()
		{
			base.Start();
			if (ChaosMod.Instance.dizzyness)
			{
				ChaosMod.Instance.RumbleAS.volume = 1f;
				ChaosMod.Instance.RumbleAS.Play();
			}
		}

		public override void Update()
		{
			base.Update();
			if (ChaosMod.Instance.dizzyness)
			{
				GameDirector.instance.CameraShake.Shake(2f, 0.5f);
				GameDirector.instance.CameraImpact.Shake(2f, 0.5f);
			}
		}

		public override void OnFinished()
		{
			base.OnFinished();
			if (ChaosMod.Instance.dizzyness)
			{
				((MonoBehaviour)ChaosMod.Instance).StartCoroutine(AudioFadeOut());
			}
		}

		[IteratorStateMachine(typeof(<AudioFadeIn>d__5))]
		private IEnumerator AudioFadeIn()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AudioFadeIn>d__5(0);
		}

		[IteratorStateMachine(typeof(<AudioFadeOut>d__6))]
		private IEnumerator AudioFadeOut()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AudioFadeOut>d__6(0);
		}
	}
	public class IncreaseValuableWorth : Modifier
	{
		public float mult = 1f;

		public IncreaseValuableWorth(float mult)
			: base("귀중품 가격", "evt_increase_valuable_desc")
		{
			isOnce = true;
			this.mult = mult;
			ID = 16;
		}

		public override string GetName()
		{
			return Language.GetText("evt_increase_valuable").Replace("%f", mult.ToString());
		}

		public override Modifier Clone()
		{
			return new IncreaseValuableWorth(mult)
			{
				isClone = true,
				Instance = this
			};
		}

		public override void Start()
		{
			base.Start();
			List<ValuableObject> valuableList = ValuableDirector.instance.valuableList;
			if (valuableList == null || valuableList.Count == 0)
			{
				if (ChaosMod.IsDebug)
				{
					Debug.LogWarning((object)"귀중품을 찾지 못했습니다. 가격 상승은 없습니다.");
				}
				return;
			}
			foreach (ValuableObject item in valuableList)
			{
				if ((Object)(object)item == (Object)null)
				{
					if (ChaosMod.IsDebug)
					{
						ChaosMod.Logger.LogWarning((object)"아이템 하나를 찾지 못하였습니다. 다음 아이템으로 스킵합니다.");
					}
					continue;
				}
				FieldInfo internalVar = Util.GetInternalVar(item, "dollarValueCurrent");
				FieldInfo internalVar2 = Util.GetInternalVar(item, "dollarValueOriginal");
				float num = (float)internalVar.GetValue(item);
				num *= mult;
				internalVar.SetValue(item, Mathf.RoundToInt(num));
				internalVar2.SetValue(item, Mathf.Max(num, (float)internalVar2.GetValue(item)));
			}
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is IncreaseValuableWorth)
				{
					Modifiers.Excludes.Add(@event);
				}
			}
		}
	}
	public class SpinEternally : Modifier
	{
		public SpinEternally()
			: base("evt_spin", "evt_spin_desc")
		{
			minTimer = 20f;
			maxTimer = 40f;
			ID = 17;
		}

		public override void Start()
		{
			base.Start();
			ChaosMod.Instance.spawnedEnemys = Object.FindObjectsByType<EnemyParent>((FindObjectsSortMode)0).ToHashSet();
		}

		public override Modifier Clone()
		{
			return new SpinEternally
			{
				isClone = true,
				Instance = this
			};
		}

		public override void Update()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			base.Update();
			foreach (EnemyParent spawnedEnemy in ChaosMod.Instance.spawnedEnemys)
			{
				if ((Object)(object)spawnedEnemy == (Object)null)
				{
					continue;
				}
				EnemyRigidbody component = ((Component)spawnedEnemy).GetComponent<EnemyRigidbody>();
				if (!((Object)(object)component == (Object)null))
				{
					Rigidbody component2 = ((Component)component).GetComponent<Rigidbody>();
					Vector3 angularVelocity = component2.angularVelocity;
					if (((Vector3)(ref angularVelocity)).magnitude <= 1500f)
					{
						component2.AddTorque(((Component)component).transform.forward * 500f, (ForceMode)1);
					}
				}
			}
		}
	}
	public class FriendlyMonsters : Modifier
	{
		public FriendlyMonsters()
			: base("evt_friendly_monsters", "evt_friendly_monsters_desc")
		{
			minTimer = 60f;
			maxTimer = 120f;
			ID = 18;
		}

		public override Modifier Clone()
		{
			FriendlyMonsters friendlyMonsters = new FriendlyMonsters();
			friendlyMonsters.isClone = true;
			friendlyMonsters.Instance = this;
			return friendlyMonsters;
		}

		public override void Start()
		{
			base.Start();
			if (!Modifiers.Excludes.Contains(base.Instance))
			{
				Modifiers.Excludes.Add(base.Instance);
			}
			Util.GetInternalVar(EnemyDirector.instance, "debugNoVision").SetValue(EnemyDirector.instance, true);
		}

		public override void OnFinished()
		{
			base.OnFinished();
			if (Modifiers.Excludes.Contains(base.Instance))
			{
				Modifiers.Excludes.Remove(base.Instance);
			}
			Util.GetInternalVar(EnemyDirector.instance, "debugNoVision").SetValue(EnemyDirector.instance, false);
		}
	}
	public class NoJumpAndSprint : Modifier
	{
		public NoJumpAndSprint()
			: base("evt_no_jump_sprint", "evt_no_jump_sprint_desc")
		{
			minTimer = 20f;
			maxTimer = 40f;
			ID = 19;
		}

		public override void Update()
		{
			base.Update();
			PlayerController.instance.EnergyCurrent = 0f;
			PlayerController.instance.OverrideJumpCooldown(timerSelf);
		}

		public override void OnFinished()
		{
			base.OnFinished();
			PlayerController.instance.EnergyCurrent = PlayerController.instance.EnergyStart;
			PlayerController.instance.OverrideJumpCooldown(0f);
		}

		public override Modifier Clone()
		{
			return new NoJumpAndSprint
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class VoicePitch : Modifier
	{
		public float pitch;

		public float timeShit;

		public VoicePitch(float pitch, string name)
			: base("목소리 음조절", "목소리의 음을 조절합니다.")
		{
			minTimer = 30f;
			maxTimer = 60f;
			base.name = name;
			options.multiplayerOnly = true;
			this.pitch = pitch;
			ID = 20;
		}

		public override Modifier Clone()
		{
			return new VoicePitch(pitch, name)
			{
				isClone = true,
				Instance = this
			};
		}

		public override void Update()
		{
			base.Update();
			if (timeShit > 0f)
			{
				timeShit -= Time.unscaledDeltaTime;
				return;
			}
			timeShit = 0.5f;
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				PlayerVoiceChat internalVar = Util.GetInternalVar<PlayerVoiceChat>(item, "voiceChat");
				internalVar.OverridePitch(pitch, 1f, 1f, 0.5f, 0f, 0f);
			}
		}
	}
	public class InvincibleOrb : Modifier
	{
		public InvincibleOrb()
			: base("evt_titanume_orb", "evt_titanume_orb_desc")
		{
			minTimer = 40f;
			maxTimer = 70f;
			ID = 21;
		}

		public override void Update()
		{
			base.Update();
			EnemyValuable[] array = Object.FindObjectsByType<EnemyValuable>((FindObjectsSortMode)0);
			foreach (EnemyValuable val in array)
			{
				((Component)val).GetComponent<PhysGrabObjectImpactDetector>().destroyDisable = true;
			}
		}

		public override Modifier Clone()
		{
			return new InvincibleOrb
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class EyeBig : Modifier
	{
		public EyeBig()
			: base("evt_big_eyes", "evt_big_eyes_desc")
		{
			minTimer = 30f;
			maxTimer = 42.5f;
			options.multiplayerOnly = true;
			ID = 22;
		}

		public override void Update()
		{
			base.Update();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				item.OverridePupilSize(2f, 10, 1f, 1f, 5f, 0.5f, 0.1f);
			}
		}

		public override Modifier Clone()
		{
			return new EyeBig
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class ReviveAllPlayers : Modifier
	{
		public ReviveAllPlayers()
			: base("evt_revive_all", "evt_revive_all_desc")
		{
			ID = 23;
			isOnce = true;
		}

		public override void Start()
		{
			base.Start();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				if (Util.GetInternalVar<bool>(item, "deadSet"))
				{
					item.Revive(false);
					item.playerHealth.Heal(1, true);
				}
			}
		}

		public override Modifier Clone()
		{
			return new ReviveAllPlayers
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class SpawnValuables : Modifier
	{
		public SpawnValuables()
			: base("귀중품 소환", "무작위 귀중품을 아무 곳에 소환합니다.")
		{
			isOnce = true;
			options.oncePerLevel = true;
			ID = 24;
		}

		public override void Start()
		{
			base.Start();
		}

		public override Modifier Clone()
		{
			return new SpawnValuables
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class DisableLighting : Modifier
	{
		public AmbientMode ogAmbientMode;

		public Color ogAmbientLight;

		public DisableLighting()
			: base("evt_disable_all_lights", "evt_disable_all_lights_desc")
		{
			minTimer = 20f;
			maxTimer = 40f;
			ID = 25;
		}

		public override void Start()
		{
			//IL_0013: 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)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			DisableLighting disableLighting = (DisableLighting)base.Instance;
			disableLighting.ogAmbientMode = RenderSettings.ambientMode;
			disableLighting.ogAmbientLight = RenderSettings.ambientLight;
			if (!Modifiers.Excludes.Contains(base.Instance))
			{
				Modifiers.Excludes.Add(base.Instance);
			}
		}

		public override void Update()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			base.Update();
			RenderSettings.ambientMode = (AmbientMode)3;
			RenderSettings.ambientLight = Color.white;
			RenderSettings.fog = false;
		}

		public override void OnFinished()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			base.OnFinished();
			DisableLighting disableLighting = (DisableLighting)base.Instance;
			RenderSettings.ambientMode = disableLighting.ogAmbientMode;
			RenderSettings.ambientLight = disableLighting.ogAmbientLight;
			RenderSettings.fog = true;
			if (Modifiers.Excludes.Contains(base.Instance))
			{
				Modifiers.Excludes.Remove(base.Instance);
			}
		}

		public override Modifier Clone()
		{
			return new DisableLighting();
		}
	}
	public class CarCrash : Modifier
	{
		public static AssetBundle car_assets;

		public CarCrash(bool isClone)
			: base("evt_driver_of_the_year", "evt_driver_of_the_year_desc")
		{
			base.isClone = isClone;
			options.singleplayerOnly = true;
			minTimer = 120f;
			maxTimer = 180f;
			ID = 26;
			if ((Object)(object)car_assets == (Object)null)
			{
				car_assets = AssetBundle.LoadFromFile(Util.GetPluginDirectory("car_assets"));
				ChaosMod.Instance.PrefabToAddNetwork.Add(car_assets.LoadAsset<GameObject>("Killer Joe"));
			}
		}

		public override void Start()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			((Component)ChaosMod.Instance.car).transform.position = Vector3.zero;
			((Component)ChaosMod.Instance.car).transform.rotation = Quaternion.identity;
			ChaosMod.Instance.car.Spawn();
			Modifiers.Excludes.Add(base.Instance);
		}

		public override void OnFinished()
		{
			base.OnFinished();
			ChaosMod.Instance.car.Despawn();
			Modifiers.Excludes.Remove(base.Instance);
		}

		public override Modifier Clone()
		{
			return new CarCrash(isClone: true)
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class NoGravity : Modifier
	{
		public NoGravity()
			: base("evt_moon_gravity", "evt_moon_gravity_desc")
		{
			minTimer = 60f;
			maxTimer = 120f;
			ID = 27;
		}

		public override void Update()
		{
			base.Update();
			PlayerController.instance.AntiGravity(0.1f);
		}

		public override Modifier Clone()
		{
			return new NoGravity
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class ShowAD : Modifier
	{
		public ShowAD()
			: base("광고 시청", "개발자도 먹고 살아야죠...")
		{
		}

		public override float GetTime()
		{
			return ChaosMod.Instance.adViewer.GetLength();
		}

		public override void Start()
		{
			ChaosMod.Instance.adViewer.SetVideo();
			ChaosMod.Instance.adViewer.Show();
			base.Start();
		}

		public override void OnFinished()
		{
			base.OnFinished();
			ChaosMod.Instance.adViewer.Hide();
		}

		public override Modifier Clone()
		{
			return new ShowAD
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class ThinkFast : Modifier
	{
		[CompilerGenerated]
		private sealed class <Flashback>d__8 : 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 <Flashback>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Expected O, but got Unknown
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//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_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					ChaosMod instance = ChaosMod.Instance;
					AudioClip val3 = instance.assets.LoadAsset<AudioClip>("Scout_stunballhit15");
					AudioClip val4 = instance.assets.LoadAsset<AudioClip>("flashbang");
					instance.AudioSource.PlayOneShot(val3);
					text1.SetActive(true);
					((Component)scout).gameObject.SetActive(true);
					<>2__current = (object)new WaitForSecondsRealtime(0.578f);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					text2.SetActive(true);
					<>2__current = (object)new WaitForSecondsRealtime(0.667f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					text1.SetActive(false);
					text2.SetActive(false);
					((Component)scout).gameObject.SetActive(false);
					if (GameManager.Multiplayer())
					{
						GameObject val = PhotonNetwork.Instantiate(StunItemPath, ((Component)PlayerAvatar.instance.localCamera).transform.position + new Vector3(0f, 2f, 0f), Quaternion.identity, (byte)0, (object[])null);
						ChaosController.instance.view.RPC("GrenadeStunExplosionRPC", (RpcTarget)0, new object[1] { val.GetComponent<PhotonView>().ViewID });
					}
					else
					{
						GameObject val2 = Object.Instantiate<GameObject>(StunItemPrefab, ((Component)PlayerAvatar.instance.localCamera).transform.position + new Vector3(0f, 2f, 0f), Quaternion.identity);
						ItemGrenade component = val2.GetComponent<ItemGrenade>();
						component.tickTime = 0f;
						Util.GetInternalVar(component, "isActive").SetValue(component, true);
					}
					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();
			}
		}

		internal static Image flash;

		internal static Image scout;

		internal static GameObject text1;

		internal static GameObject text2;

		internal static string StunItemPath = "items/Item Grenade Stun";

		internal static GameObject StunItemPrefab;

		public ThinkFast()
			: base("evt_think_fast", "evt_think_fast_desc")
		{
			isOnce = true;
			options.oncePerLevel = true;
			ID = 28;
			StunItemPrefab = Resources.Load<GameObject>(StunItemPath);
		}

		public override void Start()
		{
			base.Start();
			((MonoBehaviour)ChaosMod.Instance).StartCoroutine(Flashback());
		}

		[IteratorStateMachine(typeof(<Flashback>d__8))]
		private IEnumerator Flashback()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Flashback>d__8(0);
		}

		public override Modifier Clone()
		{
			return new ThinkFast
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class ForcePause : Modifier
	{
		public ForcePause()
			: base("일시정지", "어르으음!!!")
		{
			isOnce = true;
		}

		public override void Start()
		{
			base.Start();
			Util.GetInternalVar<MenuPage>(MenuPageEsc.instance, "menuPage").PageStateSet((PageState)0);
		}

		public override Modifier Clone()
		{
			return new ForcePause
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class ClubMood : Modifier
	{
		[CompilerGenerated]
		private sealed class <MusicFadeIn>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ClubMood <>4__this;

			private float <t>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ClubMood clubMood = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<t>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<t>5__2 < 1f)
				{
					clubMood.src.volume = <t>5__2;
					<t>5__2 += Time.deltaTime * 2f;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				clubMood.src.volume = 1f;
				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();
			}
		}

		[CompilerGenerated]
		private sealed class <MusicFadeOut>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private AudioSource <src>5__2;

			private float <t>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<src>5__2 = ChaosMod.Instance.ClubSource;
					<t>5__3 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<t>5__3 < 1f)
				{
					<src>5__2.volume = 1f - <t>5__3;
					<t>5__3 += Time.deltaTime * 2f;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<src>5__2.volume = 0f;
				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 float BPM = 140f;

		private float bps;

		private AudioSource src;

		private List<EnemyRigidbody> rbList;

		private Color ogLight = Color.clear;

		private List<PlayerAvatar> players;

		private List<PhysGrabObject> items;

		private int lastBeat = -1;

		private Color[] colors = (Color[])(object)new Color[7]
		{
			Color.red,
			new Color(1f, 1f, 0f),
			Color.yellow,
			Color.green,
			Color.cyan,
			Color.blue,
			Color.magenta
		};

		private Color curColor = Color.clear;

		private Color lastColor = Color.blue;

		private float fov = 70f;

		private float baseFOV = 70f;

		public ClubMood()
			: base("evt_club_mood", "evt_club_mood_desc")
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0036: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			//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)
			ID = 29;
			float num = 60f / BPM;
			while (minTimer < 60f)
			{
				minTimer += num;
			}
			for (maxTimer = minTimer; maxTimer < 90f; maxTimer += num)
			{
			}
		}

		public override void Start()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is ClubMood)
				{
					Modifiers.Excludes.Add(@event);
				}
			}
			ChaosMod.Instance.spawnedEnemys = Object.FindObjectsByType<EnemyParent>((FindObjectsSortMode)0).ToHashSet();
			src = ChaosMod.Instance.ClubSource;
			src.volume = 0f;
			src.Play();
			bps = 60f / BPM;
			ogLight = RenderSettings.ambientLight;
			items = Object.FindObjectsByType<PhysGrabObject>((FindObjectsSortMode)0).ToList();
			players = SemiFunc.PlayerGetAll();
			((MonoBehaviour)ChaosMod.Instance).StartCoroutine(MusicFadeIn());
		}

		[IteratorStateMachine(typeof(<MusicFadeIn>d__9))]
		private IEnumerator MusicFadeIn()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MusicFadeIn>d__9(0)
			{
				<>4__this = this
			};
		}

		public override void Update()
		{
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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)
			float num = src.time / bps;
			if (Mathf.FloorToInt(num) != lastBeat)
			{
				lastBeat = Mathf.FloorToInt(num);
				if (SemiFunc.IsMasterClientOrSingleplayer())
				{
					foreach (EnemyParent spawnedEnemy in ChaosMod.Instance.spawnedEnemys)
					{
						EnemyRigidbody component = ((Component)spawnedEnemy).GetComponent<EnemyRigidbody>();
						if (!((Object)(object)component == (Object)null))
						{
							((Component)component.enemy).GetComponent<EnemyStateStunned>().Set(timerSelf + 5f);
							Rigidbody component2 = ((Component)component).GetComponent<Rigidbody>();
							component2.AddForce(Vector3.up * 15f, (ForceMode)1);
						}
					}
					PhysGrabObjectImpactDetector val = default(PhysGrabObjectImpactDetector);
					foreach (PhysGrabObject item in items)
					{
						if (!((Object)(object)item == (Object)null))
						{
							item.OverrideIndestructible(timerSelf + 3f);
							bool flag = true;
							if (((Component)item).TryGetComponent<PhysGrabObjectImpactDetector>(ref val))
							{
								flag = !val.inCart && !item.grabbed;
							}
							if (((Object)item).name.Contains("Cart"))
							{
								flag = false;
							}
							if (Object.op_Implicit((Object)(object)item.rb) && flag)
							{
								item.rb.AddForce(Vector3.up * (3.5f * item.massOriginal), (ForceMode)1);
							}
						}
					}
				}
				curColor = colors[Random.Range(0, colors.Length)];
				while (curColor == lastColor)
				{
					curColor = colors[Random.Range(0, colors.Length)];
				}
				lastColor = curColor;
				fov = (ChaosMod.Instance.dizzyness ? (baseFOV - 5f) : (baseFOV - 2.5f));
			}
			RenderSettings.ambientLight = curColor;
			float num2 = Mathf.Sin(MathF.PI * 2f * num) * 25f;
			foreach (PlayerAvatar player in players)
			{
				if (!((Object)(object)player == (Object)null))
				{
					if ((Object)(object)SemiFunc.PlayerAvatarLocal() == (Object)(object)player)
					{
						player.playerExpression.OverrideExpressionSet(4, 100f);
						PlayerExpressionsUI.instance.playerExpression.OverrideExpressionSet(4, 100f);
						PlayerExpressionsUI.instance.playerAvatarVisuals.HeadTiltOverride(num2 * 0.5f);
					}
					else
					{
						player.playerAvatarVisuals.HeadTiltOverride(num2);
					}
				}
			}
			CameraZoom.Instance.OverrideZoomSet(fov, 0.5f, 1000f, 1000f, ((Component)ChaosMod.Instance).gameObject, 5);
			fov = Mathf.Lerp(fov, baseFOV, 1f - Mathf.Exp((0f - Time.deltaTime) * 10f));
			float num3 = Util.BeatMath(num, BPM);
			for (int i = 0; i < ChaosMod.Instance.texts.Count; i++)
			{
				TextLerp textLerp = ChaosMod.Instance.texts[i];
				if (Object.op_Implicit((Object)(object)textLerp))
				{
					textLerp.posOffset = new Vector2(num3 * ((i % 2 == 0) ? 1f : (-1f)), 0f);
				}
			}
		}

		[IteratorStateMachine(typeof(<MusicFadeOut>d__17))]
		private IEnumerator MusicFadeOut()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MusicFadeOut>d__17(0);
		}

		public override void OnFinished()
		{
			//IL_0054: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is ClubMood)
				{
					Modifiers.Excludes.Remove(@event);
				}
			}
			((MonoBehaviour)ChaosMod.Instance).StartCoroutine(MusicFadeOut());
			RenderSettings.ambientLight = ogLight;
			for (int i = 0; i < ChaosMod.Instance.texts.Count; i++)
			{
				TextLerp textLerp = ChaosMod.Instance.texts[i];
				if (Object.op_Implicit((Object)(object)textLerp))
				{
					textLerp.posOffset = Vector2.zero;
				}
			}
			base.OnFinished();
		}

		public override Modifier Clone()
		{
			return new ClubMood
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class Doomsday : Modifier
	{
		private List<PlayerAvatar> players;

		private List<PhysGrabObject> items;

		public Doomsday()
			: base("종말", "하루 뒤 지구가 멸망한다면? 하루 뒤라고 하면 한참 남았으니 지금 지구가 멸망하고 있다고 해두죠.")
		{
			minTimer = 30f;
			maxTimer = 60f;
		}

		public override void Start()
		{
			base.Start();
			items = Object.FindObjectsByType<PhysGrabObject>((FindObjectsSortMode)0).ToList();
			items.RemoveAll((PhysGrabObject x) => ((Object)((Component)x).transform).name.Contains("Cart") || ((Object)((Component)x).transform).name.Contains("Tumble"));
			players = SemiFunc.PlayerGetAll();
			ChaosMod.Instance.spawnedEnemys = Object.FindObjectsByType<EnemyParent>((FindObjectsSortMode)0).ToHashSet();
		}

		public override void Update()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0095: 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: 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)
			//IL_00c0: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				Vector3 val;
				foreach (EnemyParent spawnedEnemy in ChaosMod.Instance.spawnedEnemys)
				{
					EnemyRigidbody component = ((Component)spawnedEnemy).GetComponent<EnemyRigidbody>();
					if (!((Object)(object)component == (Object)null))
					{
						((Component)component.enemy).GetComponent<EnemyStateStunned>().Set(timerSelf + 5f);
						Rigidbody component2 = ((Component)component).GetComponent<Rigidbody>();
						val = component2.velocity;
						if (((Vector3)(ref val)).magnitude <= 50f)
						{
							component2.AddForce(((Component)component2).transform.up * 10f, (ForceMode)1);
						}
						val = component2.angularVelocity;
						if (((Vector3)(ref val)).magnitude <= 25f)
						{
							component2.AddTorque(((Component)component2).transform.forward * Random.Range(0.5f, 2f) * 10f, (ForceMode)1);
						}
					}
				}
				PhysGrabObjectImpactDetector val2 = default(PhysGrabObjectImpactDetector);
				foreach (PhysGrabObject item in items)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					item.OverrideIndestructible(timerSelf + 3f);
					bool flag = true;
					if (((Component)item).TryGetComponent<PhysGrabObjectImpactDetector>(ref val2))
					{
						flag = !val2.inCart && !item.grabbed;
					}
					if (Object.op_Implicit((Object)(object)item.rb) && flag)
					{
						val = item.rb.velocity;
						if (((Vector3)(ref val)).magnitude <= 25f)
						{
							item.rb.AddForce(((Component)item).transform.up * (2f * item.massOriginal), (ForceMode)1);
						}
						val = item.rb.angularVelocity;
						if (((Vector3)(ref val)).magnitude <= 25f)
						{
							item.rb.AddTorque(((Component)item).transform.forward * (2f * Random.Range(0.5f, 2f) * item.massOriginal), (ForceMode)1);
						}
					}
				}
			}
			if (ChaosMod.Instance.dizzyness)
			{
				GameDirector.instance.CameraShake.Shake(2f, 0.5f);
				GameDirector.instance.CameraImpact.Shake(2f, 0.5f);
			}
		}

		public override Modifier Clone()
		{
			return new Doomsday
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class GravityMult : Modifier
	{
		internal float mult = 1f;

		public GravityMult(float mult)
			: base("evt_gravity_mult", "evt_gravity_mult_desc")
		{
			this.mult = mult;
			minTimer = 30f;
			maxTimer = 60f;
			ID = 30;
		}

		public override string GetName()
		{
			return Language.GetText(name).Replace("%f", mult.ToString());
		}

		public override void Start()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			Physics.gravity = new Vector3(0f, -9.81f * mult, 0f);
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is GravityMult && !Modifiers.Excludes.Contains(@event))
				{
					Modifiers.Excludes.Add(@event);
				}
			}
		}

		public override void OnFinished()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Physics.gravity = new Vector3(0f, -9.81f, 0f);
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is GravityMult && Modifiers.Excludes.Contains(@event))
				{
					Modifiers.Excludes.Remove(@event);
				}
			}
			base.OnFinished();
		}

		public override Modifier Clone()
		{
			return new GravityMult(mult)
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class TimeMult : Modifier
	{
		internal float mult = 1f;

		public TimeMult(float mult)
			: base("evt_timer_mult", "evt_timer_mult_desc")
		{
			this.mult = mult;
			minTimer = 30f;
			maxTimer = 60f;
			ID = 31;
		}

		public override string GetName()
		{
			return Language.GetText(name).Replace("%f", mult.ToString());
		}

		public override void Start()
		{
			base.Start();
			ChaosMod.Instance.controller.timeScale = mult;
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is TimeMult && !Modifiers.Excludes.Contains(@event))
				{
					Modifiers.Excludes.Add(@event);
				}
			}
		}

		public override void OnFinished()
		{
			ChaosMod.Instance.controller.timeScale = 1f;
			foreach (Modifier @event in Modifiers.Events)
			{
				if (@event is TimeMult && Modifiers.Excludes.Contains(@event))
				{
					Modifiers.Excludes.Remove(@event);
				}
			}
			base.OnFinished();
		}

		public override Modifier Clone()
		{
			return new TimeMult(mult)
			{
				isClone = true,
				Instance = this
			};
		}
	}
	public class OilFloor : Modifier
	{
		private List<PlayerAvatar> players = new List<PlayerAvatar>();

		public OilFloor()
			: base("evt_oil_floor", "evt_oil_floor_desc")
		{
			minTimer = 40f;
			maxTimer = 120f;
			ID = 32;
		}

		public override void Start()
		{
			players = SemiFunc.PlayerGetAll();
			base.Start();
		}

		public override void Update()
		{
			foreach (PlayerAvatar player in players)
			{
				ChaosMod.Logger.LogInfo((object)((Component)player).GetComponent<Rigidbody>().drag);
			}
		}

		public override Modifier Clone()
		{
			return new OilFloor
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class RandomUpgrade : Modifier
	{
		public RandomUpgrade()
			: base("evt_random_upgrade", "evt_random_upgrade_desc")
		{
			isOnce = true;
			ID = 33;
		}

		public override void Start()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				UpgradePlayer(item);
			}
			base.Start();
		}

		private void UpgradePlayer(PlayerAvatar plr)
		{
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				string text = SemiFunc.PlayerGetSteamID(plr);
				string text2 = "Map Player Count";
				<>f__AnonymousDelegate0<string, int, int> <>f__AnonymousDelegate = PunManager.instance.UpgradeMapPlayerCount;
				switch (Random.Range(0, 12))
				{
				case 0:
					<>f__AnonymousDelegate = PunManager.instance.UpgradeDeathHeadBattery;
					text2 = "Death Head Battery";
					break;
				case 1:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerCrouchRest;
					text2 = "Crouch Rest";
					break;
				case 2:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerEnergy;
					text2 = "Energy";
					break;
				case 3:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerExtraJump;
					text2 = "Extra Jump";
					break;
				case 4:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerGrabRange;
					text2 = "Grab Range";
					break;
				case 5:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerGrabStrength;
					text2 = "Grab Strength";
					break;
				case 6:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerHealth;
					text2 = "Health";
					break;
				case 7:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerSprintSpeed;
					text2 = "Sprint Speed";
					break;
				case 8:
					if (StatsManager.instance.playerUpgradeMapPlayerCount[text] > 0)
					{
						UpgradePlayer(plr);
					}
					break;
				case 9:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerTumbleClimb;
					text2 = "Tumble Climb";
					break;
				case 10:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerTumbleLaunch;
					text2 = "Tumble Launch";
					break;
				case 11:
					<>f__AnonymousDelegate = PunManager.instance.UpgradePlayerTumbleWings;
					text2 = "Tumble Wings";
					break;
				}
				<>f__AnonymousDelegate(text);
				ChaosMod.Logger.LogInfo((object)(((Object)plr).name + " got \"" + text2 + "\" upgrade."));
			}
			if ((Object)(object)SemiFunc.PlayerAvatarLocal() == (Object)(object)plr)
			{
				StatsUI.instance.Fetch();
				StatsUI.instance.ShowStats();
				CameraGlitch.Instance.PlayUpgrade();
			}
			else
			{
				GameDirector.instance.CameraImpact.ShakeDistance(5f, 1f, 6f, ((Component)plr).transform.position, 0.2f);
			}
			if (!GameManager.Multiplayer() || PhotonNetwork.IsMasterClient)
			{
				plr.playerHealth.MaterialEffectOverride((Effect)0);
			}
		}

		public override Modifier Clone()
		{
			return new RandomUpgrade
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class RandomItems : Modifier
	{
		public RandomItems()
			: base("evt_random_items", "evt_random_items_desc")
		{
			isOnce = true;
			ID = 34;
			options.chance = 90f;
		}

		public override void Start()
		{
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			string text = "items/";
			string[] array = new string[51]
			{
				"Item Cart Cannon", "Item Cart Laser", "Item Cart Small", "Item Cart Medium", "Item Drone Battery", "Item Drone Feather", "Item Drone Indestructible", "Item Drone Torque", "Item Drone Zero Gravity", "Item Duck Bucket",
				"Item Extraction Tracker", "Item Grenade Duct Taped", "Item Grenade Explosive", "Item Grenade Human", "Item Grenade Shockwave", "Item Grenade Stun", "Item Gun Handgun", "Item Gun Laser", "Item Gun Shockwave", "Item Gun Shotgun",
				"Item Gun Stun", "Item Gun Tranq", "Item Health Pack Large", "Item Health Pack Medium", "Item Health Pack Small", "Item Melee Baseball Bat", "Item Melee Frying Pan", "Item Melee Inflatable Hammer", "Item Melee Sledge Hammer", "Item Melee Stun Baton",
				"Item Melee Sword", "Item Mine Explosive", "Item Mine Shockwave", "Item Mine Stun", "Item Orb Zero Gravity", "Item Phase Bridge", "Item Power Crystal", "Item Rubber Duck", "Item Upgrade Death Head Battery", "Item Upgrade Map Player Count",
				"Item Upgrade Player Crouch Rest", "Item Upgrade Player Energy", "Item Upgrade Player Extra Jump", "Item Upgrade Player Grab Range", "Item Upgrade Player Grab Strength", "Item Upgrade Player Health", "Item Upgrade Player Sprint Speed", "Item Upgrade Player Tumble Climb", "Item Upgrade Player Tumble Launch", "Item Upgrade Player Tumble Wings",
				"Item Valuable Tracker"
			};
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				string text2 = text + array[Random.Range(0, array.Length)];
				GameObject val = Object.Instantiate<GameObject>(Resources.Load<GameObject>(text2), ((Component)item).transform.position + new Vector3(0f, 2f, 0f), Quaternion.identity);
			}
			base.Start();
		}

		public override Modifier Clone()
		{
			return new RandomItems
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class InfinteStamina : Modifier
	{
		public InfinteStamina()
			: base("evt_infinite_stamina", "evt_infinite_stamina_desc")
		{
			minTimer = 60f;
			maxTimer = 120f;
			ID = 35;
		}

		public override void Update()
		{
			PlayerController.instance.EnergyCurrent = PlayerController.instance.EnergyStart;
		}

		public override Modifier Clone()
		{
			return new InfinteStamina
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class Invincible : Modifier
	{
		public Invincible()
			: base("evt_invincible", "evt_invincible_desc")
		{
			minTimer = 60f;
			maxTimer = 120f;
			ID = 36;
		}

		public override void Start()
		{
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				Util.GetInternalVar(item.playerHealth, "godMode").SetValue(item.playerHealth, true);
			}
			base.Start();
		}

		public override void OnFinished()
		{
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				Util.GetInternalVar(item.playerHealth, "godMode").SetValue(item.playerHealth, false);
			}
			base.OnFinished();
		}

		public override Modifier Clone()
		{
			return new Invincible
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class FuckGravity : Modifier
	{
		private float gravity;

		public FuckGravity()
			: base("evt_fuck_gravity", "evt_fuck_gravity_desc")
		{
			minTimer = 30f;
			maxTimer = 40f;
			ID = 39;
		}

		public override void Start()
		{
			gravity = -9.81f;
			base.Start();
		}

		private float rand()
		{
			return ((float)Random.Range(0, 2) - 0.5f) * 0.3f;
		}

		public override void Update()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			gravity += rand();
			Physics.gravity = new Vector3(0f, gravity, 0f);
			base.Update();
		}

		public override void OnFinished()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Physics.gravity = new Vector3(0f, -9.81f, 0f);
			base.OnFinished();
		}
	}
	public class InfiniteJump : Modifier
	{
		private FieldInfo jumpCount;

		private float timer;

		public InfiniteJump()
			: base("evt_infinite_jump", "evt_infinite_jump_desc")
		{
			minTimer = 60f;
			maxTimer = 120f;
			ID = 37;
		}

		public override void Start()
		{
			jumpCount = Util.GetInternalVar(PlayerController.instance, "JumpExtraCurrent");
			jumpCount.SetValue(PlayerController.instance, 100);
			base.Start();
		}

		public override void Update()
		{
			if (timer > 0f)
			{
				timer -= Time.fixedDeltaTime;
				return;
			}
			jumpCount.SetValue(PlayerController.instance, 100);
			timer = 1f;
		}

		public override void OnFinished()
		{
			timer = 9E+09f;
			Util.GetInternalVar(PlayerController.instance, "JumpExtraCurrent").SetValue(PlayerController.instance, Util.GetInternalVar<int>(PlayerController.instance, "JumpExtra"));
			base.OnFinished();
		}

		public override Modifier Clone()
		{
			return new InfiniteJump
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class PlayScarySound : Modifier
	{
		public PlayScarySound()
			: base("evt_doodoo_scary", "evt_doodoo_scary_desc")
		{
			isOnce = true;
		}

		public override void Start()
		{
			AudioClip val = ChaosMod.Instance.assets.LoadAsset<AudioClip>("scary_sound" + Random.Range(0, 12));
			ChaosMod.Instance.AudioSource.PlayOneShot(val);
			base.Start();
		}

		public override Modifier Clone()
		{
			return new PlayScarySound
			{
				Instance = this,
				isClone = true
			};
		}
	}
	[HarmonyPatch(typeof(EnemyParent))]
	internal class EnemyParentPatch
	{
		[HarmonyPatch("DespawnRPC")]
		[HarmonyPostfix]
		private static void Despawn_Postfix(EnemyParent __instance)
		{
			if ((Object)(object)ChaosMod.Instance != (Object)null && ChaosMod.Instance.spawnedEnemys.Contains(__instance))
			{
				ChaosMod.Instance.spawnedEnemys.Remove(__instance);
				if (ChaosMod.IsDebug)
				{
					ChaosMod.Logger.LogInfo((object)"Enemy Despawned");
				}
			}
		}

		[HarmonyPatch("SpawnRPC")]
		[HarmonyPostfix]
		private static void Spawn_Postfix(EnemyParent __instance)
		{
			if ((Object)(object)ChaosMod.Instance != (Object)null && !ChaosMod.Instance.spawnedEnemys.Contains(__instance))
			{
				ChaosMod.Instance.spawnedEnemys.Add(__instance);
				if (ChaosMod.IsDebug)
				{
					ChaosMod.Logger.LogInfo((object)"Enemy Spawned");
				}
			}
		}
	}
	internal class EventTimerBar : TextMeshProUGUI
	{
		private float timeLeft;

		private float ogTimeLeft;

		public Color noTimeColor = Color.red;

		public Color enoughTimeColor = Color.green;

		public Vector2 targetPosition = Vector2.zero;

		public void SetTime(float time)
		{
			timeLeft = time;
			ogTimeLeft = time;
		}

		private void Update()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (timeLeft > 0f)
			{
				timeLeft -= Time.unscaledDeltaTime;
			}
			timeLeft = Mathf.Max(0f, timeLeft);
			int num = Mathf.FloorToInt(timeLeft % 60f);
			int num2 = Mathf.FloorToInt(timeLeft / 60f % 60f);
			int num3 = num / 3600;
			string text = "";
			text = ((num3 <= 0) ? (text + $"{num2:D2}:{num:D2}") : (text + $"{num3}:{num2:D2}:{num:D2}"));
			((TMP_Text)this).text = "(" + text + ")";
			((Graphic)this).color = Color.Lerp(noTimeColor, enoughTimeColor, timeLeft / ogTimeLeft);
			((TMP_Text)this).rectTransform.anchoredPosition = Vector2.Lerp(((TMP_Text)this).rectTransform.anchoredPosition, targetPosition, 1f - Mathf.Exp((0f - Time.unscaledDeltaTime) * MathF.PI));
		}
	}
	public class Language
	{
		public static Dictionary<string, string> _table = new Dictionary<string, string>();

		public static void Load(string langCode)
		{
			string pluginDirectory = Util.GetPluginDirectory(langCode + ".json");
			if (!File.Exists(pluginDirectory))
			{
				ChaosMod.Logger.LogError((object)("존제하지 않음: " + pluginDirectory));
				ChaosMod.Logger.LogError((object)("\"" + langCode + "\" 언어 데이터를 찾지 못하였습니다. 언어 키가 보일 수 있습니다."));
				ChaosMod.Logger.LogError((object)("I cannot find language data named \"" + langCode + "\", language keys can be shown."));
			}
			else
			{
				string text = File.ReadAllText(pluginDirectory);
				_table = JsonConvert.DeserializeObject<Dictionary<string, string>>(text) ?? new Dictionary<string, string>();
			}
		}

		public static string GetText(string key)
		{
			if (!_table.TryGetValue(key, out var value))
			{
				return key;
			}
			return value;
		}
	}
	public class Modifiers
	{
		public static readonly List<Modifier> Events = new List<Modifier>();

		public static readonly List<Modifier> ShopEvents = new List<Modifier>();

		public static readonly List<Modifier> DebugEvents = new List<Modifier>();

		public static readonly List<Modifier> Excludes = new List<Modifier>();

		public static void Init(Action<Modifier> callback = null)
		{
			List<Modifier> list = new List<Modifier>
			{
				new Modifier("evt_none", "evt_none_desc")
				{
					isOnce = true
				},
				new Tumble(),
				new KillAllMonsters(),
				new QuakeFOV(),
				new GameSpeed(2f),
				new GameSpeed(0.75f),
				new BrokeAllDoor(),
				new MonsterSound(),
				new AddHealth(100),
				new AddHealth(50),
				new AddHealth(0),
				new AddHealth(-25),
				new HideHealthUI(),
				new HideSprintUI(),
				new JointAreDoors(),
				new DuckMadness(),
				new SayRandomThnings(),
				new ShakeScreen(),
				new IncreaseValuableWorth(2f),
				new IncreaseValuableWorth(0.9f),
				new SpinEternally(),
				new FriendlyMonsters(),
				new VoicePitch(1.5f, "evt_voice_high"),
				new VoicePitch(0.7f, "evt_voice_low"),
				new DisablePostProcessing(),
				new InvincibleOrb(),
				new ReviveAllPlayers(),
				new NoJumpAndSprint(),
				new EyeBig(),
				new DisableLighting(),
				new SpawnMonster(2),
				new SpawnMonster(4),
				new NoGravity(),
				new ThinkFast(),
				new ClubMood(),
				new GravityMult(0.25f),
				new GravityMult(5f),
				new TimeMult(2f),
				new TimeMult(0.5f),
				new TimeMult(4f),
				new RandomItems(),
				new RandomUpgrade(),
				new InfinteStamina(),
				new Invincible(),
				new InfiniteJump()
			};
			if (ChaosMod.IsDebug)
			{
				ChaosMod.Logger.LogInfo((object)("There's currently " + list.Count + " events active."));
			}
			foreach (Modifier item in list)
			{
				callback?.Invoke(item);
				Events.Add(item);
			}
			if (!((Object)(object)ChaosMod.Instance != (Object)null) || !ChaosMod.IsDebug || ChaosMod.Instance.DevMode)
			{
				return;
			}
			List<Modifier> list2 = new List<Modifier>
			{
				new RandomItems(),
				new RandomUpgrade(),
				new InfinteStamina(),
				new Invincible(),
				new InfiniteJump(),
				new MonsterSound()
			};
			foreach (Modifier item2 in list2)
			{
				DebugEvents.Add(item2);
			}
		}

		public static bool CheckExcludes(Modifier mod)
		{
			List<Modifier> list = Excludes.FindAll((Modifier e) => e.GetName() == mod.GetName());
			return list.Count > 0;
		}
	}
	public class ModifierOptions
	{
		public float chance = 1f;

		public bool oncePerLevel;

		public bool multiplayerOnly;

		public bool singleplayerOnly;

		public ModifierOptions(float chance = 1f, bool oncePerLevel = false, bool multiplayerOnly = false, bool singleplayerOnly = false)
		{
			this.chance = Mathf.Clamp01(chance);
			this.oncePerLevel = oncePerLevel;
			this.multiplayerOnly = multiplayerOnly;
			this.singleplayerOnly = singleplayerOnly;
		}
	}
	public class Modifier
	{
		public bool isClone;

		public bool finihshed;

		public bool isOnce;

		public float maxTimer = 10f;

		public float minTimer = 9f;

		public float timerSelf;

		public string name;

		public ModifierOptions options;

		public string description = "";

		public int ID;

		public bool enabled = true;

		public Modifier Instance { get; set; }

		public bool isRunning => timerSelf > 0f;

		public event Action<PlayerAvatar> onPlayerRespawned;

		public event Action<PlayerAvatar> onPlayerDead;

		public event Action<EnemyParent> onEnemyDespawned;

		public event Action<EnemyParent> onEnemyRespawned;

		public event Action<EnemyParent> onEnemyDeath;

		public Modifier(string name, string description)
		{
			this.name = name;
			this.description = description;
			options = new ModifierOptions();
			if (!isClone)
			{
				Instance = this;
			}
		}

		public virtual void Start()
		{
			timerSelf = GetTime();
			if (ChaosMod.IsDebug)
			{
				ChaosMod.Logger.LogInfo((object)("새 이벤트: " + name));
			}
			if (options.oncePerLevel && !Modifiers.Excludes.Contains(this))
			{
				Modifiers.Excludes.Add(this);
			}
		}

		public virtual float GetTime()
		{
			if (isOnce)
			{
				return 0f;
			}
			return Random.Range(minTimer, maxTimer);
		}

		public virtual string GetName()
		{
			return Language.GetText(name);
		}

		public virtual string GetDesc()
		{
			return Language.GetText(description);
		}

		public virtual void Update()
		{
		}

		public virtual void OnFinished()
		{
			finihshed = true;
		}

		public virtual Modifier Clone()
		{
			Modifier modifier = new Modifier(name, description);
			modifier.maxTimer = maxTimer;
			modifier.minTimer = minTimer;
			modifier.timerSelf = timerSelf;
			modifier.ID = ID;
			modifier.options = new ModifierOptions(options.chance, options.oncePerLevel, options.multiplayerOnly, options.singleplayerOnly);
			modifier.isClone = true;
			modifier.Instance = this;
			return modifier;
		}
	}
	public class ModVars
	{
		public static bool brokeAllDoor_didRun;

		public static void Reset()
		{
			brokeAllDoor_didRun = false;
		}
	}
	internal class OptionSetting : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		internal OptionsMenuController controller;

		internal TextMeshProUGUI categoryTxt;

		internal RectTransform Arrow;

		internal Transform child;

		internal int objectCount;

		internal float heightOffset;

		internal bool isClosed;

		private float targetAngle;

		private void Start()
		{
			Close();
		}

		public void Open()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_004d: 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_007d: Expected O, but got Unknown
			//IL_007f: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00af: 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)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			targetAngle = 0f;
			isClosed = false;
			((Component)child).gameObject.SetActive(true);
			float num = 0f;
			Transform val = child.GetChild(1);
			for (int i = 0; i < val.childCount; i++)
			{
				RectTransform val2 = (RectTransform)val.GetChild(i);
				num += val2.sizeDelta.y;
				num += 10f;
			}
			RectTransform val3 = (RectTransform)child;
			val3.sizeDelta = new Vector2(val3.sizeDelta.x, 35f + num + heightOffset);
			RectTransform val4 = (RectTransform)((Component)this).transform;
			val4.sizeDelta = new Vector2(val4.sizeDelta.x, 50f + val3.sizeDelta.y - 25f);
			UpdateLayout();
		}

		private void UpdateLayout()
		{
			((Behaviour)controller.layout).enabled = false;
			((Behaviour)controller.layout).enabled = true;
		}

		private void Update()
		{
			//IL_0006: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			((Transform)Arrow).localEulerAngles = Vector3.forward * Mathf.Lerp(targetAngle, ((Transform)Arrow).localEulerAngles.z, Mathf.Exp(MathF.PI * -5f * Time.deltaTime));
		}

		public void OnPointerClick(PointerEventData data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			RaycastResult pointerPressRaycast = data.pointerPressRaycast;
			if (!(((Object)((RaycastResult)(ref pointerPressRaycast)).gameObject).name != "BG"))
			{
				if (isClosed)
				{
					Open();
				}
				else
				{
					Close();
				}
			}
		}

		public void Close()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			targetAngle = 90f;
			isClosed = true;
			((Component)child).gameObject.SetActive(false);
			RectTransform val = (RectTransform)((Component)this).transform;
			val.sizeDelta = new Vector2(val.sizeDelta.x, 50f);
			UpdateLayout();
		}
	}
	internal class OptionsMenuController : MonoBehaviour
	{
		public enum OptionType
		{
			Checkbox,
			Range,
			Value,
			Color,
			Description
		}

		public class OptionItem
		{
			public string name;

			public OptionType type;

			public float minValue;

			public float maxValue;

			public string rangeType;

			public OptionItem(string name, OptionType type, float minValue = 0f, float maxValue = 1f, string rangeType = "%")
			{
				this.name = name;
				this.type = type;
				this.minValue = minValue;
				this.maxValue = maxValue;
				this.rangeType = rangeType;
			}
		}

		private Image Cover;

		private Image menu_bg;

		private GameObject menu;

		private GameObject item_template;

		private GameObject boolean_template;

		private GameObject range_template;

		private GameObject float_template;

		private GameObject color_template;

		private GameObject description_template;

		private Dictionary<string, GameObject[]> option_data = new Dictionary<string, GameObject[]>();

		private GameObject option_title;

		internal VerticalLayoutGroup layout;

		internal UnityEvent<OptionType, string, object> onValueChanged = new UnityEvent<OptionType, string, object>();

		internal bool isShown;

		internal Dictionary<string, object> datas = new Dictionary<string, object>();

		private bool _notify;

		private void Start()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)((Component)this).transform.GetChild(0);
			val.sizeDelta = new Vector2((float)Screen.width, (float)Screen.height);
			Cover = ((Component)val).GetComponent<Image>();
			((Graphic)Cover).CrossFadeAlpha(0f, 0f, true);
			menu_bg = ((Component)((Component)this).transform.GetChild(1)).GetComponent<Image>();
			menu = ((Component)((Component)this).transform.GetChild(2)).gameObject;
			item_template = ((Component)menu.transform.GetChild(0).GetChild(0).GetChild(5)).gameObject;
			boolean_template = ((Component)item_template.transform.parent.GetChild(0)).gameObject;
			range_template = ((Component)item_template.transform.parent.GetChild(1)).gameObject;
			float_template = ((Component)item_template.transform.parent.GetChild(2)).gameObject;
			color_template = ((Component)item_template.transform.parent.GetChild(3)).gameObject;
			description_template = ((Component)item_template.transform.parent.GetChild(4)).gameObject;
			layout = ((Component)item_template.transform.parent).GetComponent<VerticalLayoutGroup>();
			item_template.SetActive(false);
			boolean_template.SetActive(false);
			range_template.SetActive(false);
			float_template.SetActive(false);
			color_template.SetActive(false);
			description_template.SetActive(false);
			option_title = ((Component)((Component)this).transform.Find("Text (TMP)")).gameObject;
			option_title.AddComponent<TextWaver>();
			Hide();
		}

		public void AddOption(string optionName, List<OptionItem> options)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(item_template, item_template.transform.parent);
			((Object)val).name = "Option - " + optionName;
			val.SetActive(true);
			OptionSetting optionSetting = val.AddComponent<OptionSetting>();
			optionSetting.categoryTxt = ((Component)val.transform.GetChild(2)).GetComponent<TextMeshProUGUI>();
			((TMP_Text)optionSetting.categoryTxt).text = optionName;
			optionSetting.objectCount = options.Count;
			optionSetting.child = val.transform.GetChild(0);
			optionSetting.Arrow = (RectTransform)val.transform.GetChild(3);
			optionSetting.controller = this;
			Transform child = optionSetting.child.GetChild(1);
			foreach (OptionItem option in options)
			{
				switch (option.type)
				{
				case OptionType.Checkbox:
				{
					GameObject val6 = Object.Instantiate<GameObject>(boolean_template, child);
					((TMP_Text)((Component)val6.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = option.name;
					val6.SetActive(true);
					((UnityEvent<bool>)(object)((Component)val6.transform.GetChild(1)).GetComponent<Toggle>().onValueChanged).AddListener((UnityAction<bool>)delegate(bool enabled)
					{
						if (_notify)
						{
							onValueChanged.Invoke(OptionType.Checkbox, optionName + ":" + option.name, (object)enabled);
						}
					});
					option_data.Add(optionName + ":" + option.name, (GameObject[])(object)new GameObject[1] { ((Component)val6.transform.GetChild(1)).gameObject });
					datas.Add(optionName + ":" + option.name, false);
					break;
				}
				case OptionType.Range:
				{
					GameObject val5 = Object.Instantiate<GameObject>(range_template, child);
					((TMP_Text)((Component)val5.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = option.name;
					val5.SetActive(true);
					TMP_InputField minInput = ((Component)val5.transform.GetChild(1)).GetComponent<TMP_InputField>();
					TMP_InputField maxInput = ((Component)val5.transform.GetChild(2)).GetComponent<TMP_InputField>();
					((UnityEvent<string>)(object)minInput.onEndEdit).AddListener((UnityAction<string>)delegate(string txt)
					{
						float num3 = float.Parse(txt);
						float num4 = float.Parse(maxInput.text);
						num3 = Mathf.Min(num3, num4);
						num3 = Mathf.Clamp(num3, option.minValue, option.maxValue);
						minInput.SetTextWithoutNotify(num3.ToString());
						if (_notify)
						{
							onValueChanged.Invoke(OptionType.Range, optionName + ":" + option.name, (object)new float[2] { num3, num4 });
						}
					});
					((UnityEvent<string>)(object)maxInput.onEndEdit).AddListener((UnityAction<string>)delegate(string txt)
					{
						float num = float.Parse(txt);
						float num2 = float.Parse(minInput.text);
						num = Mathf.Max(num, num2);
						num = Mathf.Clamp(num, option.minValue, option.maxValue);
						maxInput.SetTextWithoutNotify(num.ToString());
						if (_notify)
						{
							onValueChanged.Invoke(OptionType.Range, optionName + ":" + option.name, (object)new float[2] { num2, num });
						}
					});
					option_data.Add(optionName + ":" + option.name, (GameObject[])(object)new GameObject[2]
					{
						((Component)val5.transform.GetChild(1)).gameObject,
						((Component)val5.transform.GetChild(2)).gameObject
					});
					datas.Add(optionName + ":" + option.name, new float[2] { 0f, 1f });
					break;
				}
				case OptionType.Value:
				{
					GameObject val4 = Object.Instantiate<GameObject>(float_template, child);
					((TMP_Text)((Component)val4.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = option.name;
					val4.SetActive(true);
					TMP_InputField input = ((Component)val4.transform.GetChild(1)).GetComponent<TMP_InputField>();
					((UnityEvent<string>)(object)input.onEndEdit).AddListener((UnityAction<string>)delegate(string txt)
					{
						float num5 = float.Parse(txt);
						num5 = Mathf.Clamp(num5, option.minValue, option.maxValue);
						input.SetTextWithoutNotify(num5.ToString());
						if (_notify)
						{
							onValueChanged.Invoke(OptionType.Value, optionName + ":" + option.name, (object)num5);
						}
					});
					option_data.Add(optionName + ":" + option.name, (GameObject[])(object)new GameObject[1] { ((Component)val4.transform.GetChild(1)).gameObject });
					datas.Add(optionName + ":" + option.name, 0f);
					break;
				}
				case OptionType.Color:
				{
					optionSetting.objectCount++;
					GameObject val3 = Object.Instantiate<GameObject>(color_template, child);
					val3.SetActive(true);
					Image preview = ((Component)val3.transform.GetChild(5)).GetComponent<Image>();
					((UnityEvent<float>)(object)((Component)val3.transform.GetChild(1)).GetComponent<Slider>().onValueChanged).AddListener((UnityAction<float>)delegate(float value)
					{
						//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_001a: 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)
						Color color3 = ((Graphic)preview).color;
						color3.r = value;
						((Graphic)preview).color = color3;
						if (_notify)
						{
							onValueChanged.Invoke(OptionType.Color, optionName + ":" + option.name, (object)((Graphic)preview).color);
						}
					});
					((UnityEvent<float>)(object)((Component)val3.transform.GetChild(2)).GetComponent<Slider>().onValueChanged).AddListener((UnityAction<float>)delegate(float value)
					{
						//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_001a: 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)
						Color color2 = ((Graphic)preview).color;
						color2.g = value;
						((Graphic)preview).color = color2;
						if (_notify)
						{
							onValueChanged.Invoke(OptionType.Color, optionName + ":" + option.name, (object)((Graphic)preview).color);
						}
					});
					((UnityEvent<float>)(object)((Component)val3.transform.GetChild(3)).GetComponent<Slider>().onValueChanged).AddListener((UnityAction<float>)delegate(float value)
					{
						//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_001a: 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)
						Color color = ((Graphic)preview).color;
						color.b = value;
						((Graphic)preview).color = color;
						if (_notify)
						{
							onValueChanged.Invoke(OptionType.Color, optionName + ":" + option.name, (object)((Graphic)preview).color);
						}
					});
					((TMP_Text)((Component)val3.transform.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = option.name;
					option_data.Add(optionName + ":" + option.name, (GameObject[])(object)new GameObject[4]
					{
						((Component)val3.transform.GetChild(1)).gameObject,
						((Component)val3.transform.GetChild(2)).gameObject,
						((Component)val3.transform.GetChild(3)).gameObject,
						((Component)val3.transform.GetChild(4)).gameObject
					});
					datas.Add(optionName + ":" + option.name, Color.black);
					break;
				}
				case OptionType.Description:
				{
					GameObject val2 = Object.Instantiate<GameObject>(description_template, child);
					val2.SetActive(true);
					TextMeshProUGUI component = val2.GetComponent<TextMeshProUGUI>();
					((TMP_Text)component).text = option.name;
					((TMP_Text)component).fontSize = 15f;
					float x = ((TMP_Text)component).rectTransform.sizeDelta.x;
					((TMP_Text)component).rectTransform.sizeDelta = new Vector2(x, ((TMP_Text)component).GetPreferredValues(((TMP_Text)component).text, x, float.PositiveInfinity).y);
					option_data.Add(optionName + ":" + option.name, (GameObject[])(object)new GameObject[1] { val2 });
					datas.Add(optionName + ":" + option.name, false);
					break;
				}
				}
			}
			((Behaviour)layout).enabled = false;
			((Behaviour)layout).enabled = true;
		}

		public bool GetBool(string name)
		{
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return false;
			}
			Toggle val = default(Toggle);
			if (!value[0].TryGetComponent<Toggle>(ref val))
			{
				ChaosMod.Logger.LogError((object)(name + " has no Toggle Component."));
				return false;
			}
			return val.isOn;
		}

		public float[] GetRange(string name)
		{
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return null;
			}
			if (value.Length != 2)
			{
				ChaosMod.Logger.LogError((object)(name + " is not range type."));
				return null;
			}
			TMP_InputField component = value[0].GetComponent<TMP_InputField>();
			TMP_InputField component2 = value[1].GetComponent<TMP_InputField>();
			if (!float.TryParse(component.text, out var result))
			{
				ChaosMod.Logger.LogError((object)("Failed to parse min float. (got " + component.text + ")"));
				return null;
			}
			if (!float.TryParse(component2.text, out var result2))
			{
				ChaosMod.Logger.LogError((object)("Failed to parse max float. (got " + component2.text + ")"));
				return null;
			}
			return new float[2] { result, result2 };
		}

		public float GetValue(string name)
		{
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return float.NaN;
			}
			TMP_InputField val = default(TMP_InputField);
			if (!value[0].TryGetComponent<TMP_InputField>(ref val))
			{
				ChaosMod.Logger.LogError((object)(name + " has no Input Field (TMP)"));
				return float.NaN;
			}
			if (!float.TryParse(val.text, out var result))
			{
				ChaosMod.Logger.LogError((object)"Failed to parse string to float.");
				return float.NaN;
			}
			return result;
		}

		public Color GetColor(string name)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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)
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return Color.magenta;
			}
			if (value.Length != 4)
			{
				ChaosMod.Logger.LogError((object)(name + " is not Color option."));
				return Color.magenta;
			}
			return new Color(value[0].GetComponent<Slider>().value, value[1].GetComponent<Slider>().value, value[2].GetComponent<Slider>().value);
		}

		public string GetText(string name)
		{
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return "Did not found option name with \"" + name + "\"";
			}
			return ((TMP_Text)value[0].GetComponent<TextMeshProUGUI>()).text;
		}

		public bool SetValue(string name, float[] range, bool notify = true)
		{
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return false;
			}
			_notify = notify;
			if (value.Length == 2)
			{
				TMP_InputField component = value[0].GetComponent<TMP_InputField>();
				TMP_InputField component2 = value[1].GetComponent<TMP_InputField>();
				component.text = range[0].ToString();
				component2.text = range[1].ToString();
				((UnityEvent<string>)(object)component.onEndEdit).Invoke(component.text);
				((UnityEvent<string>)(object)component2.onEndEdit).Invoke(component2.text);
				_notify = true;
				datas[name] = range;
				return true;
			}
			_notify = true;
			return false;
		}

		public bool SetValue(string name, float value, bool notify = true)
		{
			if (!option_data.TryGetValue(name, out var value2))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return false;
			}
			_notify = notify;
			TMP_InputField component = value2[0].GetComponent<TMP_InputField>();
			component.text = value.ToString();
			((UnityEvent<string>)(object)component.onEndEdit).Invoke(component.text);
			_notify = true;
			datas[name] = value;
			return true;
		}

		public bool SetValue(string name, bool enabled, bool notify = true)
		{
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return false;
			}
			_notify = notify;
			value[0].GetComponent<Toggle>().isOn = enabled;
			_notify = true;
			datas[name] = enabled;
			return true;
		}

		public bool SetValue(string name, Color color, bool notify = true)
		{
			//IL_003b: 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_0061: 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)
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return false;
			}
			_notify = notify;
			value[0].GetComponent<Slider>().value = color.r;
			value[1].GetComponent<Slider>().value = color.g;
			value[2].GetComponent<Slider>().value = color.b;
			_notify = true;
			datas[name] = color;
			return true;
		}

		public bool SetText(string name, string text, bool notify = true)
		{
			//IL_0088: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			if (!option_data.TryGetValue(name, out var value))
			{
				ChaosMod.Logger.LogError((object)("Did not found option name with \"" + name + "\""));
				return false;
			}
			OptionSetting component = ((Component)value[0].transform.parent.parent.parent).GetComponent<OptionSetting>();
			_notify = notify;
			TextMeshProUGUI component2 = value[0].GetComponent<TextMeshProUGUI>();
			component.objectCount -= ((TMP_Text)component2).textInfo.lineCount - 1;
			((TMP_Text)component2).text = text;
			((TMP_Text)component2).ForceMeshUpdate(false, false);
			float x = ((TMP_Text)component2).rectTransform.sizeDelta.x;
			((TMP_Text)component2).rectTransform.sizeDelta = new Vector2(x, ((TMP_Text)component2).GetPreferredValues(text, x, float.PositiveInfinity).y);
			component.objectCount += ((TMP_Text)component2).textInfo.lineCount - 1;
			_notify = true;
			datas[name] = text;
			return true;
		}

		public void AddCategory(string text)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Category Text - " + text, new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(item_template.transform.parent, false);
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = 25f;
			((TMP_Text)component).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)component).rectTransform.sizeDelta = new Vector2(760f, 25f);
			((TMP_Text)component).font = ChaosMod.Instance.pretendard;
		}

		public void Hide()
		{
			((Graphic)Cover).CrossFadeAlpha(0f, 1f, true);
			((Graphic)option_title.GetComponent<TMP_Text>()).CrossFadeAlpha(0f, 1f, true);
			((Component)menu_bg).gameObject.SetActive(false);
			menu.SetActive(false);
			isShown = false;
		}

		public void Show()
		{
			((Graphic)Cover).CrossFadeAlpha(1f, 1f, true);
			((Graphic)option_title.GetComponent<TMP_Text>()).CrossFadeAlpha(1f, 1f, true);
			((Component)menu_bg).gameObject.SetActive(true);
			menu.SetActive(true);
			isShown = true;
		}
	}
	internal class PluginInfo
	{
		public const string GUID = "Lego0_77.ChaosMod";

		public const string Name = "ChaosMod";

		public const string Version = "1.4";
	}
	[Serializable]
	[PostProcess(/*Could not decode attribute arguments.*/)]
	public sealed class RainbowEffect : PostProcessEffectSettings
	{
		[Range(0f, 1f)]
		[Tooltip("Rainbow intensity")]
		public FloatParameter intensity;

		public RainbowEffect()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0016: Expected O, but got Unknown
			FloatParameter val = new FloatParameter();
			((ParameterOverride<float>)val).value = 0.25f;
			intensity = val;
			((PostProcessEffectSettings)this)..ctor();
		}
	}
	public sealed class RainbowRenderer : PostProcessEffectRenderer<RainbowEffect>
	{
		private static Shader _shader;

		public override void Init()
		{
			if ((Object)(object)_shader == (Object)null)
			{
				LoadShaderFromBundle();
			}
		}

		private void LoadShaderFromBundle()
		{
			_shader = ChaosMod.Instance.assets.LoadAsset<Shader>("Hidden/PostProcessing/Rainbow");
			if ((Object)(object)_shader == (Object)null)
			{
				Debug.LogError((object)"Shader not found in AssetBundle!");
			}
		}

		public override void Render(PostProcessRenderContext context)
		{
			//IL_0050: 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)
			if ((Object)(object)_shader == (Object)null)
			{
				Debug.LogWarning((object)"Rainbow shader not loaded.");
				return;
			}
			PropertySheet val = context.propertySheets.Get(_shader);
			val.properties.SetFloat("_Intensity", ((ParameterOverride<float>)(object)base.settings.intensity).value);
			RuntimeUtilities.BlitFullscreenTriangle(context.command, context.source, context.destination, val, 0, false, (Rect?)null, false);
		}
	}
	public class Shop_DiscountEvent : Modifier
	{
		public List<int> ogValues = new List<int>();

		public List<ItemAttributes> items = new List<ItemAttributes>();

		public Shop_DiscountEvent()
			: base("세일", "파격 세일 중!")
		{
			minTimer = 30f;
			maxTimer = 60f;
			isOnce = true;
		}

		public override void Start()
		{
			base.Start();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			Shop_DiscountEvent shop_DiscountEvent = (Shop_DiscountEvent)base.Instance;
			ItemAttributes[] array = Object.FindObjectsByType<ItemAttributes>((FindObjectsSortMode)0);
			foreach (ItemAttributes val in array)
			{
				int internalVar = Util.GetInternalVar<int>(val, "value");
				shop_DiscountEvent.ogValues.Add(internalVar);
				val.GetValueRPC(Mathf.FloorToInt((float)internalVar * 0.75f));
				if (GameManager.Multiplayer())
				{
					((Component)val).GetComponent<PhotonView>().RPC("GetValueRPC", (RpcTarget)1, new object[1] { Mathf.FloorToInt((float)internalVar * 0.75f) });
				}
				shop_DiscountEvent.items.Add(val);
			}
			if (!Modifiers.Excludes.Contains(base.Instance))
			{
				Modifiers.Excludes.Add(base.Instance);
			}
		}

		public override void OnFinished()
		{
			base.OnFinished();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			int num = 0;
			Shop_DiscountEvent shop_DiscountEvent = (Shop_DiscountEvent)base.Instance;
			foreach (ItemAttributes item in shop_DiscountEvent.items)
			{
				if ((Object)(object)item == (Object)null)
				{
					num++;
					continue;
				}
				item.GetValueRPC(shop_DiscountEvent.ogValues[num]);
				if (GameManager.Multiplayer())
				{
					((Component)item).GetComponent<PhotonView>().RPC("GetValueRPC", (RpcTarget)1, new object[1] { shop_DiscountEvent.ogValues[num] });
				}
				num++;
			}
		}

		public override Modifier Clone()
		{
			return new Shop_DiscountEvent
			{
				Instance = this,
				isClone = true
			};
		}
	}
	public class TextLerp : TextMeshProUGUI
	{
		public Vector2 targetPosition = Vector2.zero;

		public Vector2 posOffset = Vector2.zero;

		private Vector2 lerpedPosition = Vector2.zero;

		private void Start()
		{
			UpdateLerpPos();
		}

		public void UpdateLerpPos()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			lerpedPosition = ((TMP_Text)this).rectTransform.anchoredPosition;
		}

		private void Update()
		{
			//IL_0002: 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_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_0035: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			lerpedPosition = Vector2.Lerp(lerpedPosition, targetPosition, 1f - Mathf.Exp((0f - Time.unscaledDeltaTime) * MathF.PI));
			((TMP_Text)this).rectTransform.anchoredPosition = lerpedPosition + posOffset;
		}
	}
	internal class TextWaver : MonoBehaviour
	{
		internal float radius = 10f;

		private TMP_Text tmpText;

		private void Start()
		{
			if (!((Component)this).TryGetComponent<TMP_Text>(ref tmpText))
			{
				ChaosMod.Logger.LogWarning((object)("Did not found TMP_Text on " + ((Object)this).name + "."));
				Object.Destroy((Object)(object)this);
			}
		}

		private void LateUpdate()
		{
			//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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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)
			tmpText.ForceMeshUpdate(false, false);
			TMP_TextInfo textInfo = tmpText.textInfo;
			TMP_MeshInfo[] meshInfo = textInfo.meshInfo;
			Vector3 val2 = default(Vector3);
			for (int i = 0; i < textInfo.characterCount; i++)
			{
				TMP_CharacterInfo val = textInfo.characterInfo[i];
				if (val.isVisible)
				{
					int materialReferenceIndex = val.materialReferenceIndex;
					int vertexIndex = val.vertexIndex;
					float num = (float)i / (float)textInfo.characterCount;
					num *= 5f;
					((Vector3)(ref val2))..ctor(0f, Mathf.Sin(Time.time * MathF.PI + num) * radius, 0f);
					Vector3[] vertices = tmpText.textInfo.meshInfo[materialReferenceIndex].vertices;
					Vector3[] vertices2 = meshInfo[materialReferenceIndex].vertices;
					Vector3 val3 = (vertices[vertexIndex] + vertices[vertexIndex + 2]) / 2f;
					float num2 = Mathf.Cos(Time.time * MathF.PI + num) * radius;
					Quaternion val4 = Quaternion.Euler(0f, 0f, num2);
					Color32[] colors = meshInfo[materialReferenceIndex].colors32;
					Color32 val5 = Color32.op_Implicit(Color.HSVToRGB(Mathf.Repeat(Time.time / 5f + num / 5f, 1f), 0.75f, 1f));
					for (int j = 0; j < 4; j++)
					{
						Vector3 val6 = vertices[vertexIndex + j];
						val6 -= val3;
						val6 = val4 * val6;
						val6 += val3;
						val6 += val2;
						vertices2[vertexIndex + j] = val6;
						colors[vertexIndex + j] = val5;
					}
				}
			}
			for (int k = 0; k < meshInfo.Length; k++)
			{
				meshInfo[k].mesh.vertices = meshInfo[k].vertices;
				meshInfo[k].mesh.colors32 = meshInfo[k].colors32;
				tmpText.UpdateGeometry(meshInfo[k].mesh, k);
			}
		}
	}
	internal class Util
	{
		public static FieldInfo GetInternalVar(object target, string varName)
		{
			Type type = target.GetType();
			return type.GetField(varName, BindingFlags.Instance | BindingFlags.NonPublic);
		}

		public static T GetInternalVar<T>(object target, string varName)
		{
			return (T)GetInternalVar(target, varName).GetValue(target);
		}

		public static string GetPluginDirectory(string file = "")
		{
			string location = typeof(ChaosMod).Assembly.Location;
			string directoryName = Path.GetDirectoryName(location);
			return Path.Combine(directoryName, file);
		}

		public static void RectTransformFullscreen(RectTransform rt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}

		public static float BeatMath(float beat, float bpm, float y = 0f)
		{
			float num = 0.2f;
			float num2 = 0.5f;
			float num3 = Mathf.Max(1f, (float)Math.Truncate(bpm / 150f));
			num /= num3;
			num2 /= num3;
			float num4 = beat + num;
			num4 /= num3;
			bool flag = Math.Truncate(num4) % 2.0 != 0.0;
			if (num4 < 0f)
			{
				return 0f;
			}
			num4 -= (float)Math.Truncate(num4);
			num4 += 1f;
			num4 -= (float)Math.Truncate(num4);
			if (num4 >= num2)
			{
				return 0f;
			}
			float num5 = 0f;
			if (num4 < num)
			{
				num5 = SCALE(num4, 0f, num, 0f, 1f);
				num5 *= num5;
			}
			else
			{
				num5 = SCALE(num4, num, num2, 1f, 0f);
				num5 = 1f - (1f - num5) * (1f - num5);
			}
			if (flag)
			{
				num5 *= -1f;
			}
			return 20f * num5 * Mathf.Sin(y / 15f + MathF.PI / 2f);
			static float SCALE(float x, float l1, float h1, float l2, float h2)
			{
				return (x - l1) * (h2 - l2) / (h1 - l1) + l2;
			}
		}
	}
}