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 System.Text;
using BepInEx;
using EventsIO;
using EventsIO.Interfaces;
using HarmonyLib;
using ModHelper;
using ModHelper.Interfaces;
using ModHelperUnity;
using ModHelperUnity.Interfaces;
using ModHelperUnity.UtilityGUI;
using Newtonsoft.Json;
using Photon.Pun;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using WebSocketIO;
using Zorro.Core;
using Zorro.Core.CLI;
using Zorro.Settings;
using peak_bepinex;
using peak_bepinex.Commands.Interfaces;
using peak_bepinex.Patchers;
using peak_bepinex.Services;
using peak_bepinex.Wrappers;

[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.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace peak_standalone.Commands
{
	internal class CustomRevive : IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "revive_player";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			bool dead = localCharacter.data.dead;
			if (localCharacter.data.fullyPassedOut && !dead)
			{
				((MonoBehaviourPun)localCharacter).photonView.RPC("RPCA_ReviveAtPosition", (RpcTarget)0, new object[2]
				{
					Character.localCharacter.Head,
					true
				});
			}
			else if (dead)
			{
				PlayerGhost ghost = localCharacter.Ghost;
				Vector3 val = ((!((Object)(object)ghost != (Object)null)) ? Character.localCharacter.Head : (ghost.m_target.Center + Vector3.up * 5f));
				((MonoBehaviourPun)localCharacter).photonView.RPC("RPCA_ReviveAtPosition", (RpcTarget)0, new object[2] { val, true });
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)"player is alive, skip revive");
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
}
namespace peak_bepinex
{
	[BepInPlugin("bft.chaostricks", "Chaos Tricks", "1.0.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
			{
				UtilitySettings.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.0.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.0.0", arg));
			}
		}
	}
	public static class GameUtils
	{
		public struct Coords
		{
			public Vector3 pos;

			public Quaternion rot;
		}

		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 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
			{
				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 static T GetClosestObject<T>(Vector3 pos, Func<T, bool> filter, bool needLog = true) where T : MonoBehaviour
		{
			//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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			T[] array = Object.FindObjectsOfType<T>();
			int num = array.Length;
			if (needLog)
			{
				((HelperLog)Utils.logger).LogInfo((object)$"GetClosestObject found {num}");
			}
			if (num == 0)
			{
				return default(T);
			}
			if (filter != null)
			{
				array = array.Where(filter).ToArray();
				num = array.Length;
				if (needLog)
				{
					((HelperLog)Utils.logger).LogInfo((object)$"GetClosestObject filtered size {num}");
				}
			}
			switch (num)
			{
			case 0:
				return default(T);
			case 1:
				return array[0];
			default:
			{
				T val = array[0];
				Vector3 val2 = pos - ((Component)(object)val).transform.position;
				float num2 = ((Vector3)(ref val2)).sqrMagnitude;
				for (int i = 1; i < num; i++)
				{
					T val3 = array[i];
					val2 = pos - ((Component)(object)val3).transform.position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num2)
					{
						val = val3;
						num2 = sqrMagnitude;
					}
				}
				return val;
			}
			}
		}
	}
	public sealed class InteractiveMod : MonoBehaviour
	{
		public static InteractiveMod inst;

		internal const string MOD_VERSION = "1.0.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 UtilityConsole console;

		private Dictionary<string, IInternalStandaloneCommand> commands;

		private TranslationService translationService;

		private LimitedLogWrapper limitedLogger;

		private LimitedLogWrapper limitedSceneLogger;

		private bool readyToActivateEvents;

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

		public void Awake()
		{
			inst = this;
			Utils.LogClearBySize();
			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.0.0");
			FlushLog();
			MainPatcher.InitPatch();
		}

		public void Start()
		{
			((HelperLog)logger).LogInfo((object)"InteractiveMod Start");
			try
			{
				UtilityJson.RegisterCustomGenerator((Func<IJsonUtil>)(() => (IJsonUtil)(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();
			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));
			readyToActivateEvents = name != "Title" && name != "Airport";
		}

		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 UtilityConsole((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)
		{
			string eventID = data.EventID;
			if (string.IsNullOrEmpty(eventID))
			{
				((HelperLog)logger).LogError((object)"ProcessEvent 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)$"ProcessCommands '{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);
				if (readyToActivateEvents)
				{
					eventEmitter.TriggerOnUpdateEvent(this, deltaTime);
					((EventsReaderOnFrame)eventsReader).ReadAndProcessAllWithDelayOnFrame(deltaTime);
				}
			}
			catch (Exception arg)
			{
				limitedLogger.LogError($"OnUpdate error: {arg}");
			}
		}

		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 : IJsonUtil
	{
		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);

		private const string LOG_FNAME = "latest_log.txt";

		private static readonly string logPath = Path.Combine(modFolder, "latest_log.txt");

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

		public static void LogClearBySize()
		{
			try
			{
				FileInfo fileInfo = new FileInfo(logPath);
				if (fileInfo.Exists && fileInfo.Length > 200000)
				{
					((HelperLog)logger).LogClear();
				}
			}
			catch (Exception arg)
			{
				Debug.Log((object)$"LogClearBySize error: {arg}");
			}
		}

		public static string GetRelativeModFilePath(string fname)
		{
			return Path.Combine(modFolder, fname);
		}

		public static List<T> Shuffle<T>(IEnumerable<T> list)
		{
			if (list == null)
			{
				return new List<T>();
			}
			int num = list.Count();
			if (num <= 1)
			{
				return new List<T>(list);
			}
			List<T> list2 = new List<T>(list);
			for (int i = 0; i < num; i++)
			{
				T value = list2[i];
				int index = rnd.Next(num);
				list2[i] = list2[index];
				list2[index] = value;
			}
			return list2;
		}

		public static List<T> ShuffleForceRandom<T>(IEnumerable<T> list)
		{
			if (list == null)
			{
				return new List<T>();
			}
			int num = list.Count();
			if (num <= 1)
			{
				return new List<T>(list);
			}
			T[] array = new T[num];
			T[] array2 = list.ToArray();
			List<int> list2 = new List<int>(Enumerable.Range(0, num));
			for (int i = 0; i < num; i++)
			{
				List<int> list3 = new List<int>(list2);
				list3.Remove(i);
				if (list3.Count == 0)
				{
					break;
				}
				int num2 = list3[rnd.Next(list3.Count)];
				array[i] = array2[num2];
				list2.Remove(num2);
			}
			if (list2.Count == 1)
			{
				int num3 = num - 1;
				int num4 = rnd.Next(num3);
				array[num3] = array[num4];
				array[num4] = array2[num3];
			}
			return array.ToList();
		}
	}
}
namespace peak_bepinex.Wrappers
{
	public class CommandArgsReaderWrapper
	{
		private readonly IEnumerator<string> args;

		private readonly CommandArgsReader reader;

		public CommandArgsReaderWrapper(IEnumerable<string> args)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			this.args = args?.GetEnumerator();
			reader = new CommandArgsReader((ILogger)(object)Utils.logger);
		}

		public int ReadInt(int defaultValue = 0)
		{
			return reader.ReadInt(args, defaultValue);
		}

		public float ReadFloat(float defaultValue = 0f)
		{
			return reader.ReadFloat(args, defaultValue);
		}

		public string ReadString(string defaultValue = "")
		{
			return reader.ReadString(args, defaultValue);
		}

		public string ReadSpacedString(string defaultValue = "")
		{
			return ParseItemPath(reader.ReadString(args, defaultValue));
		}

		public string ReadAllAsSingleString(string separator = " ", string defaultValue = "")
		{
			if (args == null)
			{
				return defaultValue;
			}
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = true;
			while (args.MoveNext())
			{
				if (!flag && !string.IsNullOrEmpty(separator))
				{
					stringBuilder.Append(separator);
				}
				flag = false;
				stringBuilder.Append(args.Current);
			}
			string text = stringBuilder.ToString();
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return defaultValue;
		}

		public string[] ParseList(string s, string separator = "|")
		{
			if (string.IsNullOrEmpty(s))
			{
				return null;
			}
			return (from item in s.Split(new string[1] { separator }, StringSplitOptions.None)
				select item.Trim() into item
				where !string.IsNullOrWhiteSpace(item)
				select item).ToArray();
		}

		public static string ParseItemPath(string path)
		{
			return path?.Replace("_", " ");
		}

		public bool ReadBool(bool defaultValue = false)
		{
			return reader.ReadBool(args, defaultValue);
		}
	}
	public class LimitedLogWrapper : IDebugLogger, ILoggerWithConsole, ILogger
	{
		private readonly IDebugLogger logger;

		private int messagesLimit;

		public LimitedLogWrapper(int messagesLimit, IDebugLogger logger)
		{
			this.logger = logger;
			this.messagesLimit = messagesLimit;
		}

		public void Log(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILogger)logger).Log(obj);
			}
		}

		public void LogClear()
		{
			((ILogger)logger).LogClear();
		}

		public void LogDebugInfo(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				logger.LogDebugInfo(obj);
			}
		}

		public void LogDebugWarning(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				logger.LogDebugWarning(obj);
			}
		}

		public void LogDebugError(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				logger.LogDebugError(obj);
			}
		}

		public void LogInfo(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILogger)logger).LogInfo(obj);
			}
		}

		public void LogInfoConsoleOnly(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILoggerWithConsole)logger).LogInfoConsoleOnly(obj);
			}
		}

		public void LogInfoFileOnly(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILoggerWithConsole)logger).LogInfoFileOnly(obj);
			}
		}

		public void LogWarning(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILogger)logger).LogWarning(obj);
			}
		}

		public void LogWarningConsoleOnly(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILoggerWithConsole)logger).LogWarningConsoleOnly(obj);
			}
		}

		public void LogWarningFileOnly(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILoggerWithConsole)logger).LogWarningFileOnly(obj);
			}
		}

		public void LogError(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILogger)logger).LogError(obj);
			}
		}

		public void LogErrorConsoleOnly(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILoggerWithConsole)logger).LogErrorConsoleOnly(obj);
			}
		}

		public void LogErrorFileOnly(object obj)
		{
			if (messagesLimit > 0)
			{
				messagesLimit--;
				((ILoggerWithConsole)logger).LogErrorFileOnly(obj);
			}
		}

		public void UpdateLimit(int limit)
		{
			messagesLimit = limit;
		}
	}
}
namespace peak_bepinex.Patchers
{
	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.Services
{
	public class ChaosModNetwork : MonoBehaviour
	{
		public struct DataSource
		{
			public int playerID;

			public string eventID;

			public string username;

			public string lang;
		}

		private static ChaosModNetwork inst;

		private PhotonView photonView;

		private static Queue<DataSource> commandQueue;

		private static readonly HashSet<string> shouldBeRunFromHost = new HashSet<string>();

		private void Awake()
		{
			inst = this;
			photonView = ((Component)this).GetComponent<PhotonView>();
			commandQueue = new Queue<DataSource>();
		}

		[PunRPC]
		private void ActivateEventOtherRPC(string eventID)
		{
			((HelperLog)Utils.logger).LogInfo((object)("ChaosModNetwork->ActivateEventOtherRPC triggered for " + eventID));
		}

		[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
			{
				eventID = eventID,
				playerID = playerID,
				lang = lang,
				username = username
			});
		}

		public static void RequestEventOther(string eventID)
		{
			((HelperLog)Utils.logger).LogInfo((object)("ChaosModNetwork->RequestEventOther triggered for " + eventID));
			try
			{
				inst.photonView.RPC("ActivateEventOtherRPC", (RpcTarget)1, new object[1] { eventID });
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->RequestEventOther error: {arg}");
			}
		}

		public static void RequestClientEventRPC(int userID, string eventID, string lang, string username)
		{
			((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->RequestClientEventRPC triggered for {userID} {eventID}");
			try
			{
				inst.photonView.RPC("ActivateClientEventRPC", (RpcTarget)2, new object[4] { userID, eventID, lang, username });
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->RequestClientEventRPC error: {arg}");
			}
		}

		public static bool NeedRunFromHost(string eventID)
		{
			return shouldBeRunFromHost.Contains(eventID);
		}

		public static void ProcessNetworkEvents(ICommandManager cm, Dictionary<string, IInternalStandaloneCommand> commands)
		{
			while (commandQueue.Count > 0)
			{
				try
				{
					DataSource dataSource = commandQueue.Dequeue();
					((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->ProcessEvents event id {dataSource.eventID} for {dataSource.playerID}");
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->ProcessEvents: {arg}");
				}
			}
		}

		public static void RequestNotifyOtherRPC(string eventID, string lang, string username)
		{
			if (eventID.StartsWith("all_") || eventID.StartsWith("spawn_"))
			{
				try
				{
					inst.photonView.RPC("NotifyOtherRPC", (RpcTarget)1, new object[3] { eventID, lang, username });
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->RequestActivateNotifyRPC error: {arg}");
				}
				((HelperLog)Utils.logger).LogInfo((object)("ChaosModNetwork->RequestActivateNotifyRPC triggered for " + eventID));
			}
		}

		[PunRPC]
		private void NotifyOtherRPC(string eventID, string lang, string username)
		{
			((HelperLog)Utils.logger).LogInfo((object)("ChaosModNetwork->ActivateNotifyRPC triggered for " + eventID));
		}
	}
	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)(object)new LimitedLogWrapper(100, (IDebugLogger)(object)Utils.logger);

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

		public EventEmitter()
		{
			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 void RegisterSystemScheduleManager(ScheduleManager systemScheduleManager)
		{
			this.systemScheduleManager = systemScheduleManager;
		}

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

		public void RegisterEventEmitter(EventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}
	}
	public sealed class SettingsData
	{
	}
	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, newData);
				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.Commands
{
	internal class AddBonusStamina : IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "add_bonus_stamina";

		public bool Execute(IEnumerable<string> args)
		{
			float num = new CommandArgsReaderWrapper(args).ReadFloat();
			Character.localCharacter.AddExtraStamina(num);
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			float num = new CommandArgsReaderWrapper(args).ReadFloat();
			Character.localCharacter.AddStamina(num);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DamageOnMouseClick : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			float damage = commandArgsReaderWrapper.ReadFloat();
			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);
						}
					}
				}
			}, false);
			return true;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DamageOnJump : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			float damage = commandArgsReaderWrapper.ReadFloat();
			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);
						}
					}
				}
			}, false);
			return true;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class SlipperyPlayer : 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 : 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 = new CommandArgsReaderWrapper(args).ReadFloat();
			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 : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			float periodInSec = commandArgsReaderWrapper.ReadFloat();
			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 : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			float periodInSec = commandArgsReaderWrapper.ReadFloat();
			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 : 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 : 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(new CommandArgsReaderWrapper(args).ReadString());
			Character.localCharacter.refs.afflictions.SetStatus(val, 0f);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ClearPlayerStatuses : 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 : 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)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = commandArgsReaderWrapper.ReadFloat(1000f);
			int num2 = commandArgsReaderWrapper.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 : 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)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = commandArgsReaderWrapper.ReadFloat(1000f);
			int num2 = commandArgsReaderWrapper.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 : 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)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = commandArgsReaderWrapper.ReadFloat(1000f);
			int num2 = commandArgsReaderWrapper.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 : 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)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = commandArgsReaderWrapper.ReadFloat();
			float num2 = commandArgsReaderWrapper.ReadFloat();
			float num3 = commandArgsReaderWrapper.ReadFloat();
			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 = new CommandArgsReaderWrapper(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[2] { enable, randomDirection }).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 = MathUtility.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 : 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)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string name = commandArgsReaderWrapper.ReadString();
			float num = commandArgsReaderWrapper.ReadFloat();
			STATUSTYPE val = GameUtils.NameToPlayerStatusType(name);
			Character.localCharacter.refs.afflictions.AddStatus(val, num, false);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class RandomizeCustomization : 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 : IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "play_emote";

		public bool Execute(IEnumerable<string> args)
		{
			string text = new CommandArgsReaderWrapper(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 UtilityRandom.GetRandomItemFromList<string>((IList<string>)new string[8] { "A_Scout_Emote_Salute", "A_Scout_Emote_Dance1", "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 : 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 = new CommandArgsReaderWrapper(args).ReadFloat();
			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 : 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 = new CommandArgsReaderWrapper(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 : 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 = new CommandArgsReaderWrapper(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 = UtilityRandom.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 : 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)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = commandArgsReaderWrapper.ReadFloat(0.6f);
			float num2 = commandArgsReaderWrapper.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 : IInternalStandaloneCommand, IConsoleCommand
	{
		public string Id => "drop_item_in_hands";

		public bool Execute(IEnumerable<string> args)
		{
			return DropItem(new CommandArgsReaderWrapper(args).ReadFloat());
		}

		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 : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			float num = commandArgsReaderWrapper.ReadFloat();
			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 : 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 = new CommandArgsReaderWrapper(args).ReadFloat();
			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 : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			float modifierMove = commandArgsReaderWrapper.ReadFloat();
			float modifierClimb = commandArgsReaderWrapper.ReadFloat();
			float modifierRope = commandArgsReaderWrapper.ReadFloat();
			float modifierVine = commandArgsReaderWrapper.ReadFloat();
			string text = commandArgsReaderWrapper.ReadString();
			TimerTaskData val = 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(val, true);
			}
			else
			{
				ServiceProvider.inst.scheduleManager.AppendTimerTask(val, 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 : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			float num = commandArgsReaderWrapper.ReadFloat();
			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 : 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 = new CommandArgsReaderWrapper(args).ReadFloat();
			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 abstract class MouseInvertBase : IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		protected OffOnMode oldMouseMode;

		protected bool needStoreOldSettings = true;

		public abstract string Id { get; }

		public bool IsActive { get; private set; }

		protected abstract OffOnSetting SettingObject { get; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_003a: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_008f: Expected O, but got Unknown
			//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)
			float durationInSec = new CommandArgsReaderWrapper(args).ReadFloat(30f);
			OffOnSetting settingObject = SettingObject;
			if (needStoreOldSettings)
			{
				oldMouseMode = ((EnumSetting<OffOnMode>)(object)settingObject).Value;
				needStoreOldSettings = false;
			}
			ReflectionUtility.SetInternalProperty((object)settingObject, "Value", (object)Inverted(oldMouseMode));
			IsActive = true;
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					IsActive = false;
					ReflectionUtility.SetInternalProperty((object)SettingObject, "Value", (object)oldMouseMode);
					needStoreOldSettings = true;
				}
			}, true);
			return true;
		}

		private static OffOnMode Inverted(OffOnMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)mode == 1)
			{
				return (OffOnMode)0;
			}
			return (OffOnMode)1;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ChangeMouseSens : 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
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat(30f);
			float num = commandArgsReaderWrapper.ReadFloat(2.5f);
			float num2 = commandArgsReaderWrapper.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(new CommandArgsReaderWrapper(args).ReadAllAsSingleString());
			return true;
		}

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

		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_006a: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string s = commandArgsReaderWrapper.ReadAllAsSingleString();
			string[] array = commandArgsReaderWrapper.ParseList(s);
			if (array == null || array.Length == 0)
			{
				((HelperLog)Utils.logger).LogWarning((object)"GiveItem found empty item list");
			}
			if (!PhotonNetwork.IsConnected)
			{
				return false;
			}
			Character localCharacter = Character.localCharacter;
			string randomItemFromList = UtilityRandom.GetRandomItemFromList<string>((IList<string>)array);
			PhotonNetwork.Instantiate("0_Items/" + randomItemFromList, localCharacter.Head + Vector3.up, Quaternion.identity, (byte)0, (object[])null).GetComponent<Item>().RequestPickup(((Component)localCharacter).GetComponent<PhotonView>());
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ShufflePlayerMovement : IInternalStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private readonly string[] ways = new string[4] { "up", "down", "left", "right" };

		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 = new CommandArgsReaderWrapper(args).ReadFloat();
			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()
		{
			//IL_000e: 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)
			InputAction action_move = CharacterInput.action_move;
			List<InputBinding>[] array = new List<InputBinding>[4];
			foreach (InputBinding item in ((IEnumerable<InputBinding>)(object)action_move.bindings).Where((InputBinding b) => ways.Contains(((InputBinding)(ref b)).name)))
			{
				InputBinding bind = item;
				if (ways[0] == ((InputBinding)(ref bind)).name)
				{
					AddBind(array, 0, in bind);
				}
				else if (ways[1] == ((InputBinding)(ref bind)).name)
				{
					AddBind(array, 1, in bind);
				}
				else if (ways[2] == ((InputBinding)(ref bind)).name)
				{
					AddBind(array, 2, in bind);
				}
				else if (ways[3] == ((InputBinding)(ref bind)).name)
				{
					AddBind(array, 3, in bind);
				}
			}
			SwapBinds(action_move, array[0], array[1]);
			SwapBinds(action_move, array[2], array[3]);
			return true;
		}

		private void AddBind(List<InputBinding>[] bindings, int index, in InputBinding bind)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (bindings[index] == null)
			{
				bindings[index] = new List<InputBinding> { bind };
			}
			else
			{
				bindings[index].Add(bind);
			}
		}

		private void SwapBinds(InputAction action, List<InputBinding> bindList1, List<InputBinding> bindList2)
		{
			//IL_001f: 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_0027: 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_00e0: 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)
			if (bindList1 == null || bindList2 == null)
			{
				((HelperLog)Utils.logger).LogError((object)"SwapBinds got null bind list");
				return;
			}
			for (int i = 0; i < bindList1.Count && i < bindList2.Count; i++)
			{
				InputBinding val = bindList1[i];
				InputBinding val2 = bindList2[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(action, val);
				InputActionRebindingExtensions.ApplyBindingOverride(action, val2);
			}
		}

		private void RestoreInput()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			InputAction action_move = CharacterInput.action_move;
			InputBinding[] array = ((IEnumerable<InputBinding>)(object)action_move.bindings).Where((InputBinding b) => ways.Contains(((InputBinding)(ref b)).name)).ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				InputBinding val = array[i];
				((InputBinding)(ref val)).overridePath = null;
				((HelperLog)Utils.logger).LogInfo((object)("reset bind " + ((InputBinding)(ref val)).name + " to " + ((InputBinding)(ref val)).path));
				InputActionRebindingExtensions.ApplyBindingOverride(action_move, val);
			}
		}

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

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

		public bool Execute(IEnumerable<string> args)
		{
			//IL_004a: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			if (ServiceProvider.inst.scheduleManager.IsTaskExists(Id))
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " spams too much. Old teleport is not finished"));
				return true;
			}
			Character ch = Character.localCharacter;
			RespawnChest closestObject = GameUtils.GetClosestObject<RespawnChest>(ch.Center, (Func<RespawnChest, bool>)((RespawnChest obj) => obj.IsInteractible(ch)), needLog: true);
			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
	{
		[CompilerGenerated]
		private sealed class <TeleportPosFinder>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int triggerCount;

			public Character target;

			public TeleportToRandomPlayer <>4__this;

			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__6(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(Character.localCharacter, 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)
		{
			//IL_0063: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			if (!teleportEnds && (DateTime.Now - lastTriggerTime).TotalSeconds < 1.5)
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " spams too much. Old teleport is not finished"));
				return true;
			}
			teleportEnds = false;
			lastTriggerTime = DateTime.Now;
			ServiceProvider.inst.scheduleManager.NewTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = 0.5f,
				finishAction = delegate
				{
					//IL_0099: Unknown result type (might be due to invalid IL or missing references)
					Character[] source = GameUtils.AlivePlayers.ToArray();
					Character ch = Character.localCharacter;
					Character[] array = source.Where((Character p) => (Object)(object)p != (Object)(object)ch).ToArray();
					if (array.Length == 0)
					{
						((HelperLog)Utils.logger).LogWarning((object)(Id + " can't apply teleport, other players doesn't found"));
						teleportEnds = true;
					}
					else
					{
						Character randomItemFromList = UtilityRandom.GetRandomItemFromList<Character>((IList<Character>)array);
						((HelperLog)Utils.logger).LogInfo((object)$"{Id} found otherPlayers {array.Length}, target {randomItemFromList.characterName}, base pos {ch.data.groundPos}");
						((MonoBehaviour)ch).StartCoroutine(TeleportPosFinder(randomItemFromList, 60));
					}
				}
			}, false);
			return true;
		}

		[IteratorStateMachine(typeof(<TeleportPosFinder>d__6))]
		private IEnumerator TeleportPosFinder(Character target, int triggerCount)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TeleportPosFinder>d__6(0)
			{
				<>4__this = this,
				target = target,
				triggerCount = triggerCount
			};
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			if (ServiceProvider.inst.scheduleManager.IsTaskExists(Id))
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " spams too much. Old teleport is not finished"));
				return true;
			}
			ServiceProvider.inst.scheduleManager.NewTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = 1f,
				finishAction = delegate
				{
					//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)
					List<Character> list = GameUtils.AlivePlayers.ToList();
					if (list.Count <= 1)
					{
						((HelperLog)Utils.logger).LogWarning((object)(Id + " can't apply teleport, other players doesn't found"));
					}
					else
					{
						List<Vector3> list2 = Utils.ShuffleForceRandom(list.Select((Character p) => p.Center));
						((HelperLog)Utils.logger).LogInfo((object)$"{Id} found {list.Count} players and {list2.Count} positions");
						if (list2.Count != list.Count)
						{
							((HelperLog)Utils.logger).LogError((object)(Id + " wrong arr sizes"));
						}
						else
						{
							for (int i = 0; i < list.Count; i++)
							{
								Character player = list[i];
								Vector3 pos = list2[i];
								GameUtils.TeleportPlayer(player, in pos);
							}
						}
					}
				}
			}, false);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
}
namespace peak_bepinex.Commands.Interfaces
{
	public interface INetworkCommand : IConsoleCommand
	{
	}
	public interface IInternalStandaloneCommand : IConsoleCommand
	{
	}
	public interface IInternalStandaloneCommandWithData : IInternalStandaloneCommand, IConsoleCommand, IConsoleCommandWithData
	{
	}
	public interface IForceEnd : IInternalStand