using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using EventsIO.Interfaces;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("EventIO")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("BFT")]
[assembly: AssemblyProduct("EventIO")]
[assembly: AssemblyCopyright("Copyright ©  2020")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("ab7abff2-5203-43d0-88ed-aebd4b6a130c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace EventsIO
{
	public class EventsData : IEventsData
	{
		public string Username { get; set; }

		public string Cost { get; set; }

		public string EventID { get; set; }

		public string Lang { get; set; }

		public string ExtraInfo { get; set; }

		public override string ToString()
		{
			return "EventsData: " + Username + " " + Cost + " " + EventID + " " + Lang + " " + ExtraInfo;
		}
	}
	public class EventsDataEncoder : IEventsDataEncoder, IEventsDataEncoderParams
	{
		internal static readonly string clientAppSep = "&";

		internal static readonly char clientAppSepChar = '&';

		internal static readonly string clientAppEqual = "=";

		internal static readonly char clientAppEqualChar = '=';

		protected static readonly Dictionary<string, string> symbolCodes = new Dictionary<string, string>
		{
			{ clientAppSep, "%encode_amp%" },
			{ clientAppEqual, "%encode_equal%" }
		};

		string IEventsDataEncoderParams.ClientAppSep => clientAppSep;

		char IEventsDataEncoderParams.ClientAppSepChar => clientAppSepChar;

		string IEventsDataEncoderParams.ClientAppEqual => clientAppEqual;

		char IEventsDataEncoderParams.ClientAppEqualChar => clientAppEqualChar;

		public virtual string Encode(string s)
		{
			foreach (KeyValuePair<string, string> symbolCode in symbolCodes)
			{
				s = s?.Replace(symbolCode.Key, symbolCode.Value);
			}
			return s;
		}

		public virtual string Decode(string s)
		{
			foreach (KeyValuePair<string, string> symbolCode in symbolCodes)
			{
				s = s?.Replace(symbolCode.Value, symbolCode.Key);
			}
			return s;
		}
	}
	public class EventsDataParser : IEventsDataParser
	{
		protected readonly Action<string> log;

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

		public bool isLogInfoError = true;

		public bool isLogSkipEmpty;

		public EventsDataParser(Action<string> log = null)
		{
			this.log = log;
			encoderParams = (IEventsDataEncoderParams)(encoder = new EventsDataEncoder());
		}

		protected virtual void ParserLog(string s)
		{
			log?.Invoke(s);
		}

		public virtual IEventsData ParseEvent(string data)
		{
			EventsData eventsData = new EventsData();
			string[] array = data.Split(new char[1] { encoderParams.ClientAppSepChar }, StringSplitOptions.RemoveEmptyEntries);
			if (array == null)
			{
				if (isLogInfoError)
				{
					ParserLog("get event info error. Wrong args.");
				}
				return eventsData;
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				string[] array3 = text.Split(new char[1] { encoderParams.ClientAppEqualChar }, StringSplitOptions.RemoveEmptyEntries);
				if (array3.Length != 2)
				{
					if (isLogSkipEmpty)
					{
						ParserLog("skip empty item: " + text);
					}
					continue;
				}
				string text2 = encoder.Decode(array3[0]);
				string text3 = encoder.Decode(array3[1]);
				switch (text2.ToLowerInvariant())
				{
				case "username":
					eventsData.Username = text3;
					break;
				case "eventid":
					eventsData.EventID = text3;
					break;
				case "cost":
					eventsData.Cost = text3;
					break;
				case "lang":
					eventsData.Lang = text3;
					break;
				case "extrainfo":
					eventsData.ExtraInfo = text3;
					break;
				}
			}
			return eventsData;
		}
	}
	public class EventsGenerator : IEventsGenerator
	{
		protected internal enum FieldNames
		{
			UserName,
			EventID,
			Cost,
			Lang,
			ExtraInfo
		}

		protected EventsData data;

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

		public EventsGenerator()
		{
			data = new EventsData();
			encoderParams = (IEventsDataEncoderParams)(encoder = new EventsDataEncoder());
		}

		public virtual void SetCost(string s)
		{
			data.Cost = encoder.Encode(s);
		}

		public virtual void SetEventID(string s)
		{
			data.EventID = encoder.Encode(s);
		}

		public virtual void SetLang(string s)
		{
			data.Lang = encoder.Encode(s);
		}

		public virtual void SetUsername(string s)
		{
			data.Username = encoder.Encode(s);
		}

		public virtual void SetExtraInfo(string s)
		{
			data.ExtraInfo = encoder.Encode(s);
		}

		public virtual string Generate()
		{
			Dictionary<FieldNames, string> obj = new Dictionary<FieldNames, string>
			{
				{
					FieldNames.UserName,
					data.Username
				},
				{
					FieldNames.Cost,
					data.Cost
				},
				{
					FieldNames.EventID,
					data.EventID
				},
				{
					FieldNames.Lang,
					data.Lang
				},
				{
					FieldNames.ExtraInfo,
					data.ExtraInfo
				}
			};
			StringBuilder stringBuilder = new StringBuilder(obj.Count);
			string clientAppSep = encoderParams.ClientAppSep;
			string clientAppEqual = encoderParams.ClientAppEqual;
			bool flag = true;
			foreach (KeyValuePair<FieldNames, string> item in obj)
			{
				if (flag)
				{
					stringBuilder.Append($"{item.Key}{clientAppEqual}{item.Value}");
					flag = false;
					continue;
				}
				stringBuilder.Append($"{clientAppSep}{item.Key}{clientAppEqual}{item.Value}");
			}
			data = new EventsData();
			return stringBuilder.ToString();
		}
	}
	public class EventsReaderOnKey : EventsReader, IEventsReaderOnKey, IEventsReader
	{
		protected readonly Action<IEventsData> processEvent;

		protected readonly IEventsDataParser parser;

		public EventsReaderOnKey(Action<IEventsData> processEvent, IEventsDataParser parser, Action<string> log = null, Action<string> logError = null)
			: base(log, logError)
		{
			this.processEvent = processEvent;
			this.parser = parser;
		}

		protected virtual void ProcessOnKey(string[] events)
		{
			if (events == null || events.Length == 0)
			{
				return;
			}
			foreach (IEventsData item in events.Select((string item) => parser?.ParseEvent(item)))
			{
				try
				{
					ReaderLog($"StartProcessOnKey {item}");
					processEvent?.Invoke(item);
				}
				catch (Exception arg)
				{
					ReaderLogError($"StartProcessOnKey error: {arg}");
				}
			}
		}

		public virtual void ProcessAllOnKey(string[] events)
		{
			try
			{
				ProcessOnKey(events);
			}
			catch (Exception arg)
			{
				ReaderLogError($"ProcessAllOnKey error: {arg}");
			}
		}

		public virtual void ReadAndProcessAllOnKey(string path, bool isClearFile = true)
		{
			ProcessAllOnKey(ReadAll(path, isClearFile));
		}
	}
	public class EventsReaderOnFrame : EventsReader, IEventsReaderOnFrame, IEventsReader
	{
		protected bool isFirstRun = true;

		protected readonly float delay;

		protected float delayCounter;

		protected float initDelay;

		protected float initCounter;

		protected readonly float checkPeriod;

		protected float periodCounter;

		protected readonly Action<IEventsData> processEvent;

		protected readonly IEventsDataParser parser;

		protected IEnumerator<IEventsData> eventsData;

		protected readonly string path;

		private bool isDelayEveryProcessing;

		public bool IsDelayEveryProcessing
		{
			get
			{
				return isDelayEveryProcessing;
			}
			set
			{
				isDelayEveryProcessing = value;
			}
		}

		protected virtual void StartProcessOnFrame()
		{
			while (eventsData.MoveNext())
			{
				try
				{
					ReaderLog($"StartProcessOnFrame {eventsData.Current}");
					processEvent?.Invoke(eventsData.Current);
				}
				catch (Exception arg)
				{
					ReaderLogError($"StartProcessOnFrame error: {arg}");
				}
			}
			eventsData = null;
		}

		protected virtual void StartProcessWithDelayOnFrame()
		{
			if (eventsData.MoveNext())
			{
				try
				{
					ReaderLog($"StartProcessWithDelayOnFrame {eventsData.Current}");
					processEvent?.Invoke(eventsData.Current);
					return;
				}
				catch (Exception arg)
				{
					ReaderLogError($"StartProcessWithDelayOnFrame error: {arg}");
					return;
				}
			}
			isFirstRun = false;
			eventsData = null;
			ReaderLog("StartProcessWithDelayOnFrame end");
		}

		public EventsReaderOnFrame(string path, Action<IEventsData> processEvent, IEventsDataParser parser, Action<string> log = null, Action<string> errorLog = null, float checkPeriod = 2f, float delay = 1f, float initDelay = 0.5f)
			: base(log, errorLog)
		{
			this.processEvent = processEvent;
			this.parser = parser;
			this.delay = delay;
			this.initDelay = initDelay;
			this.path = path;
			this.checkPeriod = checkPeriod;
		}

		public virtual void SetEventsToProcess(string[] events)
		{
			try
			{
				if (events == null || events.Length == 0)
				{
					eventsData = null;
					return;
				}
				ReaderLog($"SetEventsToProcess read {events.Length} events");
				eventsData = events.Select((string item) => parser?.ParseEvent(item))?.GetEnumerator();
			}
			catch (Exception arg)
			{
				ReaderLogError($"SetEventsToProcess error: {arg}");
			}
		}

		public virtual bool IsProcessEnd()
		{
			return eventsData == null;
		}

		public virtual void ProcessAllWithDelayOnFrame(float dt)
		{
			if (IsProcessEnd())
			{
				return;
			}
			try
			{
				if (isDelayEveryProcessing || isFirstRun)
				{
					if (initDelay != 0f)
					{
						initCounter += dt;
						if (initCounter >= initDelay)
						{
							initCounter = 0f;
							initDelay = 0f;
							StartProcessWithDelayOnFrame();
						}
					}
					else
					{
						delayCounter += dt;
						if (delayCounter >= delay)
						{
							delayCounter = 0f;
							StartProcessWithDelayOnFrame();
						}
					}
				}
				else
				{
					StartProcessOnFrame();
				}
			}
			catch (Exception arg)
			{
				ReaderLogError($"ProcessAllWithDelay error: {arg}");
			}
		}

		public virtual void ReadAndProcessAllWithDelayOnFrame(float dt)
		{
			if (IsProcessEnd())
			{
				periodCounter += dt;
				if (periodCounter >= checkPeriod)
				{
					periodCounter = 0f;
					string[] eventsToProcess = ReadAll(path);
					SetEventsToProcess(eventsToProcess);
				}
			}
			ProcessAllWithDelayOnFrame(dt);
		}
	}
	public class EventsReader : IEventsReader
	{
		protected readonly Action<string> log;

		protected readonly Action<string> logError;

		public EventsReader(Action<string> log = null, Action<string> logError = null)
		{
			this.log = log;
			this.logError = logError;
		}

		protected virtual void ReaderLog(string s)
		{
			log?.Invoke(s);
		}

		protected virtual void ReaderLogError(string s)
		{
			logError?.Invoke(s);
		}

		public virtual string[] ReadAllUnsafe(string path, bool isClearFile = true)
		{
			using FileStream fileStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
			using StreamReader streamReader = new StreamReader(fileStream, Encoding.UTF8);
			char[] separator = new char[2] { '\r', '\n' };
			string[] array = streamReader.ReadToEnd().Split(separator, StringSplitOptions.RemoveEmptyEntries);
			if (isClearFile && array != null && array.Length >= 1)
			{
				fileStream.SetLength(0L);
			}
			return array;
		}

		public virtual string[] ReadAll(string path, bool isClearFile = true)
		{
			try
			{
				return ReadAllUnsafe(path, isClearFile);
			}
			catch (FileNotFoundException)
			{
			}
			catch (DirectoryNotFoundException)
			{
			}
			catch (Exception arg)
			{
				ReaderLogError($"read event error: {arg}");
			}
			return null;
		}
	}
}
namespace EventsIO.Interfaces
{
	public interface IEventsData
	{
		string Username { get; }

		string Cost { get; }

		string EventID { get; }

		string Lang { get; }

		string ExtraInfo { get; }
	}
	public interface IEventsDataEncoderParams
	{
		string ClientAppSep { get; }

		char ClientAppSepChar { get; }

		string ClientAppEqual { get; }

		char ClientAppEqualChar { get; }
	}
	public interface IEventsDataEncoder
	{
		string Encode(string s);

		string Decode(string s);
	}
	public interface IEventsDataParser
	{
		IEventsData ParseEvent(string s);
	}
	public interface IEventsGenerator
	{
		void SetUsername(string s);

		void SetEventID(string s);

		void SetCost(string s);

		void SetLang(string s);

		void SetExtraInfo(string s);

		string Generate();
	}
	public interface IEventsReaderOnKey : IEventsReader
	{
		void ProcessAllOnKey(string[] events);

		void ReadAndProcessAllOnKey(string path, bool isClearFile = true);
	}
	public interface IEventsReaderOnFrame : IEventsReader
	{
		void SetEventsToProcess(string[] events);

		bool IsProcessEnd();

		void ProcessAllWithDelayOnFrame(float dt);

		void ReadAndProcessAllWithDelayOnFrame(float dt);
	}
	public interface IEventsReader
	{
		string[] ReadAll(string path, bool isClearFile = true);
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using EventsIO;
using EventsIO.Interfaces;
using HarmonyLib;
using ModHelper;
using ModHelper.Interfaces;
using ModHelper.Wrappers;
using ModHelperUnity.Interfaces;
using ModHelperUnity.TypedNotify;
using ModHelperUnity.Utilities;
using Newtonsoft.Json;
using Peak.Afflictions;
using Photon.Pun;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.SceneManagement;
using WebSocketIO;
using Zorro.Core;
using Zorro.Core.CLI;
using Zorro.Settings;
using peak_bepinex.Commands.Base;
using peak_bepinex.Commands.Interfaces;
using peak_bepinex.Patchers;
using peak_bepinex.Services;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("peak_bepinex")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("BFT LLC")]
[assembly: AssemblyProduct("ChaosTricksMod")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("BFT")]
[assembly: ComVisible(false)]
[assembly: Guid("F3976D04-F3F2-42D1-A5AD-9FEA4196A17F")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.2.0.0")]
namespace peak_bepinex
{
	[BepInPlugin("bft.chaostricks", "Chaos Tricks", "1.2.0")]
	internal class BepInExPlugin : BaseUnityPlugin
	{
		public const string GUID = "bft.chaostricks";

		public const string NAME = "Chaos Tricks";

		private GameObject hookObj;

		private bool isPatched;

		public void Awake()
		{
			try
			{
				SettingsUtils.BaseFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				SceneManager.sceneLoaded += OnSceneLoaded;
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)string.Format("{0} v{1} error: {2}", "Chaos Tricks", "1.2.0", arg));
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			try
			{
				((HelperLog)Utils.logger).Log((object)("OnSceneLoaded triggered: " + ((Scene)(ref scene)).name));
				if (!isPatched)
				{
					((HelperLog)Utils.logger).LogInfo((object)"Background task: trying to create mod instance");
					hookObj = new GameObject();
					Object.DontDestroyOnLoad((Object)(object)hookObj);
					hookObj.AddComponent<InteractiveMod>();
					hookObj.SetActive(true);
					isPatched = true;
					SceneManager.sceneLoaded -= OnSceneLoaded;
				}
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)string.Format("{0} v{1} OnSceneLoaded error: {2}", "Chaos Tricks", "1.2.0", arg));
			}
		}
	}
	internal static class CustomNotifyOnGUI
	{
		private static bool showNotify;

		private static Texture2D rectTexture;

		private static string notifyText;

		private static string prefixText;

		internal static void ShowNotify(bool show)
		{
			showNotify = show;
		}

		internal static void SetNotifyText(string prefix, string text)
		{
			prefixText = prefix;
			notifyText = text;
		}

		internal static void OnGUI()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_0021: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (showNotify)
			{
				if ((Object)(object)rectTexture == (Object)null)
				{
					rectTexture = new Texture2D(1, 1);
					rectTexture.SetPixel(0, 0, new Color(0f, 0f, 0f, 0.7f));
					rectTexture.Apply();
				}
				float val = HelperUI.CalcScreenFactor(HelperUI.StandardScreenWidth, Screen.width);
				float val2 = HelperUI.CalcScreenFactor(HelperUI.StandardScreenHeight, Screen.height);
				float num = Math.Min(val, val2);
				float num2 = Math.Max(val, val2);
				int num3 = (int)(14f * num2);
				int num4 = (int)(7f * num2);
				int num5 = (int)(10f * num2);
				int fontSize = (int)(20f * num);
				GUIStyle val3 = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					padding = new RectOffset(num3, num3, num4, num5),
					fontSize = fontSize,
					wordWrap = false
				};
				val3.normal.background = rectTexture;
				string text = "<b><color=#c11fff>" + prefixText + "</color> " + notifyText + "</b>";
				GUIContent val4 = new GUIContent(text);
				Vector2 val5 = val3.CalcSize(val4);
				GUI.Label(new Rect((float)Screen.width - val5.x, 0f, val5.x, val5.y), text, val3);
			}
		}
	}
	public static class GameUtils
	{
		public static IEnumerable<Character> Players => Character.AllCharacters;

		public static IEnumerable<Character> AlivePlayers => Character.AllCharacters.Where((Character p) => (Object)(object)p.data != (Object)null && !p.data.dead);

		public static void RunGameConsoleCommand(string cmd)
		{
			((HelperLog)Utils.logger).LogInfo((object)("try to run in-game command: " + cmd));
			ConsoleHandler.ProcessCommand(cmd);
		}

		public static void ApplyForceToPlayer(Character ch, in Vector3 dir)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			List<Bodypart> partList = ch.refs.ragdoll.partList;
			if (partList == null || partList.Count == 0)
			{
				((HelperLog)Utils.logger).LogWarning((object)"ApplyForceToPlayer empty body parts");
				return;
			}
			foreach (Bodypart item in partList)
			{
				Traverse.Create((object)item).Field<Rigidbody>("rig").Value.AddForce(dir, (ForceMode)1);
			}
		}

		public static void ApplyForceToLocalPlayer(in Vector3 dir)
		{
			ApplyForceToPlayer(Character.localCharacter, in dir);
		}

		public static Vector3 GetLocalPlayerForwardOffset(float offsetForward = 1f, float offsetHeight = 0.5f)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_001a: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)Character.localCharacter).transform;
			Vector3 position = transform.position;
			Vector3 forward = transform.forward;
			return position + ((Vector3)(ref forward)).normalized * offsetForward + new Vector3(0f, offsetHeight, 0f);
		}

		public static ref Vector3 GetLocalPlayerForwardWay()
		{
			return ref Character.localCharacter.data.lookDirection_Flat;
		}

		public static ref Vector3 GetLocalPlayerRightWay()
		{
			return ref Character.localCharacter.data.lookDirection_Right;
		}

		public static ref Vector3 GetLocalPlayerUpWay()
		{
			return ref Character.localCharacter.data.lookDirection_Up;
		}

		public static Character GetCharacterByNetworkID(int id)
		{
			foreach (Character player in Players)
			{
				if (!((Object)(object)player == (Object)null) && !((Object)(object)((MonoBehaviourPun)player).photonView == (Object)null) && ((MonoBehaviourPun)player).photonView.ViewID == id)
				{
					return player;
				}
			}
			return null;
		}

		public static void TeleportPlayer(Character player, in Vector3 pos)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			StopClimbing(player);
			((MonoBehaviourPun)player).photonView.RPC("WarpPlayerRPC", (RpcTarget)0, new object[2] { pos, true });
		}

		public static void StopClimbing(Character player)
		{
			try
			{
				if ((Object)(object)player.data == (Object)null)
				{
					((HelperLog)Utils.logger).LogWarning((object)"CancelHandle player.data null");
					return;
				}
				if ((Object)(object)player.data.currentClimbHandle == (Object)null)
				{
					return;
				}
				if ((Object)(object)player.refs.climbing == (Object)null)
				{
					((HelperLog)Utils.logger).LogWarning((object)"CancelHandle climbing null");
					return;
				}
				player.refs.climbing.CancelHandle(false);
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"CancelHandle error: {arg}");
			}
			try
			{
				Traverse.Create((object)player.refs.climbing).Field<PhotonView>("view").Value.RPC("StopClimbingRpc", (RpcTarget)0, new object[1] { 0f });
			}
			catch (Exception arg2)
			{
				((HelperLog)Utils.logger).LogError((object)$"StopClimbingRpc error: {arg2}");
			}
			try
			{
				Traverse.Create((object)player.refs.vineClimbing).Field<PhotonView>("view").Value.RPC("StopVineClimbingRpc", (RpcTarget)0, Array.Empty<object>());
			}
			catch (Exception arg3)
			{
				((HelperLog)Utils.logger).LogError((object)$"StopVineClimbingRpc error: {arg3}");
			}
			try
			{
				Traverse.Create((object)player.refs.ropeHandling).Field<PhotonView>("view").Value.RPC("StopRopeClimbingRpc", (RpcTarget)0, Array.Empty<object>());
			}
			catch (Exception arg4)
			{
				((HelperLog)Utils.logger).LogError((object)$"StopRopeClimbingRpc error: {arg4}");
			}
		}

		public static STATUSTYPE NameToPlayerStatusType(string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<STATUSTYPE>(name, ignoreCase: true, out STATUSTYPE result))
			{
				return result;
			}
			((HelperLog)Utils.logger).LogError((object)("NameToStatusType got unknown status " + name + ", used default Crab."));
			return (STATUSTYPE)4;
		}

		public static Bodypart GetCharacterBodypart(BodypartType part)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return Character.localCharacter.refs.ragdoll.partDict[part];
		}
	}
	public sealed class InteractiveMod : MonoBehaviour
	{
		public static InteractiveMod inst;

		internal const string MOD_VERSION = "1.2.0";

		private readonly ServiceProvider serviceProvider = ServiceProvider.inst;

		private readonly BufferedLogger logger = Utils.logger;

		private ScheduleManager systemScheduleManager;

		private ScheduleManager scheduleManager;

		private EventEmitter eventEmitter;

		private WebSocketEventsReader<SettingsData> eventsReader;

		private IEventsDataParser eventsParser;

		private ICommandManager commandManager;

		private IComponentTypedNotify notifyManager;

		private CommandConsole console;

		private Dictionary<string, IInternalStandaloneCommand> commands;

		private TranslationService translationService;

		private LimitedLogWrapper limitedLogger;

		private LimitedLogWrapper limitedSceneLogger;

		private Language lastUsedLang = (Language)(-1);

		private bool readyToActivateEvents;

		private readonly List<IForceEnd> forceEndEvents = new List<IForceEnd>();

		public void Awake()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			inst = this;
			((HelperLog)logger).ClearLogBySize(200000, (Action<string>)Debug.LogError);
			limitedLogger = new LimitedLogWrapper(100, (IDebugLogger)(object)Utils.logger);
			limitedSceneLogger = new LimitedLogWrapper(50, (IDebugLogger)(object)Utils.logger);
			((HelperLog)logger).LogInfo((object)"InteractiveMod Awake");
			((HelperLog)logger).LogInfo((object)"mod version 1.2.0");
			FlushLog();
			MainPatcher.InitPatch();
		}

		public void Start()
		{
			((HelperLog)logger).LogInfo((object)"InteractiveMod Start");
			try
			{
				JsonUtils.RegisterCustomGenerator((Func<IJsonUtils>)(() => (IJsonUtils)(object)new JsonParser()));
				((HelperLog)logger).LogInfo((object)"init mod services");
				InitServices();
				((HelperLog)logger).LogInfo((object)"init mod readers");
				InitReaders();
				((HelperLog)logger).LogInfo((object)"init mod commands");
				InitCommands(needValidate: false);
				((HelperLog)logger).LogInfo((object)"mod initiation ends");
			}
			catch (Exception arg)
			{
				((HelperLog)logger).LogError((object)$"mod initiation error: {arg}");
			}
			FlushLog();
		}

		public void OnDestroy()
		{
			((HelperLog)logger).LogInfo((object)"InteractiveMod OnDestroy");
			FlushLog();
			SceneManager.sceneLoaded -= SceneLoaded;
		}

		private void FlushLog()
		{
			logger.Flush(true);
		}

		private void InitServices()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			eventEmitter = new EventEmitter();
			serviceProvider.RegisterEventEmitter(eventEmitter);
			systemScheduleManager = new ScheduleManager((ILogger)(object)logger, 0);
			serviceProvider.RegisterSystemScheduleManager(systemScheduleManager);
			systemScheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				periodicAction = FlushLog,
				finishAction = FlushLog,
				periodInSec = 5f
			}, false);
			scheduleManager = new ScheduleManager((ILogger)(object)logger, 0);
			serviceProvider.RegisterScheduleManager(scheduleManager);
			translationService = new TranslationService();
			translationService.LoadData();
			serviceProvider.RegisterTranslationService(translationService);
			if (notifyManager == null)
			{
				notifyManager = (IComponentTypedNotify)(object)((Component)this).gameObject.AddComponent<TypedNotifyOnGUI>();
			}
			notifyManager.ForcePostInit(Utils.modFolder, (IDebugLogger)(object)Utils.logger, (Func<string, byte[]>)null);
			SceneManager.sceneLoaded += SceneLoaded;
		}

		private void SceneLoaded(Scene scene, LoadSceneMode mode)
		{
			string name = ((Scene)(ref scene)).name;
			((HelperLog)Utils.logger).LogInfo((object)("scene loaded: " + name));
			bool flag = name == "Airport";
			readyToActivateEvents = !flag && name != "Title";
			CustomNotifyOnGUI.ShowNotify(flag);
		}

		private void InitReaders()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			console = new CommandConsole((IDebugLogger)(object)logger, (List<string>)null);
			eventsParser = (IEventsDataParser)new EventsDataParser((Action<string>)((HelperLog)logger).LogWarning);
			eventsReader = new WebSocketEventsReader<SettingsData>((Action<IEventsData>)ProcessEvent, eventsParser, (Action<string>)((HelperLog)logger).LogInfo, (Action<string>)((HelperLog)logger).LogInfo, 0.5f, 1f, 0.5f, true);
			eventsReader.InitDefaultSocket(Utils.modFolder, "chaostricks_peak", 13715, "127.0.0.1");
			Action<string> defaultOnConfig = eventsReader.SocketHandler.OnConfigMessage;
			eventsReader.SocketHandler.OnConfigMessage = delegate(string s)
			{
				defaultOnConfig?.Invoke(s);
				SettingsManager.QueueUpdateSettings(eventsReader.Settings);
			};
			eventsReader.OpenSocket(true);
		}

		public void InitCommands(bool needValidate)
		{
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			forceEndEvents.Clear();
			Type type = typeof(IInternalStandaloneCommand);
			IEnumerable<Type> enumerable = from p in Assembly.GetExecutingAssembly().GetTypes()
				where type.IsAssignableFrom(p) && p.IsClass && !p.IsAbstract
				select p;
			((HelperLog)logger).LogInfo((object)$"found {enumerable.Count()} commands");
			commands = new Dictionary<string, IInternalStandaloneCommand>();
			foreach (Type item2 in enumerable)
			{
				IInternalStandaloneCommand internalStandaloneCommand = Activator.CreateInstance(item2) as IInternalStandaloneCommand;
				if (internalStandaloneCommand != null)
				{
					console.RegisterCommand((IConsoleCommand)internalStandaloneCommand);
					if (commands.ContainsKey(((IConsoleCommand)internalStandaloneCommand).Id))
					{
						((HelperLog)logger).LogWarning((object)("repeated id command " + ((IConsoleCommand)internalStandaloneCommand).Id + ". The command will replace existed."));
					}
					commands[((IConsoleCommand)internalStandaloneCommand).Id] = internalStandaloneCommand;
					if (internalStandaloneCommand is IForceEnd item)
					{
						forceEndEvents.Add(item);
					}
					((HelperLog)logger).LogInfo((object)("init command '" + ((IConsoleCommand)internalStandaloneCommand).Id + "' complete"));
				}
				else
				{
					((HelperLog)logger).LogError((object)("init command '" + ((IConsoleCommand)internalStandaloneCommand).Id + "' failed"));
				}
			}
			((HelperLog)logger).LogInfo((object)$"found {commands.Count} commands and {forceEndEvents.Count} timers");
			((HelperLog)logger).LogInfo((object)"init HelperCommandManager");
			commandManager = (ICommandManager)new HelperCommandManagerFormatted((IDebugLogger)(object)logger);
			commandManager.InitFromFile(Utils.GetRelativeModFilePath("commands.data"));
			int num = commandManager.GetCommands().Length;
			((HelperLog)logger).LogInfo((object)$"found {num} events");
			if (!needValidate)
			{
				return;
			}
			((HelperLog)logger).LogInfo((object)"validate commands");
			string[] array = commandManager.GetCommands();
			foreach (string text in array)
			{
				if (!console.IsValidCommandLine(text?.Trim()))
				{
					((HelperLog)logger).LogError((object)("Command line '" + text + "' invalid"));
				}
			}
			((HelperLog)logger).LogInfo((object)"init HelperCommandManager ends");
		}

		private void ProcessEvent(IEventsData data)
		{
			if (string.IsNullOrEmpty(data.EventID))
			{
				((HelperLog)logger).LogError((object)"ProcessEvent eventID is null or empty");
				return;
			}
			if (!PhotonNetwork.IsMasterClient)
			{
				int viewID = ((MonoBehaviourPun)Character.localCharacter).photonView.ViewID;
				ChaosModNetwork.RequestEventRPC((RpcTarget)2, new ChaosModNetwork.DataSource(viewID, data));
				return;
			}
			ActivateEventLocally(data);
			if (GameUtils.Players.Count() <= 1)
			{
				return;
			}
			string text = commandManager.GetCommandData(data.EventID, true)?.Trim();
			if (string.IsNullOrEmpty(text))
			{
				((HelperLog)Utils.logger).LogWarning((object)"ProcessEvent can't find commands");
				return;
			}
			string[] eventCommands = CommandConsole.ParseCommandLine(text);
			if (ChaosModNetwork.AnyCommandRequiresNetworkSync(eventCommands, commands))
			{
				ChaosModNetwork.ApplyCommandsHostEffects(eventCommands, -42, commands);
				ChaosModNetwork.RequestEventRPC((RpcTarget)1, new ChaosModNetwork.DataSource(-42, data));
			}
		}

		private void ActivateEventLocally(IEventsData data)
		{
			string eventID = data.EventID;
			if (string.IsNullOrEmpty(eventID))
			{
				((HelperLog)logger).LogError((object)"ActivateEventLocally eventID is null or empty");
				return;
			}
			((HelperLog)logger).LogInfo((object)("Try to execute event: '" + eventID + "'"));
			string text = commandManager.GetCommandData(eventID, true)?.Trim();
			try
			{
				((HelperLog)logger).LogInfo((object)("Command: " + text));
				if (console.RunCommand(text, data, (Action<string>)null))
				{
					((HelperLog)logger).LogInfo((object)("Event '" + data.EventID + "' executing is completed"));
					if (notifyManager != null)
					{
						notifyManager.AddNotifyToQueue(data, translationService.translation, (Func<string, string>)null, true);
					}
				}
				else
				{
					((HelperDebugLog)logger).LogDebugError((object)("Event '" + data.EventID + "' executing is failed"));
				}
			}
			catch (Exception arg)
			{
				((HelperLog)logger).LogError((object)$"ActivateEventLocally '{data.EventID}' unexpected error: {arg}");
			}
		}

		private void CancelEvents()
		{
			try
			{
				((HelperLog)Utils.logger).LogInfo((object)"CancelEvents triggered");
				foreach (IForceEnd forceEndEvent in forceEndEvents)
				{
					try
					{
						forceEndEvent.ForceEnd();
					}
					catch (Exception arg)
					{
						((HelperLog)Utils.logger).LogError((object)$"CancelEvents force end for {((IConsoleCommand)forceEndEvent).Id} error: {arg}");
					}
				}
				if (notifyManager != null)
				{
					notifyManager.ClearNotifyQueue();
					notifyManager.StopCurrentNotify();
				}
			}
			catch (Exception arg2)
			{
				((HelperLog)Utils.logger).LogError((object)$"CancelEvents {arg2}");
			}
		}

		public void Update()
		{
			try
			{
				float deltaTime = Time.deltaTime;
				systemScheduleManager.OnUpdate(deltaTime);
				SettingsManager.OnUpdate();
				scheduleManager.OnUpdate(deltaTime);
				UpdateWarningText();
				if (readyToActivateEvents)
				{
					eventEmitter.TriggerOnUpdateEvent(this, deltaTime);
					((EventsReaderOnFrame)eventsReader).ReadAndProcessAllWithDelayOnFrame(deltaTime);
					ChaosModNetwork.ProcessNetworkEvents(commandManager, commands, ActivateEventLocally);
				}
			}
			catch (Exception arg)
			{
				limitedLogger.LogError((object)$"OnUpdate error: {arg}");
			}
		}

		private void UpdateWarningText()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected I4, but got Unknown
			if (lastUsedLang != LocalizedText.CURRENT_LANGUAGE)
			{
				lastUsedLang = LocalizedText.CURRENT_LANGUAGE;
				Language val = lastUsedLang;
				string text;
				switch (val - 3)
				{
				case 5:
					text = "uk";
					break;
				case 4:
					text = "ru";
					break;
				case 1:
				case 2:
					text = "es";
					break;
				case 0:
					text = "ge";
					break;
				case 8:
					text = "ja";
					break;
				case 9:
					text = "ko";
					break;
				default:
					text = "en";
					break;
				}
				string trans = ServiceProvider.inst.translationService.translation.GetTrans("airplane_warning", text);
				((HelperLog)Utils.logger).LogInfo((object)("got lang: " + text + ", warning text: " + trans));
				CustomNotifyOnGUI.SetNotifyText("Chaos Tricks", trans);
			}
		}

		public void OnGUI()
		{
			CustomNotifyOnGUI.OnGUI();
		}

		public void ReinitMod()
		{
			try
			{
				((HelperLog)logger).LogInfo((object)"ReinitMod starts");
				FlushLog();
				CancelEvents();
				InitCommands(needValidate: false);
				notifyManager.ForcePostInit(Utils.modFolder, (IDebugLogger)(object)Utils.logger, (Func<string, byte[]>)null);
				((HelperLog)logger).LogInfo((object)"ReinitMod ends");
			}
			catch (Exception arg)
			{
				((HelperLog)logger).LogError((object)$"ReinitMod error: {arg}");
			}
			FlushLog();
		}
	}
	internal sealed class JsonParser : IJsonUtils
	{
		public T FromFile<T>(string path) where T : class
		{
			using StreamReader streamReader = new StreamReader(path);
			return FromString<T>(streamReader.ReadToEnd());
		}

		public T FromString<T>(string s) where T : class
		{
			return JsonConvert.DeserializeObject<T>(s);
		}
	}
	public static class Utils
	{
		public static readonly Random rnd = new Random(Guid.NewGuid().GetHashCode());

		public static readonly string modFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		public static readonly BufferedLogger logger = new BufferedLogger(modFolder, "latest_log.txt", false, 50);

		public static string GetRelativeModFilePath(string fname)
		{
			return Path.Combine(modFolder, fname);
		}
	}
}
namespace peak_bepinex.Services
{
	internal static class ArgsReaderFactory
	{
		public static CommandArgsReader NewReader(IEnumerable<string> args)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return new CommandArgsReader(args, (ILogger)(object)Utils.logger);
		}
	}
	public class ChaosModNetwork : MonoBehaviour
	{
		public struct DataSource
		{
			public int playerID;

			public string eventID;

			public string username;

			public string lang;

			public DataSource(int playerID, IEventsData e)
			{
				this.playerID = playerID;
				eventID = e.EventID;
				username = e.Username;
				lang = e.Lang;
			}

			public object[] ToNetworkArray()
			{
				return new object[4] { playerID, eventID, lang, username };
			}

			public EventsData ToEventData()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				return new EventsData
				{
					Username = username,
					EventID = eventID,
					Lang = lang
				};
			}
		}

		private static readonly Queue<DataSource> commandQueue = new Queue<DataSource>();

		public const int ANY_PLAYER_ID = -42;

		[PunRPC]
		private void ActivateClientEventRPC(int playerID, string eventID, string lang, string username)
		{
			((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->ActivateClientEventRPC triggered for {playerID} {eventID}");
			if (commandQueue == null)
			{
				((HelperLog)Utils.logger).LogError((object)"ChaosModNetwork->ActivateClientEventRPC an attempt to store events before initiating");
				return;
			}
			commandQueue.Enqueue(new DataSource
			{
				playerID = playerID,
				eventID = eventID,
				lang = lang,
				username = username
			});
		}

		public static void RequestEventRPC(RpcTarget rpcTarget, DataSource data)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->RequestEventRPC triggered for {data.playerID} {data.eventID}");
			try
			{
				((MonoBehaviourPun)Character.localCharacter).photonView.RPC("ActivateClientEventRPC", rpcTarget, data.ToNetworkArray());
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->RequestEventRPC error: {arg}");
			}
		}

		public static void ProcessNetworkEvents(ICommandManager cm, Dictionary<string, IInternalStandaloneCommand> commands, Action<IEventsData> activateEventLocally)
		{
			while (commandQueue.Count > 0)
			{
				try
				{
					if (PhotonNetwork.IsMasterClient)
					{
						ProcessNetworkEvents_OnHostSide(cm, commands, activateEventLocally);
					}
					else
					{
						ProcessNetworkEvents_OnClientSide(activateEventLocally);
					}
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->ProcessNetworkEvents (host {PhotonNetwork.IsMasterClient}): {arg}");
				}
			}
		}

		private static void ProcessNetworkEvents_OnHostSide(ICommandManager cm, Dictionary<string, IInternalStandaloneCommand> commands, Action<IEventsData> activateEventLocally)
		{
			DataSource dataSource = commandQueue.Dequeue();
			((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->ProcessNetworkEvents_OnHostSide event id {dataSource.eventID} for {dataSource.playerID}");
			if (dataSource.playerID == -42)
			{
				((HelperLog)Utils.logger).LogError((object)"ChaosModNetwork->ProcessNetworkEvents_OnHostSide should not get here any player ID");
				return;
			}
			string text = cm.GetCommandData(dataSource.eventID, true)?.Trim();
			if (string.IsNullOrEmpty(text))
			{
				((HelperLog)Utils.logger).LogWarning((object)"ChaosModNetwork->ProcessNetworkEvents_OnHostSide can't find commands");
				return;
			}
			string[] eventCommands = CommandConsole.ParseCommandLine(text);
			if (AnyCommandRequiresNetworkSync(eventCommands, commands))
			{
				activateEventLocally((IEventsData)(object)dataSource.ToEventData());
				ApplyCommandsHostEffects(eventCommands, -42, commands);
				DataSource data = dataSource;
				data.playerID = -42;
				RequestEventRPC((RpcTarget)1, data);
			}
			else
			{
				ApplyCommandsHostEffects(eventCommands, dataSource.playerID, commands);
				RequestEventRPC((RpcTarget)1, dataSource);
			}
		}

		public static bool AnyCommandRequiresNetworkSync(string[] eventCommands, Dictionary<string, IInternalStandaloneCommand> commands)
		{
			for (int i = 0; i < eventCommands.Length; i++)
			{
				string key = CommandConsole.ParseArgs(eventCommands[i])[0];
				try
				{
					if (commands[key] is INetworkSyncCommand networkSyncCommand && networkSyncCommand.NeedSendToOthers())
					{
						return true;
					}
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->AnyCommandRequiresNetworkSync: {arg}");
					return false;
				}
			}
			return false;
		}

		public static void ApplyCommandsHostEffects(string[] eventCommands, int playerID, Dictionary<string, IInternalStandaloneCommand> commands)
		{
			Character[] array;
			if (playerID == -42)
			{
				array = GameUtils.Players.Where((Character ch) => (Object)(object)ch != (Object)null && (Object)(object)ch != (Object)(object)Character.localCharacter).ToArray();
			}
			else
			{
				Character characterByNetworkID = GameUtils.GetCharacterByNetworkID(playerID);
				if ((Object)(object)characterByNetworkID == (Object)null)
				{
					((HelperLog)Utils.logger).LogError((object)"ChaosModNetwork->ApplyCommandsHostEffect: null target");
					return;
				}
				array = (Character[])(object)new Character[1] { characterByNetworkID };
			}
			Character[] array2 = array;
			foreach (Character val in array2)
			{
				foreach (string text in eventCommands)
				{
					string[] array3 = CommandConsole.ParseArgs(text);
					string key = array3[0];
					try
					{
						if (commands[key] is IHostNetworkCommand hostNetworkCommand)
						{
							hostNetworkCommand.ExecuteHostAction(array3.Skip(1), val);
						}
					}
					catch (Exception ex)
					{
						((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->ApplyCommandsHostEffect cmd {text}, target {((Object)val).name}, id {((MonoBehaviourPun)val).photonView.ViewID}: {ex}");
					}
				}
			}
		}

		private static void ProcessNetworkEvents_OnClientSide(Action<IEventsData> activateEventLocally)
		{
			DataSource dataSource = commandQueue.Dequeue();
			if (dataSource.playerID == -42 || dataSource.playerID == ((MonoBehaviourPun)Character.localCharacter).photonView.ViewID)
			{
				((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->ProcessNetworkEvents_OnClientSide event id {dataSource.eventID} for {dataSource.playerID}");
				activateEventLocally((IEventsData)(object)dataSource.ToEventData());
			}
			else
			{
				((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->ProcessNetworkEvents_OnClientSide event id {dataSource.eventID} for other player {dataSource.playerID}. Skipped.");
			}
		}
	}
	public sealed class EventEmitter
	{
		private enum Event
		{
			OnUpdate,
			OnConfigChangedThreadSafe
		}

		private class EmitterAction
		{
			public string id;

			public Action<object, object> action;
		}

		private readonly ILogger logger = (ILogger)new LimitedLogWrapper(100, (IDebugLogger)(object)Utils.logger);

		private readonly Dictionary<Event, List<EmitterAction>> eventHandlers;

		public EventEmitter()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			eventHandlers = new Dictionary<Event, List<EmitterAction>>();
			foreach (Event item in Enum.GetValues(typeof(Event)).OfType<Event>())
			{
				eventHandlers[item] = new List<EmitterAction>();
			}
		}

		private void ReplaceOrAddHandler(Event key, string id, Action<object, object> handler)
		{
			if (id != null)
			{
				eventHandlers[key].RemoveAll((EmitterAction action) => action.id == id);
			}
			eventHandlers[key].Add(new EmitterAction
			{
				action = handler,
				id = id
			});
		}

		private void TriggerEvent(Event key, object sender, object data)
		{
			try
			{
				if (!eventHandlers.TryGetValue(key, out var value))
				{
					return;
				}
				foreach (EmitterAction item in value)
				{
					try
					{
						item.action(sender, data);
					}
					catch (Exception arg)
					{
						logger.LogError((object)$"EventEmitter->TriggerEvent inner {key} error: {arg}");
					}
				}
			}
			catch (Exception arg2)
			{
				logger.LogError((object)$"EventEmitter->TriggerEvent {key} error: {arg2}");
			}
		}

		public void ReplaceOrAddOnUpdateHandler(string id, Action<object, float> handler)
		{
			ReplaceOrAddHandler(Event.OnUpdate, id, delegate(object sender, object data)
			{
				handler(sender, (float)data);
			});
		}

		public void TriggerOnUpdateEvent(object sender, float dtInSec)
		{
			TriggerEvent(Event.OnUpdate, sender, dtInSec);
		}

		public void ReplaceOrAddOnConfigChanged_ThreadSafeHandler(string id, Action<object, SettingsData> handler)
		{
			ReplaceOrAddHandler(Event.OnConfigChangedThreadSafe, id, delegate(object sender, object settings)
			{
				handler(sender, (SettingsData)settings);
			});
		}

		public void TriggerOnConfigChangedEvent_ThreadSafe(object sender, SettingsData settings)
		{
			TriggerEvent(Event.OnConfigChangedThreadSafe, sender, settings);
		}
	}
	public sealed class ServiceProvider
	{
		public static readonly ServiceProvider inst = new ServiceProvider();

		public ScheduleManager systemScheduleManager;

		public ScheduleManager scheduleManager;

		public EventEmitter eventEmitter;

		public TranslationService translationService;

		public void RegisterSystemScheduleManager(ScheduleManager systemScheduleManager)
		{
			this.systemScheduleManager = systemScheduleManager;
		}

		public void RegisterScheduleManager(ScheduleManager scheduleManager)
		{
			this.scheduleManager = scheduleManager;
		}

		public void RegisterEventEmitter(EventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		public void RegisterTranslationService(TranslationService translationService)
		{
			this.translationService = translationService;
		}
	}
	public sealed class SettingsData
	{
		public bool applySpawnItemsToAll;

		public bool applyEffectsToAll = true;
	}
	public static class SettingsManager
	{
		private static SettingsData newData;

		public static SettingsData Data { get; private set; } = new SettingsData();


		public static void QueueUpdateSettings(SettingsData data)
		{
			newData = data;
		}

		public static void OnUpdate()
		{
			if (newData != null)
			{
				Data = newData;
				ServiceProvider.inst.eventEmitter.TriggerOnConfigChangedEvent_ThreadSafe(null, Data);
				newData = null;
			}
		}
	}
	public class TranslationService
	{
		public readonly ITranslation translation;

		public TranslationService()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			translation = (ITranslation)new HelperLanguagesFormatted((IDebugLogger)(object)Utils.logger);
		}

		public void LoadData()
		{
			translation.InitFromFile(Utils.GetRelativeModFilePath("langs.data"));
		}
	}
}
namespace peak_bepinex.Patchers
{
	[HarmonyPatch(typeof(Character), "Awake")]
	public class CharacterPatcher
	{
		public static void Postfix(Character __instance)
		{
			if ((Object)(object)((Component)__instance).GetComponent<ChaosModNetwork>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<ChaosModNetwork>();
			}
		}
	}
	public static class MainPatcher
	{
		private static bool isPatched;

		public static void InitPatch()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (isPatched)
			{
				return;
			}
			isPatched = true;
			try
			{
				((HelperLog)Utils.logger).Log((object)"MainPatcher init");
				new Harmony("com.Loki.patch").PatchAll(Assembly.GetExecutingAssembly());
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"MainPatcher error: {arg}");
			}
		}
	}
}
namespace peak_bepinex.Commands
{
	internal class AddBonusStamina : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "add_bonus_stamina";

		public bool Execute(IEnumerable<string> args)
		{
			float num = ArgsReaderFactory.NewReader(args).ReadFloat(0f);
			Character.localCharacter.AddExtraStamina(num);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class AddStamina : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "add_stamina";

		public bool Execute(IEnumerable<string> args)
		{
			float num = ArgsReaderFactory.NewReader(args).ReadFloat(0f);
			Character.localCharacter.AddStamina(num);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ApplyMushroomEffect : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "apply_mushroom_effect";

		public bool Execute(IEnumerable<string> args)
		{
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			string text = obj.ReadString("");
			float durationInSec = obj.ReadFloat(0f);
			switch (text)
			{
			case "infinite_stamina":
				InfiniteStamina(durationInSec);
				break;
			case "super_speed":
				SuperSpeed(durationInSec);
				break;
			case "low_gravity":
				LowGravity(durationInSec);
				break;
			case "invincibility":
				Invincibility(durationInSec);
				break;
			case "minor_heal":
				MinorHeal();
				break;
			case "explode":
				Explode();
				break;
			case "blind":
				Blind(durationInSec);
				break;
			case "numb":
				Numb(durationInSec);
				break;
			default:
				((HelperLog)Utils.logger).LogError((object)("unknown mushroom effect id: " + text));
				return false;
			}
			return true;
		}

		private void InfiniteStamina(float durationInSec)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Affliction_InfiniteStamina val = new Affliction_InfiniteStamina(durationInSec);
			Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
		}

		private void SuperSpeed(float durationInSec)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Affliction_FasterBoi val = new Affliction_FasterBoi
			{
				moveSpeedMod = 0.5f,
				climbSpeedMod = 1.5f,
				totalTime = durationInSec,
				climbDelay = 1f
			};
			Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
		}

		private void LowGravity(float durationInSec)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			Affliction_LowGravity val = new Affliction_LowGravity(3, durationInSec);
			Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
		}

		private void Invincibility(float durationInSec)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			Affliction_Invincibility val = new Affliction_Invincibility
			{
				totalTime = durationInSec
			};
			Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
		}

		private void MinorHeal()
		{
			Character localCharacter = Character.localCharacter;
			localCharacter.refs.afflictions.AdjustStatus((STATUSTYPE)1, -0.15f, false);
			localCharacter.refs.afflictions.AdjustStatus((STATUSTYPE)0, -0.15f, false);
			localCharacter.refs.afflictions.AdjustStatus((STATUSTYPE)3, -0.15f, false);
			localCharacter.refs.afflictions.ClearPoisonAfflictions();
		}

		private void Explode()
		{
			//IL_0012: 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_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)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			GameUtils instance = GameUtils.instance;
			instance.SpawnResourceAtPositionNetworked("VFX_SporeExploExploEdibleSpawn", localCharacter.Center, (RpcTarget)1);
			instance.RPC_SpawnResourceAtPosition("VFX_SporeExploExploEdibleSpawn_NoKnockback", localCharacter.Center);
			Rigidbody rig = GameUtils.GetCharacterBodypart((BodypartType)0).Rig;
			localCharacter.AddForceToBodyPart(rig, Vector3.zero, Vector3.up * 100f);
		}

		private void Blind(float durationInSec)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			Affliction_Blind val = new Affliction_Blind
			{
				totalTime = durationInSec
			};
			Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
		}

		private void Numb(float durationInSec)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			Affliction_Numb val = new Affliction_Numb
			{
				totalTime = durationInSec
			};
			Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DamageOnMouseClick : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "damage_on_mouse_click";

		public bool IsActive { get; private set; }

		private string PeriodicId => Id + "_period";

		public bool Execute(IEnumerable<string> args)
		{
			//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_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_0072: Expected O, but got Unknown
			//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)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			CommandArgsReader val = ArgsReaderFactory.NewReader(args);
			float durationInSec = val.ReadFloat(0f);
			float damage = val.ReadFloat(0f);
			IsActive = true;
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ServiceProvider.inst.scheduleManager.RemovePeriodicTask(PeriodicId);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			ServiceProvider.inst.scheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				id = PeriodicId,
				periodInSec = 0f,
				periodicAction = delegate
				{
					if (IsActive)
					{
						Character localCharacter = Character.localCharacter;
						if (localCharacter.input.usePrimaryWasPressed || localCharacter.input.useSecondaryWasPressed)
						{
							localCharacter.refs.afflictions.AddStatus((STATUSTYPE)0, damage, false, true);
						}
					}
				}
			}, false);
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DamageOnJump : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "damage_on_jump";

		public bool IsActive { get; private set; }

		private string PeriodicId => Id + "_period";

		public bool Execute(IEnumerable<string> args)
		{
			//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_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_0072: Expected O, but got Unknown
			//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)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			CommandArgsReader val = ArgsReaderFactory.NewReader(args);
			float durationInSec = val.ReadFloat(0f);
			float damage = val.ReadFloat(0f);
			IsActive = true;
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ServiceProvider.inst.scheduleManager.RemovePeriodicTask(PeriodicId);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			ServiceProvider.inst.scheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				id = PeriodicId,
				periodInSec = 0f,
				periodicAction = delegate
				{
					if (IsActive)
					{
						Character localCharacter = Character.localCharacter;
						if (localCharacter.input.jumpWasPressed)
						{
							localCharacter.refs.afflictions.AddStatus((STATUSTYPE)0, damage, false, true);
						}
					}
				}
			}, false);
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class Knockdown : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "knockdown";

		public bool Execute(IEnumerable<string> args)
		{
			Traverse.Create((object)Character.localCharacter).Method("Fall", new object[2] { 8f, 0f }).GetValue();
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class SlipperyPlayer : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "slippery_player";

		public bool Execute(IEnumerable<string> args)
		{
			//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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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)
			Character localCharacter = Character.localCharacter;
			Dictionary<BodypartType, Bodypart> partDict = localCharacter.refs.ragdoll.partDict;
			Rigidbody rig = partDict[(BodypartType)16].Rig;
			Rigidbody rig2 = partDict[(BodypartType)13].Rig;
			Rigidbody rig3 = partDict[(BodypartType)0].Rig;
			Rigidbody rig4 = partDict[(BodypartType)4].Rig;
			localCharacter.RPCA_Fall(2f);
			Vector3 val = (localCharacter.data.lookDirection_Flat + Vector3.up) * 200f;
			rig.AddForce(val, (ForceMode)1);
			rig2.AddForce(val, (ForceMode)1);
			rig3.AddForce(Vector3.up * 1500f, (ForceMode)1);
			rig4.AddForce(localCharacter.data.lookDirection_Flat * -300f, (ForceMode)1);
			Vector3 pos = localCharacter.Center;
			PlaySound(in pos);
			return true;
		}

		private void PlaySound(in Vector3 pos)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			SlipperyJellyfish val = Object.FindFirstObjectByType<SlipperyJellyfish>();
			if (!((Object)(object)val == (Object)null) && val.slipSFX != null)
			{
				for (int i = 0; i < val.slipSFX.Length; i++)
				{
					val.slipSFX[i].Play(pos);
				}
			}
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class LockCamera : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "lock_camera";

		public bool IsActive { get; private set; }

		private string PeriodicId => Id + "_period";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_005c: 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_006d: 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_0090: Expected O, but got Unknown
			float durationInSec = ArgsReaderFactory.NewReader(args).ReadFloat(0f);
			IsActive = true;
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					Character.localCharacter.data.usingBackpackWheel = false;
					ServiceProvider.inst.scheduleManager.RemovePeriodicTask(PeriodicId);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			ServiceProvider.inst.scheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				id = PeriodicId,
				periodInSec = 0.005f,
				periodicAction = delegate
				{
					if (IsActive)
					{
						Character.localCharacter.data.usingBackpackWheel = true;
					}
				}
			}, false);
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class RandomizeOutfitPeriodically : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "randomize_outfit_periodically";

		public bool IsActive { get; private set; }

		private string PeriodicId => Id + "_period";

		public bool Execute(IEnumerable<string> args)
		{
			//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_003f: 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_005e: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float durationInSec = obj.ReadFloat(0f);
			float periodInSec = obj.ReadFloat(0f);
			IsActive = true;
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ServiceProvider.inst.scheduleManager.RemovePeriodicTask(PeriodicId);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			ServiceProvider.inst.scheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				id = PeriodicId,
				periodInSec = periodInSec,
				periodicAction = delegate
				{
					CharacterCustomization customization = Character.localCharacter.refs.customization;
					customization.SetRandomEyes();
					customization.SetRandomMouth();
					customization.SetRandomAccessory();
					customization.SetRandomOutfit();
					customization.SetRandomHat();
				}
			}, false);
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class RandomizeColorPeriodically : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "randomize_color_periodically";

		public bool IsActive { get; private set; }

		private string PeriodicId => Id + "_period";

		public bool Execute(IEnumerable<string> args)
		{
			//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_003f: 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_005e: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float durationInSec = obj.ReadFloat(0f);
			float periodInSec = obj.ReadFloat(0f);
			IsActive = true;
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ServiceProvider.inst.scheduleManager.RemovePeriodicTask(PeriodicId);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			ServiceProvider.inst.scheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				id = PeriodicId,
				periodInSec = periodInSec,
				periodicAction = delegate
				{
					Character.localCharacter.refs.customization.SetRandomSkinColor();
				}
			}, false);
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class RemoveTicks : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "remove_ticks";

		public bool Execute(IEnumerable<string> args)
		{
			Bugfix[] array = Object.FindObjectsOfType<Bugfix>();
			((HelperLog)Utils.logger).LogInfo((object)$"Found ticks: {array?.Length}");
			if (array == null || array.Length == 0)
			{
				return false;
			}
			Character ch = Character.localCharacter;
			array = array.Where((Bugfix tick) => (Object)(object)Traverse.Create((object)tick).Field<Character>("targetCharacter").Value == (Object)(object)ch).ToArray();
			((HelperLog)Utils.logger).LogInfo((object)$"Filtered ticks: {array.Length}");
			Bugfix[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Traverse.Create((object)array2[i]).Field<PhotonView>("photonView").Value.RPC("RPCA_Remove", (RpcTarget)0, Array.Empty<object>());
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ClearPlayerStatus : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "clear_status";

		public bool Execute(IEnumerable<string> args)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			STATUSTYPE val = GameUtils.NameToPlayerStatusType(ArgsReaderFactory.NewReader(args).ReadString(""));
			Character.localCharacter.refs.afflictions.SetStatus(val, 0f, true);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ClearPlayerStatuses : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "clear_statuses";

		public bool Execute(IEnumerable<string> args)
		{
			Character.localCharacter.refs.afflictions.ClearAllStatus(false);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ApplyForceToPlayer_UpWay : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "apply_force_to_player_up";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float num = obj.ReadFloat(1000f);
			int num2 = obj.ReadInt(1);
			Vector3 dir = GameUtils.GetLocalPlayerUpWay() * (float)num2 * num;
			GameUtils.ApplyForceToLocalPlayer(in dir);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ApplyForceToPlayer_ForwardWay : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "apply_force_to_player_forward";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float num = obj.ReadFloat(1000f);
			int num2 = obj.ReadInt(1);
			Vector3 dir = GameUtils.GetLocalPlayerForwardWay() * (float)num2 * num;
			GameUtils.ApplyForceToLocalPlayer(in dir);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ApplyForceToPlayer_RightWay : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "apply_force_to_player_right";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float num = obj.ReadFloat(1000f);
			int num2 = obj.ReadInt(1);
			Vector3 dir = GameUtils.GetLocalPlayerRightWay() * (float)num2 * num;
			GameUtils.ApplyForceToLocalPlayer(in dir);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ApplyForceToPlayer : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "apply_force_to_player";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_002c: 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)
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float num = obj.ReadFloat(0f);
			float num2 = obj.ReadFloat(0f);
			float num3 = obj.ReadFloat(0f);
			Vector3 dir = new Vector3(num, num2, num3);
			GameUtils.ApplyForceToLocalPlayer(in dir);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ChangeWind : IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "change_wind";

		public bool Execute(IEnumerable<string> args)
		{
			string text = ArgsReaderFactory.NewReader(args).ReadString("");
			if (!(text == "start"))
			{
				if (text == "stop")
				{
					SetWindStatus(enable: false);
					return true;
				}
				((HelperLog)Utils.logger).LogWarning((object)"undefined wind status. Will use 'start'.");
				SetWindStatus(enable: true);
				return true;
			}
			SetWindStatus(enable: true);
			return true;
		}

		private void SetWindStatus(bool enable)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			WindChillZone val = Object.FindFirstObjectByType<WindChillZone>();
			if ((Object)(object)val == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"Can't find wind manager");
				return;
			}
			Traverse obj = Traverse.Create((object)val);
			Vector3 randomDirection = GetRandomDirection();
			obj.Method("RPCA_ToggleWind", new object[3] { enable, randomDirection, 1 }).GetValue();
		}

		private Vector3 GetRandomDirection()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			int randomSign = UnityMathUtils.GetRandomSign();
			float num = Random.Range(0.25f, 0.5f);
			Vector3 val = Vector3.Lerp(Vector3.left * (float)randomSign, Vector3.forward, num);
			return ((Vector3)(ref val)).normalized;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class AddPlayerStatus : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "add_status";

		public bool Execute(IEnumerable<string> args)
		{
			//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)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			string name = obj.ReadString("");
			float num = obj.ReadFloat(0f);
			STATUSTYPE val = GameUtils.NameToPlayerStatusType(name);
			Character.localCharacter.refs.afflictions.AddStatus(val, num, false, true);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class RandomizeCustomization : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "randomize_cosmetics";

		public bool Execute(IEnumerable<string> args)
		{
			Character.localCharacter.refs.customization.RandomizeCosmetics();
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class PlayEmote : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "play_emote";

		public bool Execute(IEnumerable<string> args)
		{
			string text = ArgsReaderFactory.NewReader(args).ReadString("");
			((HelperLog)Utils.logger).LogInfo((object)("try to play emote '" + text + "'"));
			if (text == "random")
			{
				text = GetRandomEmote();
				((HelperLog)Utils.logger).LogInfo((object)("random selected '" + text + "'"));
			}
			Traverse.Create((object)Character.localCharacter.refs.animations).Method("PlayEmote", new object[1] { text }).GetValue();
			return true;
		}

		private string GetRandomEmote()
		{
			return RandomUtils.GetRandomItemFromList<string>((IList<string>)new string[11]
			{
				"A_Scout_Emote_Salute", "A_Scout_Emote_Dance1", "A_Scout_Emote_Dance2", "A_Scout_Emote_Crashout", "A_Scout_Emote_Wave", "A_Scout_Emote_CrossedArms", "A_Scout_Emote_Shrug", "A_Scout_Emote_Flex", "A_Scout_Emote_Nono", "A_Scout_Emote_Think",
				"A_Scout_Emote_ThumbsUp"
			});
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DropBackpack : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "drop_backpack";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_001e: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			float num = ArgsReaderFactory.NewReader(args).ReadFloat(0f);
			Transform transform = ((Component)GameUtils.GetCharacterBodypart((BodypartType)0)).transform;
			Vector3 val = transform.position + transform.forward * num;
			((MonoBehaviourPun)Character.localCharacter).photonView.RPC("DropItemFromSlotRPC", (RpcTarget)0, new object[2]
			{
				(byte)3,
				val
			});
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class AddTick : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "add_tick";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			int num = ArgsReaderFactory.NewReader(args).ReadInt(1);
			int viewID = ((MonoBehaviourPun)Character.localCharacter).photonView.ViewID;
			for (int i = 0; i < num; i++)
			{
				PhotonNetwork.Instantiate("BugfixOnYou", Vector3.zero, Quaternion.identity, (byte)0, (object[])null).GetComponent<PhotonView>().RPC("AttachBug", (RpcTarget)0, new object[1] { viewID });
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DropRandomInvetoryItem : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "drop_random_inventory_item";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_00b3: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			float num = ArgsReaderFactory.NewReader(args).ReadFloat(0.6f);
			Character ch = Character.localCharacter;
			List<ItemSlot> list = (from i in Enumerable.Range(0, 3)
				select ch.player.GetItemSlot((byte)i) into slot
				where slot != null && !slot.IsEmpty()
				select slot).ToList();
			if (list.Count == 0)
			{
				((HelperLog)Utils.logger).LogInfo((object)"Inventory items not found.");
				return true;
			}
			byte itemSlotID = RandomUtils.GetRandomItemFromList<ItemSlot>((IList<ItemSlot>)list).itemSlotID;
			((HelperLog)Utils.logger).LogInfo((object)$"target slot: {itemSlotID}");
			Optionable<byte> currentSelectedSlot = ch.refs.items.currentSelectedSlot;
			if (currentSelectedSlot.IsSome && currentSelectedSlot.Value == itemSlotID)
			{
				DropItemInHands.DropItem(0.2f);
			}
			Transform transform = ((Component)GameUtils.GetCharacterBodypart((BodypartType)0)).transform;
			Vector3 val = transform.position + transform.forward * num;
			((MonoBehaviourPun)ch).photonView.RPC("DropItemFromSlotRPC", (RpcTarget)0, new object[2] { itemSlotID, val });
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DropInvetoryItems : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "drop_inventory_items";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float num = obj.ReadFloat(0.6f);
			float num2 = obj.ReadFloat(0.5f);
			DropItemInHands.DropItem(0.2f);
			Character localCharacter = Character.localCharacter;
			Transform transform = ((Component)GameUtils.GetCharacterBodypart((BodypartType)0)).transform;
			Vector3 val = transform.position + transform.forward * num;
			for (int i = 0; i <= 2; i++)
			{
				((MonoBehaviourPun)localCharacter).photonView.RPC("DropItemFromSlotRPC", (RpcTarget)0, new object[2]
				{
					(byte)i,
					val
				});
				val += Vector3.up * num2;
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DropItemInHands : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "drop_item_in_hands";

		public bool Execute(IEnumerable<string> args)
		{
			return DropItem(ArgsReaderFactory.NewReader(args).ReadFloat(0f));
		}

		public static bool DropItem(float throwPower)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			CharacterItems items = localCharacter.refs.items;
			if (items.currentSelectedSlot.IsNone || (Object)(object)localCharacter.data.currentItem == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"DropItemInHands can't drop an item. Hands slot is empty.");
				return false;
			}
			byte value = items.currentSelectedSlot.Value;
			ItemSlot itemSlot = localCharacter.player.GetItemSlot(value);
			((MonoBehaviourPun)localCharacter).photonView.RPC("DropItemRpc", (RpcTarget)0, new object[6]
			{
				throwPower,
				value,
				((Component)localCharacter.data.currentItem).transform.position + Vector3.down * 0.2f,
				localCharacter.data.currentItem.rig.linearVelocity,
				((Component)localCharacter.data.currentItem).transform.rotation,
				itemSlot.data
			});
			items.throwChargeLevel = 0f;
			items.EquipSlot(Optionable<byte>.None);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class GravityPower : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private bool isInitiated;

		private float defaultPower;

		public string Id => "gravity_power";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0062: 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)
			//IL_0073: 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_008d: Expected O, but got Unknown
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float durationInSec = obj.ReadFloat(0f);
			float num = obj.ReadFloat(0f);
			CharacterMovement movement = Character.localCharacter.refs.movement;
			if (!isInitiated)
			{
				isInitiated = true;
				defaultPower = movement.maxGravity;
			}
			bool num2 = movement.maxGravity != num;
			movement.maxGravity = num;
			IsActive = true;
			TimerTaskData val = new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					Character localCharacter = Character.localCharacter;
					localCharacter.refs.movement.maxGravity = defaultPower;
					localCharacter.data.sinceGrounded = 0f;
					localCharacter.data.sinceJump = 0f;
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			};
			if (num2)
			{
				ServiceProvider.inst.scheduleManager.NewTimerTask(val, false);
			}
			else
			{
				ServiceProvider.inst.scheduleManager.AppendTimerTask(val, false);
			}
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class LockStatus : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "lock_status";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			float durationInSec = ArgsReaderFactory.NewReader(args).ReadFloat(0f);
			IsActive = true;
			ReflectionUtility.SetInternalProperty((object)Character.localCharacter, "statusesLocked", (object)true);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ReflectionUtility.SetInternalProperty((object)Character.localCharacter, "statusesLocked", (object)false);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class SpeedBonus : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private string oldActivationKey;

		public string Id => "speed_bonus";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			CommandArgsReader val = ArgsReaderFactory.NewReader(args);
			float durationInSec = val.ReadFloat(0f);
			float modifierMove = val.ReadFloat(0f);
			float modifierClimb = val.ReadFloat(0f);
			float modifierRope = val.ReadFloat(0f);
			float modifierVine = val.ReadFloat(0f);
			string text = val.ReadString("");
			TimerTaskData val2 = new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					SetModifiers(Character.localCharacter, 0f - modifierMove, 0f - modifierClimb, 0f - modifierRope, 0f - modifierVine);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			};
			if (!IsActive || text != oldActivationKey)
			{
				IsActive = true;
				oldActivationKey = text;
				SetModifiers(Character.localCharacter, modifierMove, modifierClimb, modifierRope, modifierVine);
				ServiceProvider.inst.scheduleManager.NewTimerTask(val2, true);
			}
			else
			{
				ServiceProvider.inst.scheduleManager.AppendTimerTask(val2, true);
			}
			return true;
		}

		private void SetModifiers(Character ch, float modifierMove, float modifierClimb, float modifierRope, float modifierVine)
		{
			CharacterMovement movement = ch.refs.movement;
			movement.movementModifier += modifierMove;
			CharacterClimbing climbing = ch.refs.climbing;
			climbing.climbSpeedMod += modifierClimb;
			CharacterRopeHandling ropeHandling = ch.refs.ropeHandling;
			ropeHandling.climbSpeedMod += modifierRope;
			CharacterVineClimbing vineClimbing = ch.refs.vineClimbing;
			vineClimbing.climbSpeedMod += modifierVine;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class JumpPower : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private bool isInitiated;

		private float defaultJumpGravity;

		public string Id => "jump_power";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0062: 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)
			//IL_0073: 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_008d: Expected O, but got Unknown
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float durationInSec = obj.ReadFloat(0f);
			float num = obj.ReadFloat(0f);
			CharacterMovement movement = Character.localCharacter.refs.movement;
			if (!isInitiated)
			{
				isInitiated = true;
				defaultJumpGravity = movement.jumpGravity;
			}
			bool num2 = movement.jumpGravity != num;
			movement.jumpGravity = num;
			IsActive = true;
			TimerTaskData val = new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					Character.localCharacter.refs.movement.jumpGravity = defaultJumpGravity;
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			};
			if (num2)
			{
				ServiceProvider.inst.scheduleManager.NewTimerTask(val, false);
			}
			else
			{
				ServiceProvider.inst.scheduleManager.AppendTimerTask(val, false);
			}
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class InfiniteStamina : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "infinite_stamina";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			float durationInSec = ArgsReaderFactory.NewReader(args).ReadFloat(0f);
			IsActive = true;
			Character.localCharacter.data.currentStamina = 1f;
			Traverse.Create((object)Character.localCharacter).Property("infiniteStam", (object[])null).SetValue((object)true);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					Traverse.Create((object)Character.localCharacter).Property("infiniteStam", (object[])null).SetValue((object)false);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			return true;
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ChangeMouseSens : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private float oldMouseSens;

		private float oldConstrollerSens;

		private float lastMouseCommandSens;

		private bool needStoreOldSettings = true;

		public string Id => "change_mouse_move_sens";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00af: Expected O, but got Unknown
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			float durationInSec = obj.ReadFloat(30f);
			float num = obj.ReadFloat(2.5f);
			float num2 = obj.ReadFloat(2.5f);
			FloatSetting mouseSetting = GetMouseSetting();
			FloatSetting controllerSetting = GetControllerSetting();
			if (needStoreOldSettings)
			{
				oldMouseSens = mouseSetting.Value;
				oldConstrollerSens = controllerSetting.Value;
				needStoreOldSettings = false;
			}
			ReflectionUtility.SetInternalProperty((object)mouseSetting, "Value", (object)num);
			ReflectionUtility.SetInternalProperty((object)controllerSetting, "Value", (object)num2);
			TimerTaskData val = new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ReflectionUtility.SetInternalProperty((object)GetMouseSetting(), "Value", (object)oldMouseSens);
					ReflectionUtility.SetInternalProperty((object)GetControllerSetting(), "Value", (object)oldConstrollerSens);
					needStoreOldSettings = true;
				}
			};
			if (lastMouseCommandSens != num)
			{
				if (IsActive)
				{
					((HelperLog)Utils.logger).LogInfo((object)"ChangeMouseSens reset timer");
				}
				ServiceProvider.inst.scheduleManager.NewTimerTask(val, false);
			}
			else
			{
				ServiceProvider.inst.scheduleManager.AppendTimerTask(val, true);
			}
			IsActive = true;
			lastMouseCommandSens = num;
			return true;
		}

		private FloatSetting GetMouseSetting()
		{
			return (FloatSetting)(object)GameHandler.Instance.SettingsHandler.GetSetting<MouseSensitivitySetting>();
		}

		private FloatSetting GetControllerSetting()
		{
			return (FloatSetting)(object)GameHandler.Instance.SettingsHandler.GetSetting<ControllerSensitivitySetting>();
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class MouseInvertY : MouseInvertBase
	{
		public override string Id => "mouse_invert_y";

		protected override OffOnSetting SettingObject => (OffOnSetting)(object)GameHandler.Instance.SettingsHandler.GetSetting<InvertYSetting>();
	}
	internal class MouseInvertX : MouseInvertBase
	{
		public override string Id => "mouse_invert_x";

		protected override OffOnSetting SettingObject => (OffOnSetting)(object)GameHandler.Instance.SettingsHandler.GetSetting<InvertXSetting>();
	}
	internal class RunGameConsoleCommand : IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "console_cmd";

		public bool Execute(IEnumerable<string> args)
		{
			GameUtils.RunGameConsoleCommand(ArgsReaderFactory.NewReader(args).ReadAllAsSingleString(" ", ""));
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class GiveItem : IInternalStandaloneCommand, IConsoleCommand, IHostNetworkCommand, INetworkSyncCommand
	{
		public string Id => "give_item";

		public bool Execute(IEnumerable<string> args)
		{
			return ExecuteHostAction(args, Character.localCharacter);
		}

		public bool ExecuteHostAction(IEnumerable<string> args, Character targetCharacter)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.IsConnected)
			{
				return false;
			}
			if (!PhotonNetwork.IsMasterClient)
			{
				return true;
			}
			CommandArgsReader obj = ArgsReaderFactory.NewReader(args);
			string text = obj.ReadAllAsSingleString(" ", "");
			string[] array = obj.ParseList(text, "|");
			if (array == null || array.Length == 0)
			{
				((HelperLog)Utils.logger).LogWarning((object)"GiveItem found empty item list");
			}
			string randomItemFromList = RandomUtils.GetRandomItemFromList<string>((IList<string>)array);
			PhotonNetwork.Instantiate("0_Items/" + randomItemFromList, targetCharacter.Head + Vector3.up, Quaternion.identity, (byte)0, (object[])null).GetComponent<Item>().RequestPickup(((Component)targetCharacter).GetComponent<PhotonView>());
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}

		public bool NeedSendToOthers()
		{
			return SettingsManager.Data.applySpawnItemsToAll;
		}
	}
	internal class ShufflePlayerMovement : SyncLocalCommand, IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "shuffle_player_movement";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//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_002c: 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_004b: Expected O, but got Unknown
			float durationInSec = ArgsReaderFactory.NewReader(args).ReadFloat(0f);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					RestoreInput();
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			if (ShuffleBinds())
			{
				IsActive = true;
				return true;
			}
			return false;
		}

		private bool ShuffleBinds()
		{
			List<InputAction> actions = GetActions();
			SwapBinds(actions[0], actions[1]);
			SwapBinds(actions[2], actions[3]);
			return true;
		}

		private void SwapBinds(InputAction action1, InputAction action2)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (action1 == null || action2 == null)
			{
				((HelperLog)Utils.logger).LogError((object)"SwapBinds got null bind list");
				return;
			}
			ReadOnlyArray<InputBinding> bindings = action1.bindings;
			ReadOnlyArray<InputBinding> bindings2 = action2.bindings;
			if (bindings.Count <= 0 || bindings2.Count <= 0)
			{
				((HelperLog)Utils.logger).LogError((object)"SwapBinds got 0 binds");
				return;
			}
			for (int i = 0; i < bindings.Count && i < bindings2.Count; i++)
			{
				InputBinding val = bindings[i];
				InputBinding val2 = bindings2[i];
				((HelperLog)Utils.logger).LogInfo((object)("rebind " + ((InputBinding)(ref val)).name + " from " + ((InputBinding)(ref val)).path + " to " + ((InputBinding)(ref val2)).path));
				((HelperLog)Utils.logger).LogInfo((object)("rebind " + ((InputBinding)(ref val2)).name + " from " + ((InputBinding)(ref val2)).path + " to " + ((InputBinding)(ref val)).path));
				((InputBinding)(ref val)).overridePath = ((InputBinding)(ref val2)).path;
				((InputBinding)(ref val2)).overridePath = ((InputBinding)(ref val)).path;
				InputActionRebindingExtensions.ApplyBindingOverride(action1, i, val);
				InputActionRebindingExtensions.ApplyBindingOverride(action2, i, val2);
			}
		}

		private void RestoreInput()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			List<InputAction> actions = GetActions();
			for (int i = 0; i < actions.Count; i++)
			{
				InputAction val = actions[i];
				if (val != null)
				{
					ReadOnlyArray<InputBinding> bindings = val.bindings;
					for (int j = 0; j < bindings.Count; j++)
					{
						InputBinding val2 = bindings[j];
						((InputBinding)(ref val2)).overridePath = null;
						((HelperLog)Utils.logger).LogInfo((object)("reset bind " + ((InputBinding)(ref val2)).name + " to " + ((InputBinding)(ref val2)).path));
						InputActionRebindingExtensions.ApplyBindingOverride(val, j, val2);
					}
				}
			}
		}

		private List<InputAction> GetActions()
		{
			return new List<InputAction>
			{
				CharacterInput.action_moveForward,
				CharacterInput.action_moveBackward,
				CharacterInput.action_moveLeft,
				CharacterInput.action_moveRight
			};
		}

		public void ForceEnd()
		{
			ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(Id);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class TeleportAllPlayersToShrine : IInternalStandaloneCommand, IConsoleCommand, IHostNetworkCommand
	{
		public string Id => "teleport_all_to_shrine";

		public bool Execute(IEnumerable<string> args)
		{
			return ExecuteHostAction(args, Character.localCharacter);
		}

		public bool ExecuteHostAction(IEnumerable<string> args, Character targetCharacter)
		{
			//IL_004f: 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)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			if (!PhotonNetwork.IsMasterClient)
			{
				return true;
			}
			if (ServiceProvider.inst.scheduleManager.IsTaskExists(Id))
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " spams too much. Old teleport is not finished"));
				return true;
			}
			RespawnChest closestObject = GameObjectUtils.GetClosestObject<RespawnChest>(targetCharacter.Center, (Func<RespawnChest, bool>)((RespawnChest obj) => obj.IsInteractible(targetCharacter)), (Action<string>)((HelperLog)Utils.logger).LogInfo);
			if ((Object)(object)closestObject == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " can't find not used Shrine. Skip teleporting."));
				return false;
			}
			Vector3 val = ((Luggage)closestObject).Center();
			Vector3 forward = ((Component)closestObject).transform.forward;
			Vector3 shrinePos = val + ((Vector3)(ref forward)).normalized * 2f;
			ServiceProvider.inst.scheduleManager.NewTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = 1f,
				finishAction = delegate
				{
					Character[] array = GameUtils.AlivePlayers.ToArray();
					for (int i = 0; i < array.Length; i++)
					{
						GameUtils.TeleportPlayer(array[i], in shrinePos);
					}
				}
			}, false);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class TeleportToRandomPlayer : IInternalStandaloneCommand, IConsoleCommand, IHostNetworkCommand
	{
		[CompilerGenerated]
		private sealed class <TeleportPosFinder>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int triggerCount;

			public Character target;

			public TeleportToRandomPlayer <>4__this;

			public Character originalPlayer;

			private List<Vector3> <posList>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0049: 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_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: 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_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: 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;
				TeleportToRandomPlayer teleportToRandomPlayer = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<posList>5__2 = new List<Vector3>();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (triggerCount > 0)
				{
					int num2 = triggerCount - 1;
					triggerCount = num2;
					Vector3 val = target.Center + Vector3.up * (target.data.currentHeadHeight + 1.5f);
					<posList>5__2.Add(val);
					if (triggerCount % 10 == 0)
					{
						((HelperLog)Utils.logger).LogInfo((object)$"found pos {val}");
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (<posList>5__2.Count == 0)
				{
					((HelperLog)Utils.logger).LogError((object)"positions is not found");
					teleportToRandomPlayer.teleportEnds = true;
					return false;
				}
				Vector3 pos = <posList>5__2.Aggregate((Vector3 max, Vector3 next) => (!(next.y > max.y)) ? max : next);
				((HelperLog)Utils.logger).LogInfo((object)$"selected pos {pos}");
				GameUtils.TeleportPlayer(originalPlayer, in pos);
				teleportToRandomPlayer.teleportEnds = 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();
			}
		}

		private const float DELAY = 0.5f;

		private DateTime lastTriggerTime = DateTime.MinValue;

		private bool teleportEnds = true;

		public string Id => "teleport_to_random_player";

		public bool Execute(IEnumerable<string> args)
		{