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

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

		public string Cost { get; set; }

		public string EventID { get; set; }

		public string Lang { get; set; }

		public string ExtraInfo { get; set; }

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

		internal static readonly char clientAppSepChar = '&';

		internal static readonly string clientAppEqual = "=";

		internal static readonly char clientAppEqualChar = '=';

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

		string IEventsDataEncoderParams.ClientAppSep => clientAppSep;

		char IEventsDataEncoderParams.ClientAppSepChar => clientAppSepChar;

		string IEventsDataEncoderParams.ClientAppEqual => clientAppEqual;

		char IEventsDataEncoderParams.ClientAppEqualChar => clientAppEqualChar;

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

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

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

		public bool isLogInfoError = true;

		public bool isLogSkipEmpty;

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

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

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

		protected EventsData data;

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

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

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

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

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

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

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

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

		protected readonly IEventsDataParser parser;

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

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

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

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

		protected readonly float delay;

		protected float delayCounter;

		protected float initDelay;

		protected float initCounter;

		protected readonly float checkPeriod;

		protected float periodCounter;

		protected readonly Action<IEventsData> processEvent;

		protected readonly IEventsDataParser parser;

		protected IEnumerator<IEventsData> eventsData;

		protected readonly string path;

		private bool isDelayEveryProcessing;

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

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

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

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

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

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

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

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

		protected readonly Action<string> logError;

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

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

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

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

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

		string Cost { get; }

		string EventID { get; }

		string Lang { get; }

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

		char ClientAppSepChar { get; }

		string ClientAppEqual { get; }

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

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

		void SetEventID(string s);

		void SetCost(string s);

		void SetLang(string s);

		void SetExtraInfo(string s);

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

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

		bool IsProcessEnd();

		void ProcessAllWithDelayOnFrame(float dt);

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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using EventsIO;
using EventsIO.Interfaces;
using HarmonyLib;
using ModHelper;
using ModHelper.Interfaces;
using ModHelperUnity;
using Newtonsoft.Json;
using Photon.Pun;
using REPO_BFT_BepInEx.Commands.Interfaces;
using REPO_BFT_BepInEx.Patchers;
using REPO_BFT_BepInEx.Services;
using REPO_BFT_BepInEx.Wrappers;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using WebSocketIO;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("REPO BepInEx version")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("BFT LLC")]
[assembly: AssemblyProduct("ChaosTricksMod")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("BFT")]
[assembly: ComVisible(false)]
[assembly: Guid("482A702C-A19B-425E-8DCC-FE9C62D172B0")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.3.0.0")]
namespace REPO_BFT_BepInEx
{
	[BepInPlugin("bft.chaostricks", "Chaos Tricks", "1.3.0")]
	public 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.3.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.3.0", arg));
			}
		}
	}
	public sealed class InteractiveMod : MonoBehaviour
	{
		internal static InteractiveMod inst;

		internal const string MOD_VERSION = "1.3.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 CommandListArgManager commandListArgManager = new CommandListArgManager();

		private UtilityConsole console;

		private ChaosEnemySpawner enemySpawner;

		private Dictionary<string, IRepoStandaloneCommand> commands;

		private TranslationService translationService;

		private LimitedLogWrapper limitedLogger;

		private LimitedLogWrapper limitedSceneLogger;

		private bool isAppConnected;

		private bool isAppConnectedProcessed = true;

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

		private static bool msgType;

		private bool isLevelGeneratedLastCheck;

		private bool isMenuLevelLastCheck;

		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.3.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();
		}

		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();
			commandListArgManager = new CommandListArgManager();
			serviceProvider.RegisterCommandListArgManager(commandListArgManager);
			commandListArgManager.LoadCommandsList();
			ChaosItemManager chaosItemManager = new ChaosItemManager();
			serviceProvider.RegisterItemManager(chaosItemManager);
			chaosItemManager.LoadAllObjects();
			enemySpawner = new ChaosEnemySpawner();
			serviceProvider.RegisterEnemySpawner(enemySpawner);
		}

		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);
			eventsReader.InitDefaultSocket(Utils.modFolder, "chaostricks_repo", 13715, "127.0.0.1");
			eventsReader.OnOpen = delegate
			{
				isAppConnected = true;
				isAppConnectedProcessed = false;
			};
			eventsReader.OnCloseOnlyAfterConnect = delegate
			{
				isAppConnected = false;
				isAppConnectedProcessed = false;
			};
			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(IRepoStandaloneCommand);
			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, IRepoStandaloneCommand>();
			foreach (Type item2 in enumerable)
			{
				IRepoStandaloneCommand repoStandaloneCommand = Activator.CreateInstance(item2) as IRepoStandaloneCommand;
				if (repoStandaloneCommand != null)
				{
					console.RegisterCommand((IConsoleCommand)repoStandaloneCommand);
					if (commands.ContainsKey(((IConsoleCommand)repoStandaloneCommand).Id))
					{
						((HelperLog)logger).LogWarning((object)("repeated id command " + ((IConsoleCommand)repoStandaloneCommand).Id + ". The command will replace existed."));
					}
					commands[((IConsoleCommand)repoStandaloneCommand).Id] = repoStandaloneCommand;
					if (repoStandaloneCommand is IForceEnd item)
					{
						forceEndEvents.Add(item);
					}
					((HelperLog)logger).LogInfo((object)("init command '" + ((IConsoleCommand)repoStandaloneCommand).Id + "' complete"));
				}
				else
				{
					((HelperLog)logger).LogError((object)("init command '" + ((IConsoleCommand)repoStandaloneCommand).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;
			}
			if (!GameUtils.IsMaster && ChaosModNetwork.NeedRunFromHost(eventID))
			{
				((HelperLog)logger).LogInfo((object)("Try to execute network event: '" + eventID + "'"));
				ChaosModNetwork.RequestClientEventRPC(GameUtils.LocalPlayer.photonView.ViewID, eventID);
				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"));
					string trans = translationService.translation.GetTrans(data.EventID, data.Lang);
					string trans2 = translationService.translation.GetTrans("%template_msg%", data.Lang);
					string message = data.Username + " " + trans2 + " '" + trans + "'";
					GameUtils.SendTruckChatMessage(message);
					GameUtils.ShowUIMessage(message);
					msgType = !msgType;
				}
				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 OnLevelGenerated()
		{
			try
			{
				((HelperLog)Utils.logger).LogInfo((object)"OnLevelGenerated triggered");
				SemiFunc_EnemySpawnPatcher.ClearBlockEnemies();
				enemySpawner?.ClearSpawnedEnemies();
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"OnLevelGenerated {arg}");
			}
		}

		private void OnMenuLevel()
		{
			try
			{
				((HelperLog)Utils.logger).LogInfo((object)"OnMenuLevel triggered");
				ChaosInputManager.UnblockAll();
				ChaosInputManager.UnholdAll();
				SemiFunc_EnemySpawnPatcher.ClearBlockEnemies();
				enemySpawner?.ClearSpawnedEnemies();
				foreach (IForceEnd forceEndEvent in forceEndEvents)
				{
					try
					{
						forceEndEvent.ForceEnd();
					}
					catch (Exception arg)
					{
						((HelperLog)Utils.logger).LogError((object)$"OnMenuLevel force end for {((IConsoleCommand)forceEndEvent).Id} error: {arg}");
					}
				}
			}
			catch (Exception arg2)
			{
				((HelperLog)Utils.logger).LogError((object)$"OnMenuLevel {arg2}");
			}
		}

		private bool IsReadyForCheckEvent()
		{
			try
			{
				bool generated = LevelGenerator.Instance.Generated;
				if (generated != isLevelGeneratedLastCheck && generated)
				{
					OnLevelGenerated();
				}
				isLevelGeneratedLastCheck = generated;
				bool flag = SemiFunc.MenuLevel();
				if (flag != isMenuLevelLastCheck && flag)
				{
					OnMenuLevel();
				}
				isMenuLevelLastCheck = flag;
				if (!generated || flag)
				{
					return false;
				}
				try
				{
					if (!GameUtils.AnyPlayerAlive())
					{
						return false;
					}
				}
				catch (Exception arg)
				{
					limitedLogger.LogError($"IsReadyForCheckEvent alive check error: {arg}");
				}
				return true;
			}
			catch (Exception arg2)
			{
				limitedLogger.LogError($"IsReadyForCheckEvent error: {arg2}");
			}
			return false;
		}

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

		internal void ReinitMod()
		{
			try
			{
				((HelperLog)logger).LogInfo((object)"ReinitMod starts");
				FlushLog();
				OnMenuLevel();
				commandListArgManager.LoadCommandsList();
				InitCommands(needValidate: false);
				((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);
		}
	}
	internal static class CoroutineUtils
	{
		[CompilerGenerated]
		private sealed class <ActionCoroutine>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float delayInSec;

			public Action action;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (delayInSec == 0f)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(delayInSec);
					<>1__state = 2;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				try
				{
					action();
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ActionCoroutine for {delayInSec} error: {arg}");
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public int delayInFrames;

			public Action action;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (delayInFrames > 0)
				{
					int num = delayInFrames - 1;
					delayInFrames = num;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				try
				{
					action();
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ActionCoroutineInFrames for {delayInFrames} error: {arg}");
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public float repeatDelayInSec;

			public Func<bool> action;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					bool flag;
					try
					{
						flag = action();
					}
					catch (Exception arg)
					{
						((HelperLog)Utils.logger).LogError((object)$"ActionCoroutine for {repeatDelayInSec} error: {arg}");
						flag = false;
					}
					if (!flag)
					{
						return false;
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = (object)new WaitForSeconds(repeatDelayInSec);
				<>1__state = 1;
				return true;
			}

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

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

		internal static void StartCoroutine(MonoBehaviour script, float delayInSec, Action action)
		{
			if ((Object)(object)script == (Object)null)
			{
				return;
			}
			if (action == null)
			{
				((HelperLog)Utils.logger).LogError((object)"StartCoroutine got null action");
				return;
			}
			if (delayInSec < 0f)
			{
				delayInSec = 0f;
				((HelperLog)Utils.logger).LogWarning((object)$"StartCoroutine got invalid delay {delayInSec}");
			}
			script.StartCoroutine(ActionCoroutine(delayInSec, action));
		}

		[IteratorStateMachine(typeof(<ActionCoroutine>d__1))]
		private static IEnumerator ActionCoroutine(float delayInSec, Action action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ActionCoroutine>d__1(0)
			{
				delayInSec = delayInSec,
				action = action
			};
		}

		internal static void StartCoroutineInFrames(MonoBehaviour script, int delayInFrames, Action action)
		{
			if ((Object)(object)script == (Object)null)
			{
				return;
			}
			if (action == null)
			{
				((HelperLog)Utils.logger).LogError((object)"StartCoroutineInFrames got null action");
				return;
			}
			if (delayInFrames <= 0)
			{
				((HelperLog)Utils.logger).LogWarning((object)$"StartCoroutineInFrames got invalid delay in frames {delayInFrames}. Replaced to 1.");
				delayInFrames = 1;
			}
			script.StartCoroutine(ActionCoroutineInFrames(delayInFrames, action));
		}

		[IteratorStateMachine(typeof(<ActionCoroutineInFrames>d__3))]
		private static IEnumerator ActionCoroutineInFrames(int delayInFrames, Action action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ActionCoroutineInFrames>d__3(0)
			{
				delayInFrames = delayInFrames,
				action = action
			};
		}

		internal static void StartCoroutineWhile(MonoBehaviour script, float repeatDelayInSec, Func<bool> action)
		{
			if ((Object)(object)script == (Object)null)
			{
				return;
			}
			if (action == null)
			{
				((HelperLog)Utils.logger).LogError((object)"StartCoroutine got null action");
				return;
			}
			if (repeatDelayInSec < 0f)
			{
				repeatDelayInSec = 0f;
				((HelperLog)Utils.logger).LogWarning((object)$"StartCoroutine got invalid delay {repeatDelayInSec}");
			}
			script.StartCoroutine(WhileCoroutine(repeatDelayInSec, action));
		}

		[IteratorStateMachine(typeof(<WhileCoroutine>d__5))]
		private static IEnumerator WhileCoroutine(float repeatDelayInSec, Func<bool> action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WhileCoroutine>d__5(0)
			{
				repeatDelayInSec = repeatDelayInSec,
				action = action
			};
		}
	}
	internal static class GameUtils
	{
		internal struct Coords
		{
			public Vector3 pos;

			public Quaternion rot;
		}

		internal static PlayerAvatar LocalPlayer
		{
			get
			{
				PlayerController instance = PlayerController.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return null;
				}
				return instance.playerAvatarScript;
			}
		}

		internal static IEnumerable<PlayerAvatar> Players => from p in SemiFunc.PlayerGetAll()
			where (Object)(object)p != (Object)null
			select p;

		internal static List<PlayerAvatar> AlivePlayers => Players.Where(IsPlayerAlive).ToList();

		internal static List<PlayerAvatar> DeadPlayers => Players.Where(IsPlayerDead).ToList();

		internal static bool IsMaster
		{
			get
			{
				if (GameManager.Multiplayer())
				{
					return PhotonNetwork.IsMasterClient;
				}
				return true;
			}
		}

		internal static Vector3 GetPlayerForward(float length = 1f)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return GetPlayerForward(((Component)LocalPlayer).transform, length);
		}

		internal static Vector3 GetForwardOffset(float length = 1f, float height = 0.5f)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return GetForwardOffset(((Component)LocalPlayer).transform, length, height);
		}

		internal static Vector3 GetPlayerForward(Transform tr, float length = 1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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)
			Vector3 position = tr.position;
			Vector3 forward = tr.forward;
			return position + ((Vector3)(ref forward)).normalized * length;
		}

		internal static Vector3 GetForwardOffset(Transform tr, float length = 1f, float height = 0.5f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Vector3 forward = tr.forward;
			return ((Vector3)(ref forward)).normalized * length + new Vector3(0f, height, 0f);
		}

		internal static void SetHealthPercentage(PlayerAvatar player, float percents, bool keepAlive)
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if (percents < 0f)
			{
				percents = 0f;
				((HelperLog)Utils.logger).LogWarning((object)"SetHealth got negative percents value");
			}
			if ((Object)(object)player == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"SetHealth got null player");
				return;
			}
			if ((Object)(object)player.playerHealth == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"SetHealth playerHealth null");
				return;
			}
			if (!((Behaviour)player.playerHealth).enabled)
			{
				((HelperLog)Utils.logger).LogWarning((object)"SetHealth playerHealth disabled");
			}
			int playerMaxHealth = GetPlayerMaxHealth(player.playerHealth);
			int playerHealth = GetPlayerHealth(player.playerHealth);
			int num = (int)Math.Ceiling((float)playerMaxHealth * (percents / 100f));
			if (keepAlive && num <= 0)
			{
				num = 1;
			}
			if (playerHealth != num)
			{
				if (playerHealth < num)
				{
					int num2 = num - playerHealth;
					((HelperLog)Utils.logger).LogInfo((object)$"SetHealth calc playerHealth heal: {num2} from {playerHealth} to {num} with keep alive {keepAlive}");
					player.playerHealth.HealOther(num2, true);
				}
				else
				{
					int num3 = playerHealth - num;
					((HelperLog)Utils.logger).LogInfo((object)$"SetHealth calc playerHealth damage: {num3} from {playerHealth} to {num} with kill {keepAlive}");
					player.playerHealth.HurtOther(num3, Vector3.zero, false, -1);
				}
			}
		}

		internal static void SetHealthAmount(PlayerAvatar player, int amount, bool keepAlive)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (amount < 0)
			{
				((HelperLog)Utils.logger).LogWarning((object)"SetHealthAmount got negative amount value");
				return;
			}
			if ((Object)(object)player == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"SetHealthAmount got null player");
				return;
			}
			if ((Object)(object)player.playerHealth == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"SetHealthAmount playerHealth null");
				return;
			}
			if (!((Behaviour)player.playerHealth).enabled)
			{
				((HelperLog)Utils.logger).LogWarning((object)"SetHealthAmount playerHealth disabled");
			}
			int playerHealth = GetPlayerHealth(player.playerHealth);
			if (playerHealth == amount)
			{
				return;
			}
			if (playerHealth < amount)
			{
				int num = amount - playerHealth;
				((HelperLog)Utils.logger).LogInfo((object)$"SetHealthAmount calc playerHealth heal: {num} from {playerHealth} to {amount}");
				player.playerHealth.HealOther(num, true);
				return;
			}
			int num2 = amount;
			if (keepAlive && num2 <= 0)
			{
				num2 = 1;
			}
			int num3 = playerHealth - num2;
			((HelperLog)Utils.logger).LogInfo((object)$"SetHealthAmount calc playerHealth damage: {num3} from {playerHealth} to {num2}");
			player.playerHealth.HurtOther(num3, Vector3.zero, false, -1);
		}

		internal static string GetPlayerName(PlayerAvatar player)
		{
			return Traverse.Create((object)player).Field("playerName").GetValue<string>() ?? "";
		}

		internal static int GetPlayerMaxHealth(PlayerHealth health)
		{
			return Traverse.Create((object)health).Field("maxHealth").GetValue<int>();
		}

		internal static int GetPlayerHealth(PlayerHealth health)
		{
			return Traverse.Create((object)health).Field("health").GetValue<int>();
		}

		internal static bool IsPlayerDead(PlayerAvatar p)
		{
			return Traverse.Create((object)p).Field("isDisabled").GetValue<bool>();
		}

		internal static bool IsPlayerAlive(PlayerAvatar p)
		{
			return !IsPlayerDead(p);
		}

		internal static int GetAlivePlayersCount()
		{
			return Players.Select(IsPlayerAlive).Count();
		}

		internal static bool AnyPlayerAlive()
		{
			return Players.Any(IsPlayerAlive);
		}

		internal static List<PlayerAvatar> GetAlivePlayerEventTargets(bool isMultiplayer)
		{
			if (isMultiplayer)
			{
				return AlivePlayers;
			}
			if (IsPlayerAlive(LocalPlayer))
			{
				return new List<PlayerAvatar> { LocalPlayer };
			}
			return new List<PlayerAvatar>();
		}

		internal static List<PlayerAvatar> GetDeadPlayerEventTargets(bool isMultiplayer)
		{
			if (isMultiplayer)
			{
				return DeadPlayers;
			}
			if (IsPlayerDead(LocalPlayer))
			{
				return new List<PlayerAvatar> { LocalPlayer };
			}
			return new List<PlayerAvatar>();
		}

		internal static List<PlayerAvatar> GetPlayerEventTargets(bool isMultiplayer)
		{
			if (isMultiplayer)
			{
				return Players.ToList();
			}
			return new List<PlayerAvatar> { LocalPlayer };
		}

		internal static bool IsLocalPlayer(PlayerAvatar player)
		{
			if (GameManager.Multiplayer() && !((Object)(object)player.photonView == (Object)null))
			{
				return player.photonView.IsMine;
			}
			return true;
		}

		internal static void TeleportPlayer(PlayerAvatar player, Vector3 pos, Quaternion rot)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (IsLocalPlayer(player))
			{
				PlayerController instance = PlayerController.instance;
				instance.Kinematic(0.5f);
				instance.InputDisable(0.5f);
				instance.CollisionController.ResetFalling();
				instance.VelocityRelative = Vector3.zero;
				instance.Velocity = Vector3.zero;
				Traverse.Create((object)instance).Field<bool>("VelocityIdle").Value = true;
				CoroutineUtils.StartCoroutine((MonoBehaviour)(object)instance, 0.2f, delegate
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					player.Spawn(pos, rot);
				});
			}
			else
			{
				player.Spawn(pos, rot);
			}
		}

		internal static GameObject SpawnItem(string name, Vector3 spawnPos, Quaternion rot, bool needLog = true)
		{
			//IL_005e: 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_00b6: 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)
			ChaosItemManager.SpawnItem spawnItem = ServiceProvider.inst.itemManager.GetSpawnItem(name);
			if (SemiFunc.IsMasterClient())
			{
				if (needLog)
				{
					((HelperLog)Utils.logger).LogInfo((object)("master network spawn item '" + spawnItem.name + "'"));
				}
				if (string.IsNullOrEmpty(spawnItem.name))
				{
					((HelperLog)Utils.logger).LogError((object)"master network spawn item invalid path");
					return null;
				}
				return PhotonNetwork.InstantiateRoomObject(spawnItem.path, spawnPos, rot, (byte)0, (object[])null);
			}
			if (!SemiFunc.IsMultiplayer())
			{
				if (needLog)
				{
					((HelperLog)Utils.logger).LogInfo((object)("single mode spawn item '" + spawnItem.name + "'"));
				}
				if ((Object)(object)spawnItem.prefab == (Object)null)
				{
					((HelperLog)Utils.logger).LogError((object)"single mode spawn item invalid prefab");
					return null;
				}
				return Object.Instantiate<GameObject>(spawnItem.prefab, spawnPos, rot);
			}
			return null;
		}

		internal static void RegisterItemInGame(string assetName)
		{
			if (string.IsNullOrEmpty(assetName) || !assetName.StartsWith("Item "))
			{
				return;
			}
			StatsManager instance = StatsManager.instance;
			Dictionary<string, Item> itemDictionary = instance.itemDictionary;
			if (itemDictionary != null && itemDictionary.ContainsKey(assetName))
			{
				((HelperLog)Utils.logger).LogInfo((object)"register item");
				if (instance.itemsPurchased.TryGetValue(assetName, out var value))
				{
					instance.itemsPurchased[assetName] = value + 1;
				}
				else
				{
					instance.itemsPurchased[assetName] = 1;
				}
				if (instance.itemsPurchasedTotal.TryGetValue(assetName, out var value2))
				{
					instance.itemsPurchasedTotal[assetName] = value2 + 1;
				}
				else
				{
					instance.itemsPurchasedTotal[assetName] = 1;
				}
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)"registering item in game is skipped");
			}
		}

		internal static void ChargeItem(GameObject obj, float delayInSec, int amount)
		{
			if (!((Object)(object)obj == (Object)null))
			{
				ItemBattery battery = obj.GetComponentInParent<ItemBattery>();
				CoroutineUtils.StartCoroutine((MonoBehaviour)(object)battery, delayInSec, delegate
				{
					int num = amount;
					bool flag = true;
					Traverse obj2 = Traverse.Create((object)battery);
					_ = obj2.Field<PhotonView>("photonView").Value;
					obj2.Method("BatteryFullPercentChange", new object[2] { num, flag }).GetValue();
				});
			}
		}

		internal static T GetRandomLevelPoint<T>(IEnumerable<T> points, T lastUsedPoint, bool useLastUsedPointIfNoOthers = true, bool needLog = true)
		{
			HashSet<T> pointsToIgnore = new HashSet<T> { lastUsedPoint };
			T randomLevelPoint = GetRandomLevelPoint(points, pointsToIgnore, needLog);
			if (randomLevelPoint == null && useLastUsedPointIfNoOthers)
			{
				return lastUsedPoint;
			}
			return randomLevelPoint;
		}

		internal static T GetRandomLevelPoint<T>(IEnumerable<T> points, HashSet<T> pointsToIgnore, bool needLog = true)
		{
			List<T> list = points.Where((T p) => p != null && !pointsToIgnore.Contains(p)).ToList();
			if (list.Count == 0)
			{
				if (needLog)
				{
					((HelperLog)Utils.logger).LogError((object)"can't find points");
				}
				return default(T);
			}
			if (needLog)
			{
				((HelperLog)Utils.logger).LogInfo((object)$"found {list.Count()} valid points of total {points.Count()}");
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			return UtilityRandom.GetRandomItemFromList<T>((IList<T>)list);
		}

		internal static GameObject GetClosestObjectByTag(Vector3 pos, string tag, Func<GameObject, bool> filter, bool needLog = true)
		{
			//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_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_0096: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (tag == null)
			{
				return null;
			}
			GameObject[] array = GameObject.FindGameObjectsWithTag(tag);
			int num = array.Length;
			if (needLog)
			{
				((HelperLog)Utils.logger).LogInfo((object)$"GetClosestObjectByTag {tag} found {num}");
			}
			if (num == 0)
			{
				return null;
			}
			if (filter != null)
			{
				array = array.Where(filter).ToArray();
				num = array.Length;
				if (needLog)
				{
					((HelperLog)Utils.logger).LogInfo((object)$"GetClosestObjectByTag filtered size {num}");
				}
			}
			if (num == 1)
			{
				return array[0];
			}
			GameObject val = array[0];
			Vector3 val2 = pos - val.transform.position;
			float num2 = ((Vector3)(ref val2)).sqrMagnitude;
			for (int i = 1; i < num; i++)
			{
				GameObject val3 = array[i];
				val2 = pos - val3.transform.position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num2)
				{
					val = val3;
					num2 = sqrMagnitude;
				}
			}
			return val;
		}

		internal static ValuableObject GetClosestValuableObject(Vector3 pos, Func<ValuableObject, bool> filter, bool needLog = true)
		{
			//IL_0069: 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_0075: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			ValuableObject[] array = Object.FindObjectsOfType<ValuableObject>();
			int num = array.Length;
			if (needLog)
			{
				((HelperLog)Utils.logger).LogInfo((object)$"GetClosestValuableObject found {num}");
			}
			if (num == 0)
			{
				return null;
			}
			if (filter != null)
			{
				array = array.Where(filter).ToArray();
				num = array.Length;
				if (needLog)
				{
					((HelperLog)Utils.logger).LogInfo((object)$"GetClosestValuableObject filtered size {num}");
				}
			}
			if (num == 1)
			{
				return array[0];
			}
			ValuableObject val = array[0];
			Vector3 val2 = pos - ((Component)val).transform.position;
			float num2 = ((Vector3)(ref val2)).sqrMagnitude;
			for (int i = 1; i < num; i++)
			{
				ValuableObject val3 = array[i];
				val2 = pos - ((Component)val3).transform.position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num2)
				{
					val = val3;
					num2 = sqrMagnitude;
				}
			}
			return val;
		}

		internal static GameObject GetClosestCart(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetClosestObjectByTag(pos, "Cart", (GameObject item) => (Object)(object)item.GetComponentInParent<PhysGrabCart>() != (Object)null);
		}

		internal static GameObject[] GetObjectsByTag(string tag, Func<GameObject, bool> filter, bool needLog = true)
		{
			if (tag == null)
			{
				return (GameObject[])(object)new GameObject[0];
			}
			GameObject[] array = GameObject.FindGameObjectsWithTag(tag);
			int num = array.Length;
			if (needLog)
			{
				((HelperLog)Utils.logger).LogInfo((object)$"GetObjectsByTag found {num}");
			}
			if (num == 0)
			{
				return (GameObject[])(object)new GameObject[0];
			}
			if (filter != null)
			{
				array = array.Where(filter).ToArray();
				num = array.Length;
				if (needLog)
				{
					((HelperLog)Utils.logger).LogInfo((object)$"GetObjectsByTag filtered size {num}");
				}
			}
			return array;
		}

		internal static GameObject[] GetCarts()
		{
			return GetObjectsByTag("Cart", (GameObject item) => (Object)(object)item.GetComponentInParent<PhysGrabCart>() != (Object)null);
		}

		internal static List<CartObject> GetCartItems(GameObject cart)
		{
			PhysGrabCart componentInParent = cart.GetComponentInParent<PhysGrabCart>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"can't find PhysGrabCart");
				return null;
			}
			if ((Object)(object)componentInParent.physGrabInCart == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"can't find PhysGrabCart");
				return null;
			}
			List<CartObject> value = Traverse.Create((object)componentInParent.physGrabInCart).Field<List<CartObject>>("inCartObjects").Value;
			if (value == null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"inCartObjects null");
				return null;
			}
			return value;
		}

		internal static Enemy[] GetEnemies()
		{
			return Object.FindObjectsOfType<Enemy>();
		}

		internal static Enemy GetClosestEnemy(Vector3 pos)
		{
			//IL_0035: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Enemy[] array = Object.FindObjectsOfType<Enemy>();
			int num = array.Length;
			((HelperLog)Utils.logger).LogInfo((object)$"found {num} enemies");
			switch (num)
			{
			case 0:
				return null;
			case 1:
				return array[0];
			default:
			{
				Enemy val = array[0];
				Vector3 val2 = pos - ((Component)val).transform.position;
				float num2 = ((Vector3)(ref val2)).sqrMagnitude;
				for (int i = 1; i < num; i++)
				{
					Enemy val3 = array[i];
					val2 = pos - ((Component)val3).transform.position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num2)
					{
						val = val3;
						num2 = sqrMagnitude;
					}
				}
				return val;
			}
			}
		}

		internal static void ActivateTumble(PlayerTumble tumble, PlayerAvatar p, Vector3 force, float rotatePower)
		{
			//IL_0001: 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)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			tumble.TumbleForce(force);
			tumble.TumbleTorque(((Component)tumble).transform.right * rotatePower);
			try
			{
				Traverse.Create((object)tumble).Method("BreakFree", new object[1] { p.localCameraTransform.forward }).GetValue();
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"BreakFree error: {arg}");
			}
			tumble.TumbleSet(true, false);
		}

		internal static ExtractionPoint GetCurrentExtractionPoint()
		{
			return Traverse.Create((object)RoundDirector.instance).Field<ExtractionPoint>("extractionPointCurrent").Value;
		}

		internal static Dictionary<RoomVolume, List<LevelPoint>> GetLevelPointsByRoom(bool excludePlayerRooms)
		{
			Dictionary<RoomVolume, List<LevelPoint>> dictionary = new Dictionary<RoomVolume, List<LevelPoint>>();
			List<LevelPoint> list = SemiFunc.LevelPointsGetAll();
			List<LevelPoint> list2 = (excludePlayerRooms ? SemiFunc.LevelPointsGetInPlayerRooms() : new List<LevelPoint>());
			if (list == null)
			{
				return dictionary;
			}
			foreach (LevelPoint item in list)
			{
				if (!((Object)(object)item == (Object)null) && (!excludePlayerRooms || !list2.Contains(item)))
				{
					if (!dictionary.TryGetValue(item.Room, out var value))
					{
						value = new List<LevelPoint>();
						dictionary[item.Room] = value;
					}
					value.Add(item);
				}
			}
			return dictionary;
		}

		internal static List<LevelPoint> GetLevelPoints(bool excludePlayerRooms)
		{
			List<LevelPoint> list = SemiFunc.LevelPointsGetAll();
			if (excludePlayerRooms)
			{
				List<LevelPoint> playerRoomPoints = SemiFunc.LevelPointsGetInPlayerRooms();
				return list.Where((LevelPoint p) => !playerRoomPoints.Contains(p)).ToList();
			}
			return list;
		}

		internal static Vector3 GetPlayerSpawnPoint()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)Object.FindFirstObjectByType<SpawnPoint>()).transform.position;
		}

		internal static Vector3[] GetPlayerSpawnPoints()
		{
			return (from p in Object.FindObjectsOfType<SpawnPoint>()
				where (Object)(object)((Component)p).transform != (Object)null
				select ((Component)p).transform.position).ToArray();
		}

		internal static Vector3 GetFreeOfPlayersFarPointFrom(Vector3 start)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			List<LevelPoint> levelPoints = GetLevelPoints(excludePlayerRooms: true);
			Vector3 result = start;
			float num = 0f;
			foreach (LevelPoint item in levelPoints)
			{
				Vector3 val = ((Component)item).transform.position - start;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude > num)
				{
					num = sqrMagnitude;
					result = ((Component)item).transform.position;
				}
			}
			return result;
		}

		public static Vector3 GetClosestSpawnPointTo(Vector3 start)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			List<LevelPoint> levelPoints = GetLevelPoints(excludePlayerRooms: true);
			Vector3 result = start;
			float num = float.MaxValue;
			foreach (LevelPoint item in levelPoints)
			{
				Vector3 val = ((Component)item).transform.position - start;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					result = ((Component)item).transform.position;
				}
			}
			return result;
		}

		internal static void SendTruckChatMessage(string message)
		{
			TruckScreenText instance = TruckScreenText.instance;
			if ((Object)(object)instance == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"TruckScreenText null");
			}
			else
			{
				instance.MessageSendCustom("", "{arrowright}" + message + "{arrowleft}", 0);
			}
		}

		internal static void SendPlayerTTS(string message, bool crouching)
		{
			PlayerAvatar localPlayer = LocalPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				Traverse.Create((object)localPlayer).Method("ChatMessageSpeak", new object[2] { message, crouching }).GetValue();
			}
		}

		internal static void ShowUIMessage(string message)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			MissionUI instance = MissionUI.instance;
			if ((Object)(object)instance == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"MissionUI null");
			}
			else
			{
				instance.MissionText(message, Color.magenta, Color.magenta, 5f);
			}
		}
	}
	internal static class Utils
	{
		internal static readonly Random rnd = new Random(Guid.NewGuid().GetHashCode());

		internal 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");

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

		internal static void LogClearBySize()
		{
			FileInfo fileInfo = new FileInfo(logPath);
			if (fileInfo.Exists && fileInfo.Length > 200000)
			{
				((HelperLog)logger).LogClear();
			}
		}

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

		internal 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;
		}

		internal 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();
		}

		internal static float GetRandomBetween(float min, float max)
		{
			return min + (float)((double)(max - min) * rnd.NextDouble());
		}
	}
}
namespace REPO_BFT_BepInEx.Services
{
	internal class ChaosEnemySpawner
	{
		internal struct EnemyData
		{
			public GameObject prefab;

			public string name;

			public string path;
		}

		private const string BASE_ENEMY_PATH = "Enemies/Enemy - ";

		private readonly Dictionary<string, EnemyData> enemyPrefabs = new Dictionary<string, EnemyData>();

		private int spawnedCount;

		private readonly List<EnemyParent> spawnedEnemies = new List<EnemyParent>();

		private float spawnsCheckInSec;

		internal void RegisterSpawnedEnemyFinished(Enemy enemy)
		{
			CoroutineUtils.StartCoroutine((MonoBehaviour)(object)enemy, 0f, delegate
			{
				EnemyParent componentInParent = ((Component)enemy).GetComponentInParent<EnemyParent>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					((HelperLog)Utils.logger).LogWarning((object)"EnemyParent null. Fix despawning is skipped");
				}
				else
				{
					spawnedEnemies.Add(componentInParent);
				}
			});
		}

		internal void ClearSpawnedEnemies()
		{
			spawnedEnemies.Clear();
		}

		internal void OnUpdate(float dtInSec)
		{
			spawnsCheckInSec -= dtInSec;
			if (spawnsCheckInSec > 0f)
			{
				return;
			}
			spawnsCheckInSec = 0.5f;
			foreach (EnemyParent spawnedEnemy in spawnedEnemies)
			{
				if ((Object)(object)spawnedEnemy != (Object)null && spawnedEnemy.DespawnedTimer > 0f)
				{
					spawnedEnemy.DespawnedTimer = 60f;
				}
			}
		}

		internal Enemy SpawnEnemy(string enemyName, Vector3 spawnPoint)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(enemyName))
			{
				((HelperLog)Utils.logger).LogError((object)"SpawnEnemy invalid name");
				return null;
			}
			EnemyData enemyPrefab = GetEnemyPrefab(enemyName);
			GameObject prefab = enemyPrefab.prefab;
			if ((Object)(object)prefab == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)("SpawnEnemy can't find enemy prefab: path '" + enemyPrefab.path + "', name '" + enemyName + "'"));
				return null;
			}
			RunManager.instance.EnemiesSpawnedRemoveStart();
			Enemy val = LevelGeneratorEnemySpawn(prefab, enemyPrefab.path, spawnPoint);
			if ((Object)(object)val == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"ChaosEnemySpawner->SpawnEnemy Enemy component is null");
			}
			else
			{
				((Object)val).name = $"Chaos Tricks custom mob [{enemyName}] [{spawnedCount++}]";
				foreach (PlayerAvatar player in GameUtils.Players)
				{
					val.PlayerAdded(player.photonView.ViewID);
				}
			}
			SemiFunc_EnemySpawnPatcher.AddEnemyToBlockInGameSpawn(val);
			RunManager.instance.EnemiesSpawnedRemoveEnd();
			return val;
		}

		private Enemy LevelGeneratorEnemySpawn(GameObject prefab, string path, Vector3 position)
		{
			//IL_001c: 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_000d: 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)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ((GameManager.instance.gameMode != 0) ? PhotonNetwork.InstantiateRoomObject(path, position, Quaternion.identity, (byte)0, (object[])null) : Object.Instantiate<GameObject>(prefab, position, Quaternion.identity));
			EnemyParent component = val.GetComponent<EnemyParent>();
			if (Object.op_Implicit((Object)(object)component))
			{
				Traverse.Create((object)component).Field<bool>("SetupDone").Value = true;
				Enemy componentInChildren = val.GetComponentInChildren<Enemy>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.EnemyTeleported(position);
					Traverse<int> obj = Traverse.Create((object)LevelGenerator.Instance).Field<int>("EnemiesSpawnTarget");
					int value = obj.Value;
					obj.Value = value + 1;
					EnemyDirector.instance.FirstSpawnPointAdd(component);
				}
				return componentInChildren;
			}
			((HelperLog)Utils.logger).LogWarning((object)("LevelGeneratorEnemySpawn can't find EnemyParent component for '" + path + "'"));
			return null;
		}

		private EnemyData GetEnemyPrefab(string name)
		{
			if (enemyPrefabs.TryGetValue(name, out var value) && (Object)(object)value.prefab != (Object)null)
			{
				return value;
			}
			string enemyPath = GetEnemyPath(name);
			EnemyData enemyData = default(EnemyData);
			enemyData.name = name;
			enemyData.path = enemyPath;
			enemyData.prefab = Resources.Load<GameObject>(enemyPath);
			EnemyData enemyData2 = enemyData;
			enemyPrefabs[name] = enemyData2;
			return enemyData2;
		}

		private string GetEnemyPath(string name)
		{
			return "Enemies/Enemy - " + name;
		}
	}
	internal class ChaosItemManager
	{
		internal struct SpawnItem
		{
			public GameObject prefab;

			public string name;

			public string path;
		}

		private readonly Dictionary<string, SpawnItem> prefabs;

		internal static readonly string itemsBasePath = "Items/";

		internal static readonly string removedItemsBasePath = "Items/Removed Items/";

		internal static readonly string valuablesBasePath = "Valuables/";

		internal static readonly string[] valuableCategories = new string[7] { "01 Tiny", "02 Small", "03 Medium", "04 Big", "05 Wide", "06 Tall", "07 Very Tall" };

		internal ChaosItemManager()
		{
			prefabs = new Dictionary<string, SpawnItem>();
		}

		internal SpawnItem GetSpawnItem(string name)
		{
			if (prefabs.TryGetValue(name, out var value))
			{
				if ((Object)(object)value.prefab != (Object)null)
				{
					return value;
				}
				value.prefab = Resources.Load<GameObject>(value.path);
				prefabs[value.name] = value;
				return value;
			}
			SpawnItem result = TryToFindObject(name);
			if ((Object)(object)result.prefab == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)("can't load prefab for '" + name + "'"));
			}
			return result;
		}

		private void LoadObjects(string basePath)
		{
			GameObject[] array = Resources.LoadAll<GameObject>(basePath);
			foreach (GameObject val in array)
			{
				string path = basePath + ((Object)val).name;
				prefabs[((Object)val).name] = new SpawnItem
				{
					prefab = val,
					name = ((Object)val).name,
					path = path
				};
			}
		}

		internal void LoadAllObjects()
		{
			try
			{
				LoadObjects(removedItemsBasePath);
				LoadObjects(itemsBasePath);
				LoadObjects(valuablesBasePath);
				string[] array = valuableCategories;
				foreach (string text in array)
				{
					LoadObjects(valuablesBasePath + text + "/");
				}
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"ChaosItemManager->LoadAllObjects {arg}");
			}
		}

		private SpawnItem LoadObjectWithFilter(string basePath, string targetName)
		{
			GameObject[] array = Resources.LoadAll<GameObject>(basePath);
			foreach (GameObject val in array)
			{
				if (targetName == ((Object)val).name)
				{
					string path = basePath + ((Object)val).name;
					SpawnItem spawnItem = default(SpawnItem);
					spawnItem.prefab = val;
					spawnItem.name = ((Object)val).name;
					spawnItem.path = path;
					SpawnItem spawnItem2 = spawnItem;
					prefabs[((Object)val).name] = spawnItem2;
					return spawnItem2;
				}
			}
			return default(SpawnItem);
		}

		private SpawnItem TryToFindObject(string targetName)
		{
			string[] array = valuableCategories;
			foreach (string text in array)
			{
				SpawnItem result = LoadObjectWithFilter(valuablesBasePath + text + "/", targetName);
				if ((Object)(object)result.prefab != (Object)null)
				{
					return result;
				}
			}
			SpawnItem result2 = LoadObjectWithFilter(valuablesBasePath, targetName);
			if ((Object)(object)result2.prefab != (Object)null)
			{
				return result2;
			}
			result2 = LoadObjectWithFilter(itemsBasePath, targetName);
			if ((Object)(object)result2.prefab != (Object)null)
			{
				return result2;
			}
			return LoadObjectWithFilter(removedItemsBasePath, targetName);
		}
	}
	internal class ChaosModNetwork : MonoBehaviour
	{
		internal struct DataSource
		{
			public int playerID;

			public string eventID;
		}

		private static ChaosModNetwork inst;

		private PhotonView photonView;

		private static Queue<DataSource> commandQueue;

		private static readonly HashSet<string> shouldBeRunFromHost = new HashSet<string>
		{
			"all_buff_hp_average", "all_goal_dec", "all_goal_inc", "solo_debuff_item_boom", "all_debuff_kill_rand", "all_cart_spread", "active_nade_stun", "active_nade_shock", "active_nade_expl", "active_nade_duck",
			"spawn_duck", "spawn_spewer", "spawn_upscream", "spawn_alien", "spawn_animal", "spawn_baby", "spawn_thinman", "spawn_hidden", "spawn_frog", "spawn_bowtie",
			"spawn_huntsman", "spawn_head", "spawn_trudge", "spawn_clown", "spawn_robe", "spawn_reaper", "item_health_small", "item_health_med", "item_health_big", "item_crystal",
			"item_nade_stun", "item_nade_shock", "item_nade_expl", "item_nade_f1", "item_nade_duck_f1", "item_mine_stun", "item_mine_shock", "item_mine_expl", "item_rubber_duck", "item_book_roll",
			"item_book_speed", "item_book_energy", "item_book_health", "item_book_range", "item_book_strength", "item_book_jump", "item_drone_roll", "item_drone_gravity", "item_drone_feather", "item_drone_energy",
			"item_drone_shield", "item_sphere_gravity", "item_frying_pan", "item_inflatable_hammer", "item_sword", "item_baseball_bat", "item_sledge_hammer", "item_valuable_tracker", "item_extraction_tracker", "item_cart_small",
			"item_cart_medium", "item_tranq", "item_handgun", "item_shotgun", "loot_rand_small", "loot_rand_med", "loot_rand_big", "loot_money_rain", "loot_frog", "loot_bottle",
			"loot_love_potion", "loot_gramophone", "loot_power_crystal", "loot_fan", "loot_clown", "loot_guitar", "loot_propane_tank", "loot_music_box", "loot_television", "loot_flamethrower",
			"loot_saw", "loot_time_glass", "loot_doll", "loot_barrel", "loot_sword", "loot_staff", "loot_animal_crate", "loot_creature_leg", "loot_ice_block", "loot_broom",
			"loot_painting", "loot_harp", "loot_grandfather_clock", "loot_golden_statue", "loot_science_station", "loot_server_rack", "loot_dinosaur", "loot_griffin_statue", "loot_piano", "solo_frogs_around",
			"solo_poop_diamonds", "solo_poop_mines", "solo_poop_nades", "loot_rand_enemy", "all_stun_enemies", "all_cart_teleport_rand", "all_cart_teleport_start", "all_teleport_rand", "solo_teleport_start", "all_teleport_start",
			"all_teleport_shuffle", "solo_upgrade_roll", "solo_upgrade_speed", "solo_upgrade_energy", "solo_upgrade_health", "solo_upgrade_range", "solo_upgrade_strength", "solo_upgrade_jump"
		};

		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)
		{
			((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
			});
		}

		internal 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}");
			}
		}

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

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

		internal static void ProcessNetworkEvents(ICommandManager cm, Dictionary<string, IRepoStandaloneCommand> commands)
		{
			while (commandQueue.Count > 0)
			{
				try
				{
					DataSource dataSource = commandQueue.Dequeue();
					((HelperLog)Utils.logger).LogInfo((object)$"ChaosModNetwork->ProcessEvents event id {dataSource.eventID} for {dataSource.playerID}");
					PlayerAvatar val = SemiFunc.PlayerAvatarGetFromPhotonID(dataSource.playerID);
					if ((Object)(object)val == (Object)null)
					{
						((HelperLog)Utils.logger).LogWarning((object)"ChaosModNetwork->ProcessEvents can't find player. Skip event");
						continue;
					}
					string text = cm.GetCommandData(dataSource.eventID, true)?.Trim();
					if (string.IsNullOrEmpty(text))
					{
						((HelperLog)Utils.logger).LogWarning((object)"ChaosModNetwork->ProcessEvents can't find commands");
					}
					else
					{
						ProcessCommandLines(UtilityConsole.ParseCommandLine(text), val, commands);
					}
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->ProcessEvents: {arg}");
				}
			}
		}

		private static void ProcessCommandLines(string[] lines, PlayerAvatar player, Dictionary<string, IRepoStandaloneCommand> commands)
		{
			for (int i = 0; i < lines.Length; i++)
			{
				string[] array = UtilityConsole.ParseArgs(lines[i]);
				string key = array[0];
				try
				{
					IRepoStandaloneCommand repoStandaloneCommand = commands[key];
					if (repoStandaloneCommand is INetworkCommand networkCommand)
					{
						networkCommand.Execute(array.Skip(1), player);
					}
					else
					{
						((IConsoleCommand)repoStandaloneCommand).Execute(array.Skip(1));
					}
				}
				catch (Exception arg)
				{
					((HelperLog)Utils.logger).LogError((object)$"ChaosModNetwork->ProcessEvents: {arg}");
				}
			}
		}
	}
	internal class CommandListArgManager
	{
		internal class Group
		{
			[JsonProperty("drop_variants")]
			public DropVariant[] dropVariants;
		}

		internal class DropVariant
		{
			public string[] items;
		}

		private Dictionary<string, Group> groups;

		private Dictionary<string, string[]> simpleGroups;

		internal CommandListArgManager()
		{
		}

		internal void LoadCommandsList()
		{
			try
			{
				string relativeModFilePath = Utils.GetRelativeModFilePath("drop_groups.data");
				groups = UtilityJson.Generate((IDebugLogger)(object)Utils.logger).FromFile<Dictionary<string, Group>>(relativeModFilePath);
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)$"CommandListArgManager groups init error: {arg}");
			}
			try
			{
				string relativeModFilePath2 = Utils.GetRelativeModFilePath("drop_simple_groups.data");
				simpleGroups = UtilityJson.Generate((IDebugLogger)(object)Utils.logger).FromFile<Dictionary<string, string[]>>(relativeModFilePath2);
			}
			catch (Exception arg2)
			{
				((HelperLog)Utils.logger).LogError((object)$"CommandListArgManager simple groups init error: {arg2}");
			}
		}

		internal DropVariant GetRandomDropVariant(string groupName)
		{
			if (groups == null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"CommandListArgManager groups null");
				return null;
			}
			if (!groups.TryGetValue(groupName, out var value))
			{
				((HelperLog)Utils.logger).LogWarning((object)("CommandListArgManager can't find group " + groupName));
				return null;
			}
			if (value == null || value.dropVariants == null || value.dropVariants.Length == 0)
			{
				((HelperLog)Utils.logger).LogWarning((object)("CommandListArgManager drop variants empty for " + groupName));
				return null;
			}
			return UtilityRandom.GetRandomItemFromList<DropVariant>((IList<DropVariant>)value.dropVariants);
		}

		internal string[] GetRandomDropVariantPaths(string groupName)
		{
			DropVariant randomDropVariant = GetRandomDropVariant(groupName);
			if (randomDropVariant == null || randomDropVariant.items == null)
			{
				return new string[0];
			}
			return randomDropVariant.items.Select((string s) => CommandArgsReaderWrapper.ParseItemPath(s)).ToArray();
		}

		internal string GetRandomDropFromSimpleGroup(string groupName)
		{
			if (simpleGroups == null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"CommandListArgManager simpleGroups null");
				return null;
			}
			if (!simpleGroups.TryGetValue(groupName, out var value))
			{
				((HelperLog)Utils.logger).LogWarning((object)("CommandListArgManager can't find simple group " + groupName));
				return null;
			}
			return CommandArgsReaderWrapper.ParseItemPath(UtilityRandom.GetRandomItemFromList<string>((IList<string>)value));
		}

		internal bool IsSimpeGroup(string name)
		{
			if (simpleGroups != null)
			{
				return simpleGroups.ContainsKey(name);
			}
			return false;
		}
	}
	internal 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;

		internal 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}");
			}
		}

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

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

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

		internal void TriggerOnConfigChangedEvent_ThreadSafe(object sender, SettingsData settings)
		{
			TriggerEvent(Event.OnConfigChangedThreadSafe, sender, settings);
		}
	}
	internal static class ExplodeManager
	{
		private static GameObject explodePrefab;

		private static void CheckPrefab()
		{
			if ((Object)(object)explodePrefab == (Object)null)
			{
				explodePrefab = Resources.Load<GameObject>("Effects/Part Prefab Explosion");
			}
		}

		private static void InternalExplode(Vector3 pos, float expSize, int expDamage, float forceMult)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			CheckPrefab();
			ParticlePrefabExplosion component = Object.Instantiate<GameObject>(explodePrefab, pos, Quaternion.identity).GetComponent<ParticlePrefabExplosion>();
			component.forceMultiplier = forceMult;
			Traverse obj = Traverse.Create((object)component);
			obj.Field<float>("explosionSize").Value = expSize;
			obj.Field<int>("explosionDamage").Value = expDamage;
		}

		internal static void CreateExplodeNearPlayer(PlayerAvatar player, float offset, float expSize, int expDamage, float forceMult)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			InternalExplode(GameUtils.GetPlayerForward(((Component)player).transform, offset), expSize, expDamage, forceMult);
		}

		internal static GameObject ExplodeGrabItem(PlayerAvatar player, float expSize, int expDamage, float forceMult)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			PhysGrabber physGrabber = player.physGrabber;
			if (!physGrabber.grabbed)
			{
				((HelperLog)Utils.logger).LogInfo((object)"ExplodeGrabItem no item in hands");
				return null;
			}
			InternalExplode(physGrabber.grabbedObjectTransform.position, expSize, expDamage, forceMult);
			return ((Component)physGrabber.grabbedObjectTransform).gameObject;
		}

		internal static ValuableObject ExplodeClosestItem(PlayerAvatar player, float expSize, int expDamage, float forceMult)
		{
			//IL_0006: 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)
			ValuableObject closestValuableObject = GameUtils.GetClosestValuableObject(((Component)player).transform.position, null);
			if ((Object)(object)closestValuableObject == (Object)null)
			{
				((HelperLog)Utils.logger).LogInfo((object)"ExplodeGrabItem no item found");
				return null;
			}
			InternalExplode(((Component)closestValuableObject).transform.position, expSize, expDamage, forceMult);
			return closestValuableObject;
		}
	}
	internal sealed class ServiceProvider
	{
		internal static readonly ServiceProvider inst = new ServiceProvider();

		internal ScheduleManager systemScheduleManager;

		internal ScheduleManager scheduleManager;

		internal EventEmitter eventEmitter;

		internal ChaosItemManager itemManager;

		internal CommandListArgManager commandListArgManager;

		internal ChaosEnemySpawner enemySpawner;

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

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

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

		internal void RegisterItemManager(ChaosItemManager itemManager)
		{
			this.itemManager = itemManager;
		}

		internal void RegisterCommandListArgManager(CommandListArgManager commandListArgManager)
		{
			this.commandListArgManager = commandListArgManager;
		}

		internal void RegisterEnemySpawner(ChaosEnemySpawner enemySpawner)
		{
			this.enemySpawner = enemySpawner;
		}
	}
	internal sealed class SettingsData
	{
		internal bool ApplySpawnEventsForAll { get; set; } = true;


		internal bool ApplyEffectEventsForAll { get; set; } = true;

	}
	internal static class SettingsManager
	{
		private static SettingsData newData;

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


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

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

		internal 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 REPO_BFT_BepInEx.Wrappers
{
	internal 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 static string ParseItemPath(string path)
		{
			return path?.Replace("_", " ");
		}

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

		private int messagesLimit;

		internal 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 REPO_BFT_BepInEx.Patchers
{
	internal static class ChaosInputManager
	{
		private static readonly Dictionary<InputKey, bool> blockedKeys = new Dictionary<InputKey, bool>();

		private static readonly Dictionary<InputKey, bool> holdKeys = new Dictionary<InputKey, bool>();

		internal static float mouseSpeedCoeffX = 1f;

		internal static float mouseSpeedCoeffY = 1f;

		internal static void BlockKey(InputKey key)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			blockedKeys[key] = true;
		}

		internal static void UnblockKey(InputKey key)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			blockedKeys[key] = false;
		}

		internal static void UnblockAll()
		{
			blockedKeys.Clear();
		}

		internal static bool IsKeyBlocked(InputKey key)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (blockedKeys.TryGetValue(key, out var value))
			{
				return value;
			}
			return false;
		}

		internal static void HoldKey(InputKey key)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			holdKeys[key] = true;
		}

		internal static void UnholdKey(InputKey key)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			holdKeys[key] = false;
		}

		internal static void UnholdAll()
		{
			holdKeys.Clear();
		}

		internal static bool IsKeyHold(InputKey key)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (holdKeys.TryGetValue(key, out var value))
			{
				return value;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InputManager), "KeyDown")]
	internal class InputManager_KeyDownPatcher
	{
		private static bool Prefix(ref bool __result, InputKey key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (ChaosInputManager.IsKeyBlocked(key))
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InputManager), "KeyHold")]
	internal class InputManager_KeyHoldPatcher
	{
		internal static bool Prefix(ref bool __result, InputKey key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (ChaosInputManager.IsKeyBlocked(key))
			{
				__result = false;
				return false;
			}
			if (ChaosInputManager.IsKeyHold(key))
			{
				__result = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InputManager), "GetMouseX")]
	internal class InputManager_MouseX_Patcher
	{
		internal static void Postfix(ref float __result)
		{
			__result *= ChaosInputManager.mouseSpeedCoeffX;
		}
	}
	[HarmonyPatch(typeof(InputManager), "GetMouseY")]
	internal class InputManager_MouseY_Patcher
	{
		internal static void Postfix(ref float __result)
		{
			__result *= ChaosInputManager.mouseSpeedCoeffY;
		}
	}
	internal static class MainPatcher
	{
		private static bool isPatched;

		internal 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}");
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar), "Awake")]
	internal class PlayerAvatarPatcher
	{
		internal static void Postfix(PlayerAvatar __instance)
		{
			if ((Object)(object)((Component)__instance).GetComponent<ChaosModNetwork>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<ChaosModNetwork>();
			}
		}
	}
	[HarmonyPatch(typeof(SemiFunc), "EnemySpawn")]
	internal class SemiFunc_EnemySpawnPatcher
	{
		private static readonly HashSet<Enemy> enemiesToBlockInGameSpawn = new HashSet<Enemy>();

		internal static void AddEnemyToBlockInGameSpawn(Enemy enemy)
		{
			if (!((Object)(object)enemy == (Object)null))
			{
				enemiesToBlockInGameSpawn.Add(enemy);
			}
		}

		internal static void ClearBlockEnemies()
		{
			enemiesToBlockInGameSpawn.Clear();
		}

		private static bool Prefix(ref bool __result, Enemy enemy)
		{
			if (enemiesToBlockInGameSpawn.Contains(enemy))
			{
				((HelperLog)Utils.logger).LogInfo((object)("semi spawn for enemy '" + ((Object)enemy).name + "' is blocked"));
				enemiesToBlockInGameSpawn.Remove(enemy);
				ServiceProvider.inst.enemySpawner.RegisterSpawnedEnemyFinished(enemy);
				__result = false;
				return false;
			}
			return true;
		}
	}
}
namespace REPO_BFT_BepInEx.Commands
{
	internal class AddExtractGoal : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		public string Id => "add_extract_goal";

		public bool Execute(IEnumerable<string> args)
		{
			int num = new CommandArgsReaderWrapper(args).ReadInt();
			Traverse obj = Traverse.Create((object)RoundDirector.instance);
			int value = obj.Field<int>("extractionHaulGoal").Value;
			Traverse.Create((object)obj.Field<ExtractionPoint>("extractionPointCurrent").Value).Method("HaulGoalSet", new object[1] { Mathf.Max(1, value + num) }).GetValue();
			return true;
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			return Execute(args);
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			//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();
			GameUtils.LocalPlayer.ForceImpulse(new Vector3(num, num2, num3));
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0048: 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();
			float rotatePower = commandArgsReaderWrapper.ReadFloat(10f);
			PlayerAvatar localPlayer = GameUtils.LocalPlayer;
			GameUtils.ActivateTumble(localPlayer.tumble, localPlayer, new Vector3(num, num2, num3), rotatePower);
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			//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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = commandArgsReaderWrapper.ReadFloat();
			float num2 = commandArgsReaderWrapper.ReadFloat();
			Transform transform = ((Component)GameUtils.LocalPlayer).transform;
			Vector3 val = transform.forward;
			Vector3 val2 = ((Vector3)(ref val)).normalized * num;
			val = transform.right;
			Vector3 val3 = ((Vector3)(ref val)).normalized * (0f - num2);
			PlayerAvatar localPlayer = GameUtils.LocalPlayer;
			Traverse val4 = Traverse.Create((object)localPlayer);
			Vector3 val5 = val2 + val3;
			localPlayer.ForceImpulse(val5);
			if (val4.Field<bool>("isCrouching").Value || val4.Field<bool>("isCrawling").Value)
			{
				((HelperLog)Utils.logger).LogInfo((object)"add push v2");
				GameUtils.ActivateTumble(localPlayer.tumble, localPlayer, val5, 10f);
				return true;
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class AveragePlayersHealth : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		public string Id => "avg_players_hp";

		public bool Execute(IEnumerable<string> args)
		{
			List<PlayerAvatar> alivePlayers = GameUtils.AlivePlayers;
			int amount = alivePlayers.Select((PlayerAvatar p) => GameUtils.GetPlayerHealth(p.playerHealth)).Sum() / alivePlayers.Count;
			foreach (PlayerAvatar item in alivePlayers)
			{
				GameUtils.SetHealthAmount(item, amount, keepAlive: true);
			}
			return true;
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			return Execute(args);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ChangeExtractGoalPercents : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		public string Id => "change_extract_goal_percents";

		public bool Execute(IEnumerable<string> args)
		{
			float num = new CommandArgsReaderWrapper(args).ReadFloat();
			Traverse obj = Traverse.Create((object)RoundDirector.instance);
			int value = obj.Field<int>("extractionHaulGoal").Value;
			Traverse.Create((object)obj.Field<ExtractionPoint>("extractionPointCurrent").Value).Method("HaulGoalSet", new object[1] { Mathf.Max(1, (int)((float)value * num)) }).GetValue();
			return true;
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			return Execute(args);
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ChangeHeight : IRepoStandaloneCommand, IConsoleCommand
	{
		private Vector3 basePlayerScale;

		private int sizeTriggerCount;

		public string Id => "change_height";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ChangeMouseSpeedX : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "change_mouse_speed_x";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			ChaosInputManager.mouseSpeedCoeffX = commandArgsReaderWrapper.ReadFloat();
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ChaosInputManager.mouseSpeedCoeffX = 1f;
				}
			}, true);
			return true;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ChangeMouseSpeedY : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "change_mouse_speed_y";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			ChaosInputManager.mouseSpeedCoeffY = commandArgsReaderWrapper.ReadFloat();
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					ChaosInputManager.mouseSpeedCoeffY = 1f;
				}
			}, true);
			return true;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DisablePlayerAiming : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "disable_player_aiming";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			float num = new CommandArgsReaderWrapper(args).ReadFloat();
			Traverse<float> aimingTimerField = GetAimingTimerField();
			if (aimingTimerField == null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + " target field null"));
				return false;
			}
			aimingTimerField.Value = num + Mathf.Max(0f, aimingTimerField.Value);
			return true;
		}

		private Traverse<float> GetAimingTimerField()
		{
			InputManager instance = InputManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + " InputManager null"));
				return null;
			}
			return Traverse.Create((object)instance).Field<float>("disableAimingTimer");
		}

		public void ForceEnd()
		{
			Traverse<float> aimingTimerField = GetAimingTimerField();
			if (aimingTimerField != null)
			{
				aimingTimerField.Value = 0f;
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " field null when ForceEnd"));
			}
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DisableCrouch : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private readonly Dictionary<InputKey, bool> isActive = new Dictionary<InputKey, bool>();

		public string Id => "disable_input";

		public bool IsActive => isActive.Any((KeyValuePair<InputKey, bool> item) => item.Value);

		public bool Execute(IEnumerable<string> args)
		{
			//IL_005d: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00b3: Expected O, but got Unknown
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			string text = commandArgsReaderWrapper.ReadString();
			if (!Enum.TryParse<InputKey>(text, ignoreCase: true, out InputKey key))
			{
				((HelperLog)Utils.logger).LogError((object)(Id + " can't find key for name " + text));
				return false;
			}
			isActive[key] = true;
			ChaosInputManager.BlockKey(key);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = GetTimerKey(key),
				durationInSec = durationInSec,
				finishAction = delegate
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					isActive[key] = false;
					ChaosInputManager.UnblockKey(key);
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			return true;
		}

		private string GetTimerKey(InputKey key)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return $"{Id}_{key}";
		}

		public void ForceEnd()
		{
			//IL_0015: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			foreach (InputKey key in isActive.Keys)
			{
				ServiceProvider.inst.scheduleManager.FinishImmediatlyTimerTask(GetTimerKey(key));
			}
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DisablePlayerMovement : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		public string Id => "disable_player_movement";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			float num = new CommandArgsReaderWrapper(args).ReadFloat();
			Traverse<float> movementTimerField = GetMovementTimerField();
			if (movementTimerField == null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + " target field null"));
				return false;
			}
			movementTimerField.Value = num + Mathf.Max(0f, movementTimerField.Value);
			return true;
		}

		private Traverse<float> GetMovementTimerField()
		{
			InputManager instance = InputManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + " InputManager null"));
				return null;
			}
			return Traverse.Create((object)instance).Field<float>("disableMovementTimer");
		}

		public void ForceEnd()
		{
			Traverse<float> movementTimerField = GetMovementTimerField();
			if (movementTimerField != null)
			{
				movementTimerField.Value = 0f;
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " field null when ForceEnd"));
			}
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class DrainStamina : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private float power;

		public string Id => "drain_player_stamina";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_007f: Expected O, but got Unknown
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = commandArgsReaderWrapper.ReadFloat();
			power = commandArgsReaderWrapper.ReadFloat();
			ServiceProvider.inst.eventEmitter.ReplaceOrAddOnUpdateHandler(Id, OnUpdate);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			IsActive = true;
			return true;
		}

		private void OnUpdate(object sender, float dtInSec)
		{
			if (IsActive)
			{
				float energyCurrent = PlayerController.instance.EnergyCurrent;
				PlayerController.instance.EnergyCurrent = Mathf.Max(0f, energyCurrent - power * dtInSec);
			}
		}

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

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

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0075: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			PlayerAvatar localPlayer = GameUtils.LocalPlayer;
			if (GameUtils.IsPlayerDead(GameUtils.LocalPlayer))
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " player is dead"));
				return true;
			}
			Inventory instance = Inventory.instance;
			if ((Object)(object)instance == (Object)null)
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " player inventory is not found"));
				return false;
			}
			PhysGrabber grabber = GameUtils.LocalPlayer.physGrabber;
			_ = ((Component)localPlayer).transform.position + GameUtils.GetForwardOffset();
			List<ItemEquippable> l