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.Utilities;
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.7.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.7.0.0")]
namespace REPO_BFT_BepInEx
{
	[BepInPlugin("bft.chaostricks", "Chaos Tricks", "1.7.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
			{
				SettingsUtils.BaseFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				SceneManager.sceneLoaded += OnSceneLoaded;
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogError((object)string.Format("{0} v{1} error: {2}", "Chaos Tricks", "1.7.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.7.0", arg));
			}
		}
	}
	public sealed class InteractiveMod : MonoBehaviour
	{
		internal static InteractiveMod inst;

		internal const string MOD_VERSION = "1.7.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 CommandConsole 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 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.7.0");
			FlushLog();
			MainPatcher.InitPatch();
		}

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

		public void OnDestroy()
		{
			((HelperLog)logger).LogInfo((object)"InteractiveMod OnDestroy");
			FlushLog();
		}

		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 CommandConsole((IDebugLogger)(object)logger, (List<string>)null);
			eventsParser = (IEventsDataParser)new EventsDataParser((Action<string>)((HelperLog)logger).LogWarning);
			eventsReader = new WebSocketEventsReader<SettingsData>((Action<IEventsData>)ProcessEvent, eventsParser, (Action<string>)((HelperLog)logger).LogInfo, (Action<string>)((HelperLog)logger).LogInfo, 0.5f, 1f, 0.5f, true);
			eventsReader.InitDefaultSocket(Utils.modFolder, "chaostricks_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, data.Lang, data.Username);
				NotifyEvent(data.EventID, data.Lang, data.Username, ignoreTruck: false);
				ChaosModNetwork.RequestNotifyOtherRPC(data.EventID, data.Lang, data.Username);
				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"));
					NotifyEvent(data.EventID, data.Lang, data.Username, ignoreTruck: false);
					ChaosModNetwork.RequestNotifyOtherRPC(data.EventID, data.Lang, data.Username);
				}
				else
				{
					((HelperDebugLog)logger).LogDebugError((object)("Event '" + data.EventID + "' executing is failed"));
				}
			}
			catch (Exception arg)
			{
				((HelperLog)logger).LogError((object)$"ProcessCommands '{data.EventID}' unexpected error: {arg}");
			}
		}

		public void NotifyEvent(string eventID, string lang, string username, bool ignoreTruck)
		{
			string trans = translationService.translation.GetTrans(eventID, lang);
			string trans2 = translationService.translation.GetTrans("%template_msg%", lang);
			string message = (username ?? "viewer") + " " + trans2 + " '" + trans + "'";
			if (!ignoreTruck)
			{
				GameUtils.SendTruckChatMessage(message);
			}
			GameUtils.ShowUIMessage(message);
		}

		private void OnLevelGenerated()
		{
			try
			{
				((HelperLog)Utils.logger).LogInfo((object)"OnLevelGenerated triggered");
				SemiFunc_EnemySpawnPatcher.ClearBlockEnemies();
				EnemyParentPatcher.ClearEnemies();
				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();
				EnemyParentPatcher.ClearEnemies();
				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 : IJsonUtils
	{
		public T FromFile<T>(string path) where T : class
		{
			using StreamReader streamReader = new StreamReader(path);
			return FromString<T>(streamReader.ReadToEnd());
		}

		public T FromString<T>(string s) where T : class
		{
			return JsonConvert.DeserializeObject<T>(s);
		}
	}
	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)
		{
			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}");
					IsolatedHurtyOther(player, num3);
				}
			}
		}

		internal static void SetHealthAmount(PlayerAvatar player, int amount, bool keepAlive)
		{
			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}");
			IsolatedHurtyOther(player, num3);
		}

		private static void IsolatedHurtyOther(PlayerAvatar player, int damage)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			player.playerHealth.HurtOther(damage, Vector3.zero, false, -1, false);
		}

		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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			PhysGrabber physGrabber = player.physGrabber;
			if ((Object)(object)physGrabber != (Object)null)
			{
				physGrabber.ReleaseObject(-1, 0.2f);
			}
			player.Spawn(pos, rot);
			try
			{
				Traverse.Create((object)Traverse.Create((object)player).Field<PlayerTumble>("tumble").Value).Field<PhysGrabObject>("physGrabObject").Value.Teleport(pos, rot);
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogWarning((object)$"TeleportPlayer tumble/grab error: {arg}");
			}
			((Component)player).transform.position = pos;
			((Component)player).transform.rotation = rot;
			((Component)player.playerAvatarVisuals).transform.position = pos;
			Traverse.Create((object)player.playerAvatarVisuals).Field<Vector3>("visualPosition").Value = pos;
			if (IsLocalPlayer(player))
			{
				PlayerController instance = PlayerController.instance;
				instance.CollisionController.ResetFalling();
				instance.VelocityRelative = Vector3.zero;
				instance.Velocity = Vector3.zero;
				Rigidbody value = Traverse.Create((object)instance).Field<Rigidbody>("rb").Value;
				value.velocity = Vector3.zero;
				value.position = pos;
				value.rotation = rot;
				Traverse.Create((object)instance).Field<Vector3>("clientPosition").Value = pos;
				Traverse.Create((object)instance).Field<Vector3>("clientPositionCurrent").Value = pos;
				Traverse.Create((object)instance).Field<Quaternion>("clientRotation").Value = rot;
				Traverse.Create((object)instance).Field<Quaternion>("clientRotationCurrent").Value = rot;
				Traverse.Create((object)instance).Field<Vector3>("spawnPosition").Value = pos;
				Traverse.Create((object)instance).Field<Quaternion>("spawnRotation").Value = rot;
				Traverse.Create((object)instance).Field<Vector3>("rbVelocityRaw").Value = Vector3.zero;
				Traverse.Create((object)instance).Field<float>("MoveForceAmount").Value = 0f;
				Traverse.Create((object)instance).Field<Vector3>("VelocityImpulse").Value = Vector3.zero;
			}
		}

		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 = -1)
		{
			if (!((Object)(object)obj == (Object)null))
			{
				ItemBattery battery = obj.GetComponentInParent<ItemBattery>();
				CoroutineUtils.StartCoroutine((MonoBehaviour)(object)battery, delayInSec, delegate
				{
					int num = ((amount < 0) ? battery.batteryBars : 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 RandomUtils.GetRandomItemFromList<T>((IList<T>)list);
		}

		internal static GameObject GetClosestObjectByTag(Vector3 pos, string tag, Func<GameObject, bool> filter, bool needLog = true)
		{
			//IL_0075: 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_0086: 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_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)
			//IL_00ad: 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}");
				}
			}
			switch (num)
			{
			case 0:
				return null;
			case 1:
				return array[0];
			default:
			{
				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_006e: 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_007f: 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_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)
			//IL_00a6: 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}");
				}
			}
			switch (num)
			{
			case 0:
				return null;
			case 1:
				return array[0];
			default:
			{
				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_003c: 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] { ((Component)p.localCamera).transform.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);
			}
		}

		public static ItemEquippable GetGrabbedItem(PhysGrabber grabber)
		{
			if ((Object)(object)grabber == (Object)null)
			{
				return null;
			}
			try
			{
				PhysGrabObject value = Traverse.Create((object)grabber).Field<PhysGrabObject>("grabbedPhysGrabObject").Value;
				if ((Object)(object)value == (Object)null)
				{
					return null;
				}
				return ((Component)value).GetComponent<ItemEquippable>();
			}
			catch (Exception arg)
			{
				((HelperLog)Utils.logger).LogWarning((object)$"grabber {arg}");
				return null;
			}
		}
	}
	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).ClearLog((Action<string>)null);
			}
		}

		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_009d: 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;
			}
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)"error: SpawnEnemy RunManager.instance is null");
				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);
			EnemyParentPatcher.AddEnemy(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_007a: 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));
			if ((Object)(object)val == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)"LevelGeneratorEnemySpawn spawned enemy is null");
				return null;
			}
			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);
		}
	}
	public class ChaosModNetwork : MonoBehaviour
	{
		public struct DataSource
		{
			public int playerID;

			public string eventID;

			public string username;

			public string lang;
		}

		private static ChaosModNetwork inst;

		private PhotonView photonView;

		private static Queue<DataSource> commandQueue;

		private static bool logNetworkInitIssue = true;

		private static readonly HashSet<string> shouldBeRunFromHost = new HashSet<string>
		{
			"solo_buff_resurrect", "all_buff_resurrect_rand", "all_buff_resurrect_all", "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", "item_duck_bucket", "item_melee_prodzap", "item_gun_boltzap", "item_gun_pulse", "loot_rand_beta_small", "loot_rand_beta_med", "loot_mug_deluxe", "loot_baby_head", "loot_gem_burger",
			"loot_ac_gumball", "loot_ac_boombox", "loot_milk", "loot_golden_swirl", "loot_ac_blender", "loot_horse", "loot_ac_trafic_light", "solo_upgrade_wings", "solo_upgrade_rest", "item_book_wings",
			"item_book_rest", "item_cart_cannon", "item_cart_laser", "item_bridge", "item_photon_blaster", "spawn_dogo", "spawn_tick", "spawn_birthday_boy", "spawn_gambit", "spawn_headgrab",
			"spawn_heart_hugger", "spawn_cleanup_crew", "spawn_bella", "spawn_oogly", "spawn_loom", "item_book_battery", "item_book_climb", "loot_rand_huge", "loot_star_wand", "loot_lev_potion",
			"loot_jackhammer", "loot_coffin", "loot_tray", "loot_dragon_skull", "item_cart_scooter", "item_cart_scooter_small", "item_staff_gravity", "item_staff_torque", "item_staff_void", "item_walkie_talkie",
			"item_revive"
		};

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

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

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

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

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

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

		public static void ProcessNetworkEvents(ICommandManager cm, Dictionary<string, IRepoStandaloneCommand> commands)
		{
			if (commandQueue == null || cm == null || commands == null)
			{
				if (logNetworkInitIssue)
				{
					logNetworkInitIssue = false;
					((HelperLog)Utils.logger).LogWarning((object)$"ProcessNetworkEvents unexpected issue cq {commandQueue == null}, cm {cm == null}, c {commands == null}");
				}
				return;
			}
			while (commandQueue.Count > 0)
			{
				try
				{
					logNetworkInitIssue = true;
					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(CommandConsole.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 = CommandConsole.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}");
				}
			}
		}

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

		[PunRPC]
		private void NotifyOtherRPC(string eventID, string lang, string username)
		{
			((HelperLog)Utils.logger).LogInfo((object)("ChaosModNetwork->ActivateNotifyRPC triggered for " + eventID));
			InteractiveMod.inst.NotifyEvent(eventID, lang, username, ignoreTruck: true);
		}
	}
	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 = JsonUtils.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 = JsonUtils.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 RandomUtils.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) => CommandArgsReader.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 CommandArgsReader.ParseItemPath(RandomUtils.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 : CommandArgsReader
	{
		public CommandArgsReaderWrapper(IEnumerable<string> args)
			: base(args, (ILogger)(object)Utils.logger)
		{
		}
	}
	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 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;
		}

		public void ClearLog(Action<string> onError)
		{
			((ILogger)logger).ClearLog(onError);
		}

		public void ClearLogBySize(int fileSizeInBytes, Action<string> onError)
		{
			((ILogger)logger).ClearLogBySize(fileSizeInBytes, onError);
		}
	}
}
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 '" + ((Object)enemy).name + "' patcher"));
				ServiceProvider.inst.enemySpawner.RegisterSpawnedEnemyFinished(enemy);
				enemiesToBlockInGameSpawn.Remove(enemy);
				__result = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EnemyParent))]
	public static class EnemyParentPatcher
	{
		private static readonly HashSet<Enemy> enemies = new HashSet<Enemy>();

		public static void AddEnemy(Enemy enemy)
		{
			if (!((Object)(object)enemy == (Object)null))
			{
				enemies.Add(enemy);
			}
		}

		public static void ClearEnemies()
		{
			enemies.Clear();
		}

		[HarmonyPatch("Despawn")]
		[HarmonyPrefix]
		private static bool Despawn_Prefix(Enemy ___Enemy, float ___SpawnedTimeMax, ref float ___SpawnedTimer)
		{
			if (enemies.Contains(___Enemy))
			{
				((HelperLog)Utils.logger).LogInfo((object)("despawn '" + ((Object)___Enemy).name + "' patcher"));
				enemies.Remove(___Enemy);
				___SpawnedTimer = ___SpawnedTimeMax;
				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 = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadInt(0);
			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 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			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_0057: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float rotatePower = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(10f);
			PlayerAvatar localPlayer = GameUtils.LocalPlayer;
			GameUtils.ActivateTumble(Traverse.Create((object)localPlayer).Field<PlayerTumble>("tumble").Value, 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			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(val4.Field<PlayerTumble>("tumble").Value, 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 = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			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 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			ChaosInputManager.mouseSpeedCoeffX = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			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 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			ChaosInputManager.mouseSpeedCoeffY = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			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 = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			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 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			string text = ((CommandArgsReader)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 = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			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 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			power = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			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> list = new List<ItemEquippable>();
			ItemEquippable grabbedItem = GameUtils.GetGrabbedItem(grabber);
			bool physGrabActive = PlayerController.instance.physGrabActive;
			foreach (InventorySpot allSpot in instance.GetAllSpots())
			{
				if (!((Object)(object)allSpot == (Object)null))
				{
					ItemEquippable currentItem = allSpot.CurrentItem;
					if (!((Object)(object)currentItem == (Object)null))
					{
						currentItem.RequestUnequip();
						list.Add(currentItem);
					}
				}
			}
			if (list.Count == 0)
			{
				return true;
			}
			if ((list.Contains(grabbedItem) && physGrabActive) || !physGrabActive)
			{
				((HelperLog)Utils.logger).LogInfo((object)"di run delayed free grab task");
				CoroutineUtils.StartCoroutine((MonoBehaviour)(object)grabber, 0.45f, delegate
				{
					((HelperLog)Utils.logger).LogInfo((object)"di release grabber");
					grabber.ReleaseObject(-1, 0.2f);
					Traverse.Create((object)grabber).Field<float>("grabDisableTimer").Value = 0.2f;
				});
			}
			return true;
		}

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

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			float num = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			PlayerController instance = PlayerController.instance;
			float value = Traverse.Create((object)instance).Field<float>("antiGravityTimer").Value;
			instance.AntiGravity(num + Mathf.Max(0f, value));
			return true;
		}

		public void ForceEnd()
		{
			PlayerController instance = PlayerController.instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.AntiGravity(0f);
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + "->ForceEnd PlayerController null"));
			}
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float expSize = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(2f);
			int expDamage = ((CommandArgsReader)commandArgsReaderWrapper).ReadInt(5);
			float forceMult = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(1f);
			float min = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(1f);
			float max = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float min2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(1f);
			float max2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float min3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(1f);
			float max3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			ValuableObject val = ExplodeManager.ExplodeClosestItem(targetPlayer, expSize, expDamage, forceMult);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			PhysGrabObject componentInParent = ((Component)val).GetComponentInParent<PhysGrabObject>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				float num = Utils.GetRandomBetween(min2, max2) * (float)UnityMathUtils.GetRandomSign();
				float randomBetween = Utils.GetRandomBetween(min, max);
				float num2 = Utils.GetRandomBetween(min3, max3) * (float)UnityMathUtils.GetRandomSign();
				componentInParent.rb.AddForce(new Vector3(num, randomBetween, num2), (ForceMode)1);
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " target object no phys grab"));
			}
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float expSize = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(2f);
			int expDamage = ((CommandArgsReader)commandArgsReaderWrapper).ReadInt(5);
			float forceMult = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(1f);
			ExplodeManager.ExplodeGrabItem(targetPlayer, expSize, expDamage, forceMult);
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float offset = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(2f);
			float expSize = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(2f);
			int expDamage = ((CommandArgsReader)commandArgsReaderWrapper).ReadInt(5);
			float forceMult = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(1f);
			ExplodeManager.CreateExplodeNearPlayer(targetPlayer, offset, expSize, expDamage, forceMult);
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			if (GameUtils.IsPlayerAlive(GameUtils.LocalPlayer))
			{
				GameUtils.LocalPlayer.PlayerDeath(-1);
			}
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			PlayerAvatar randomItemFromList = RandomUtils.GetRandomItemFromList<PlayerAvatar>((IList<PlayerAvatar>)GameUtils.AlivePlayers);
			if ((Object)(object)randomItemFromList == (Object)null)
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " all players are dead"));
				return true;
			}
			((HelperLog)Utils.logger).LogInfo((object)(Id + " try to kill player " + GameUtils.GetPlayerName(randomItemFromList)));
			randomItemFromList.PlayerDeath(-1);
			return true;
		}

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

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

		public bool Execute(IEnumerable<string> args)
		{
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			bool isMultiplayer = ((CommandArgsReader)commandArgsReaderWrapper).ReadBool(false);
			int num = ((CommandArgsReader)commandArgsReaderWrapper).ReadInt(0);
			foreach (PlayerAvatar alivePlayerEventTarget in GameUtils.GetAlivePlayerEventTargets(isMultiplayer))
			{
				alivePlayerEventTarget.playerHealth.HealOther(num, true);
			}
			return true;
		}

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

		public string Id => "hold_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 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			string text = ((CommandArgsReader)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.HoldKey(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.UnholdKey(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 HurtPlayer : IRepoStandaloneCommand, IConsoleCommand
	{
		public string Id => "hurt_player_amount";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			bool isMultiplayer = ((CommandArgsReader)commandArgsReaderWrapper).ReadBool(false);
			int num = ((CommandArgsReader)commandArgsReaderWrapper).ReadInt(0);
			bool flag = ((CommandArgsReader)commandArgsReaderWrapper).ReadBool(false);
			foreach (PlayerAvatar alivePlayerEventTarget in GameUtils.GetAlivePlayerEventTargets(isMultiplayer))
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " process " + GameUtils.GetPlayerName(alivePlayerEventTarget)));
				int playerHealth = GameUtils.GetPlayerHealth(alivePlayerEventTarget.playerHealth);
				int num2 = num;
				if (flag && playerHealth <= num2)
				{
					num2 = playerHealth - 1;
					if (num2 == 0)
					{
						((HelperLog)Utils.logger).LogInfo((object)"skipped damage, too low hp");
						continue;
					}
				}
				alivePlayerEventTarget.playerHealth.HurtOther(num2, Vector3.zero, false, -1, false);
			}
			return true;
		}

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

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//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_004d: 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_006c: Expected O, but got Unknown
			float durationInSec = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			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)
			{
				PlayerController instance = PlayerController.instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.EnergyCurrent = instance.EnergyStart;
				}
			}
		}

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

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

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//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_004d: 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_006c: Expected O, but got Unknown
			float durationInSec = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			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)
			{
				return;
			}
			PlayerAvatar localPlayer = GameUtils.LocalPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && GameUtils.IsPlayerAlive(localPlayer))
			{
				PlayerHealth playerHealth = localPlayer.playerHealth;
				if (!((Object)(object)playerHealth == (Object)null) && ((Behaviour)playerHealth).enabled)
				{
					playerHealth.InvincibleSet(5f);
				}
			}
		}

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

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

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0044: 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)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float rotatePower = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(10f);
			PlayerAvatar localPlayer = GameUtils.LocalPlayer;
			GameUtils.ActivateTumble(Traverse.Create((object)localPlayer).Field<PlayerTumble>("tumble").Value, localPlayer, ((Component)localPlayer.localCamera).transform.forward * num, rotatePower);
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			float num = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0.1f);
			PhysGrabber physGrabber = GameUtils.LocalPlayer.physGrabber;
			if ((Object)(object)physGrabber == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + " can't find grabber"));
				return false;
			}
			physGrabber.ReleaseObject(-1, num);
			Traverse.Create((object)physGrabber).Field<float>("grabDisableTimer").Value = num;
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			PlayerController instance = PlayerController.instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.EnergyCurrent = instance.EnergyStart;
			}
			return true;
		}

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

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

		public bool Execute(IEnumerable<string> args)
		{
			List<PlayerAvatar> deadPlayers = GameUtils.DeadPlayers;
			if (deadPlayers == null || deadPlayers.Count == 0)
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " all players are alive"));
				return true;
			}
			foreach (PlayerAvatar item in deadPlayers)
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " try to resurrect player " + GameUtils.GetPlayerName(item)));
				item.Revive(false);
			}
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			Resurect(GameUtils.LocalPlayer);
			return true;
		}

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

		private void Resurect(PlayerAvatar player)
		{
			if (GameUtils.IsPlayerDead(player))
			{
				player.Revive(false);
			}
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			PlayerAvatar randomItemFromList = RandomUtils.GetRandomItemFromList<PlayerAvatar>((IList<PlayerAvatar>)GameUtils.DeadPlayers);
			if ((Object)(object)randomItemFromList == (Object)null)
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " all players are alive"));
				return true;
			}
			((HelperLog)Utils.logger).LogInfo((object)(Id + " try to resurrect player " + GameUtils.GetPlayerName(randomItemFromList)));
			randomItemFromList.Revive(false);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class SetCustomPlayerGravity : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private float oldCustomGravity = 20f;

		private float oldPlayerGravity = 20f;

		private float currentGravity;

		public string Id => "set_player_gravity";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_003e: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float durationInSec = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			ServiceProvider.inst.eventEmitter.ReplaceOrAddOnUpdateHandler(Id, OnUpdate);
			TimerTaskData val = new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
					PlayerController instance2 = PlayerController.instance;
					if ((Object)(object)instance2 != (Object)null)
					{
						instance2.CustomGravity = oldCustomGravity;
						Traverse.Create((object)instance2).Field<float>("playerOriginalCustomGravity").Value = oldPlayerGravity;
					}
					else
					{
						((HelperLog)Utils.logger).LogWarning((object)(Id + "->ForceEnd PlayerController null"));
					}
				}
			};
			if (num == currentGravity)
			{
				ServiceProvider.inst.scheduleManager.AppendTimerTask(val, false);
			}
			else
			{
				ServiceProvider.inst.scheduleManager.NewTimerTask(val, false);
			}
			currentGravity = num;
			if (!IsActive)
			{
				IsActive = true;
				PlayerController instance = PlayerController.instance;
				if ((Object)(object)instance == (Object)null)
				{
					((HelperLog)Utils.logger).LogWarning((object)(Id + "->Execute PlayerController null"));
					return false;
				}
				if (Traverse.Create((object)instance).Field<float>("antiGravityTimer").Value > 0f)
				{
					instance.AntiGravity(0f);
				}
				if (currentGravity != instance.CustomGravity)
				{
					oldCustomGravity = instance.CustomGravity;
					oldPlayerGravity = Traverse.Create((object)instance).Field<float>("playerOriginalCustomGravity").Value;
				}
			}
			return true;
		}

		private void OnUpdate(object sender, float dtInSec)
		{
			if (IsActive)
			{
				PlayerController instance = PlayerController.instance;
				if ((Object)(object)instance != (Object)null && instance.CustomGravity != currentGravity)
				{
					instance.CustomGravity = currentGravity;
					Traverse.Create((object)instance).Field<float>("playerOriginalCustomGravity").Value = currentGravity;
				}
			}
		}

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

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

		public string Id => "set_player_speed_mult";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float num = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			PlayerController instance = PlayerController.instance;
			if (oldPower == num2)
			{
				float value = Traverse.Create((object)instance).Field<float>("overrideSpeedTimer").Value;
				num += Mathf.Max(0f, value);
			}
			else
			{
				oldPower = num2;
			}
			instance.OverrideSpeed(num2, num);
			return true;
		}

		public void ForceEnd()
		{
			PlayerController instance = PlayerController.instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.OverrideSpeed(1f, 0f);
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + "->ForceEnd PlayerController null"));
			}
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			bool isMultiplayer = ((CommandArgsReader)commandArgsReaderWrapper).ReadBool(false);
			float percents = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			bool keepAlive = ((CommandArgsReader)commandArgsReaderWrapper).ReadBool(false);
			foreach (PlayerAvatar alivePlayerEventTarget in GameUtils.GetAlivePlayerEventTargets(isMultiplayer))
			{
				GameUtils.SetHealthPercentage(alivePlayerEventTarget, percents, keepAlive);
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class SetJumpPower : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private float oldJumpForce = 20f;

		private float currentJumpForce;

		public string Id => "set_player_jump_power";

		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 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			currentJumpForce = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			ServiceProvider.inst.eventEmitter.ReplaceOrAddOnUpdateHandler(Id, OnUpdate);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					PlayerController instance2 = PlayerController.instance;
					if ((Object)(object)instance2 != (Object)null)
					{
						instance2.JumpForce = oldJumpForce;
					}
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			if (!IsActive)
			{
				IsActive = true;
				PlayerController instance = PlayerController.instance;
				if ((Object)(object)instance != (Object)null && currentJumpForce != instance.JumpForce)
				{
					oldJumpForce = instance.JumpForce;
				}
			}
			return true;
		}

		private void OnUpdate(object sender, float dtInSec)
		{
			if (IsActive)
			{
				PlayerController instance = PlayerController.instance;
				if (instance.JumpForce != currentJumpForce)
				{
					instance.JumpForce = currentJumpForce;
				}
			}
		}

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

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

		public bool Execute(IEnumerable<string> args)
		{
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			bool isMultiplayer = ((CommandArgsReader)commandArgsReaderWrapper).ReadBool(false);
			bool keepAlive = ((CommandArgsReader)commandArgsReaderWrapper).ReadBool(false);
			foreach (PlayerAvatar alivePlayerEventTarget in GameUtils.GetAlivePlayerEventTargets(isMultiplayer))
			{
				int playerMaxHealth = GameUtils.GetPlayerMaxHealth(alivePlayerEventTarget.playerHealth);
				int amount = 1 + Utils.rnd.Next(playerMaxHealth);
				GameUtils.SetHealthAmount(alivePlayerEventTarget, amount, keepAlive);
			}
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float min = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float max = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(10f);
			float min2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float max2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(20f);
			float min3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float max3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(10f);
			GameObject closestCart = GameUtils.GetClosestCart(((Component)targetPlayer).transform.position);
			if ((Object)(object)closestCart == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"can't find cart");
				return false;
			}
			List<CartObject> cartItems = GameUtils.GetCartItems(closestCart);
			if (cartItems == null)
			{
				return false;
			}
			foreach (CartObject item in cartItems)
			{
				if (!((Object)(object)item.physGrabObject == (Object)null) && !((Object)(object)item.physGrabObject.rb == (Object)null))
				{
					float num = Utils.GetRandomBetween(min, max) * (float)UnityMathUtils.GetRandomSign();
					float randomBetween = Utils.GetRandomBetween(min2, max2);
					float num2 = Utils.GetRandomBetween(min3, max3) * (float)UnityMathUtils.GetRandomSign();
					item.physGrabObject.rb.AddForce(new Vector3(num, randomBetween, num2), (ForceMode)1);
				}
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class ShakeCartItemsDelayed : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		[CompilerGenerated]
		private sealed class <ForceWithDelay>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			public Rigidbody rb;

			public float forceX;

			public float forceZ;

			public int count;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					rb.AddForce(new Vector3(forceX, 0f, forceZ), (ForceMode)1);
					break;
				}
				if (count-- > 0)
				{
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		public string Id => "shake_cart_items_delayed";

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			float min = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float max = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(10f);
			float min2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float max2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(20f);
			float min3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(5f);
			float max3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(10f);
			float delay = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0.5f);
			int count = ((CommandArgsReader)commandArgsReaderWrapper).ReadInt(3);
			GameObject closestCart = GameUtils.GetClosestCart(((Component)targetPlayer).transform.position);
			if ((Object)(object)closestCart == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"can't find cart");
				return false;
			}
			List<CartObject> cartItems = GameUtils.GetCartItems(closestCart);
			if (cartItems == null)
			{
				return false;
			}
			foreach (CartObject item in cartItems)
			{
				if (!((Object)(object)item.physGrabObject == (Object)null) && !((Object)(object)item.physGrabObject.rb == (Object)null))
				{
					float forceX = Utils.GetRandomBetween(min, max) * (float)UnityMathUtils.GetRandomSign();
					float randomBetween = Utils.GetRandomBetween(min2, max2);
					float forceZ = Utils.GetRandomBetween(min3, max3) * (float)UnityMathUtils.GetRandomSign();
					item.physGrabObject.rb.AddForce(new Vector3(0f, randomBetween, 0f), (ForceMode)1);
					IEnumerator enumerator2 = ForceWithDelay(item.physGrabObject.rb, forceX, forceZ, delay, count);
					((MonoBehaviour)item.physGrabObject).StartCoroutine(enumerator2);
				}
			}
			return true;
		}

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

		[IteratorStateMachine(typeof(<ForceWithDelay>d__5))]
		private IEnumerator ForceWithDelay(Rigidbody rb, float forceX, float forceZ, float delay, int count)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ForceWithDelay>d__5(0)
			{
				rb = rb,
				forceX = forceX,
				forceZ = forceZ,
				delay = delay,
				count = count
			};
		}
	}
	internal class ShufflePlayerMovement : IRepoStandaloneCommand, IConsoleCommand, IForceEnd
	{
		private readonly string[] ways = new string[4] { "Up", "Down", "Left", "Right" };

		public string Id => "shuffle_player_movement";

		public bool IsActive { get; private set; }

		public bool Execute(IEnumerable<string> args)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			float durationInSec = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					IsActive = false;
					RestoreInput();
					((HelperLog)Utils.logger).LogInfo((object)(Id + " ends"));
				}
			}, false);
			if (ShuffleBinds())
			{
				IsActive = true;
				return true;
			}
			return false;
		}

		private Dictionary<InputKey, InputAction> GetInputActions()
		{
			InputManager instance = InputManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + "->RestoreInput->InputManager null"));
				return null;
			}
			Traverse<Dictionary<InputKey, InputAction>> val = Traverse.Create((object)instance).Field<Dictionary<InputKey, InputAction>>("inputActions");
			if (val == null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + "->RestoreInput->InputManager->inputActions null"));
				return null;
			}
			Dictionary<InputKey, InputAction> value = val.Value;
			if (value == null)
			{
				((HelperLog)Utils.logger).LogError((object)(Id + "->RestoreInput->InputManager->inputActions value null"));
				return null;
			}
			return value;
		}

		private bool ShuffleBinds()
		{
			//IL_001c: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<InputKey, InputAction> inputActions = GetInputActions();
			if (inputActions == null)
			{
				return false;
			}
			InputAction val = inputActions[(InputKey)0];
			InputBinding[] array = (InputBinding[])(object)new InputBinding[4];
			foreach (InputBinding item in ((IEnumerable<InputBinding>)(object)val.bindings).Where((InputBinding b) => ways.Contains(((InputBinding)(ref b)).name)))
			{
				InputBinding current = item;
				if (ways[0] == ((InputBinding)(ref current)).name)
				{
					array[0] = current;
				}
				else if (ways[1] == ((InputBinding)(ref current)).name)
				{
					array[1] = current;
				}
				else if (ways[2] == ((InputBinding)(ref current)).name)
				{
					array[2] = current;
				}
				else if (ways[3] == ((InputBinding)(ref current)).name)
				{
					array[3] = current;
				}
			}
			SwapBinds(val, array[0], array[1]);
			SwapBinds(val, array[2], array[3]);
			return true;
		}

		private void SwapBinds(InputAction action, InputBinding bind1, InputBinding bind2)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			((HelperLog)Utils.logger).LogInfo((object)("rebind " + ((InputBinding)(ref bind1)).name + " from " + ((InputBinding)(ref bind1)).path + " to " + ((InputBinding)(ref bind2)).path));
			((HelperLog)Utils.logger).LogInfo((object)("rebind " + ((InputBinding)(ref bind2)).name + " from " + ((InputBinding)(ref bind2)).path + " to " + ((InputBinding)(ref bind1)).path));
			((InputBinding)(ref bind1)).overridePath = ((InputBinding)(ref bind2)).path;
			((InputBinding)(ref bind2)).overridePath = ((InputBinding)(ref bind1)).path;
			InputActionRebindingExtensions.ApplyBindingOverride(action, bind1);
			InputActionRebindingExtensions.ApplyBindingOverride(action, bind2);
		}

		private void RestoreInput()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<InputKey, InputAction> inputActions = GetInputActions();
			if (inputActions != null)
			{
				InputAction val = inputActions[(InputKey)0];
				InputBinding[] array = ((IEnumerable<InputBinding>)(object)val.bindings).Where((InputBinding b) => ways.Contains(((InputBinding)(ref b)).name)).ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					InputBinding val2 = array[i];
					((InputBinding)(ref val2)).overridePath = null;
					((HelperLog)Utils.logger).LogInfo((object)("reset bind " + ((InputBinding)(ref val2)).name + " to " + ((InputBinding)(ref val2)).path));
					InputActionRebindingExtensions.ApplyBindingOverride(val, val2);
				}
			}
		}

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

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

		public bool Execute(IEnumerable<string> args)
		{
			List<PlayerAvatar> alivePlayers = GameUtils.AlivePlayers;
			List<int> list = Utils.ShuffleForceRandom(alivePlayers.Select((PlayerAvatar p) => GameUtils.GetPlayerHealth(p.playerHealth)));
			for (int i = 0; i < alivePlayers.Count; i++)
			{
				GameUtils.SetHealthAmount(alivePlayers[i], list[i], keepAlive: true);
			}
			return true;
		}

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

			private object <>2__current;

			public Rigidbody rb;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: 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_00a0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 100)
				{
					rb.AddForce(Vector3.up * 4f, (ForceMode)1);
					rb.AddTorque(Random.insideUnitSphere * 2f, (ForceMode)1);
					float num = Random.Range(2.5f, 6f);
					Rigidbody obj = rb;
					Vector2 insideUnitCircle = Random.insideUnitCircle;
					obj.AddForce(Vector2.op_Implicit(((Vector2)(ref insideUnitCircle)).normalized * num), (ForceMode)1);
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		public string Id => "spawn_active_item";

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_005e: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string name = ((CommandArgsReader)commandArgsReaderWrapper).ReadSpacedString("");
			float length = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float height = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			Transform transform = ((Component)targetPlayer).transform;
			Vector3 spawnPos = GameUtils.GetPlayerForward(transform) + GameUtils.GetForwardOffset(transform, length, height);
			GameObject obj = GameUtils.SpawnItem(name, spawnPos, Quaternion.Euler(num, num2, num3));
			GameUtils.ChargeItem(obj, 0f, 10);
			ActivateItem(obj);
			return true;
		}

		private void ActivateItem(GameObject obj)
		{
			CheckStaff(obj);
			CheckDuck(obj);
			CheckBottle(obj);
			CheckToggleItems(obj);
		}

		private void CheckStaff(GameObject obj)
		{
			ValuableWizardStaff comp = obj.GetComponentInChildren<ValuableWizardStaff>();
			if (!((Object)(object)comp == (Object)null))
			{
				((HelperLog)Utils.logger).LogInfo((object)"prepare activating laser");
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)comp, 1, delegate
				{
					((HelperLog)Utils.logger).LogInfo((object)"try to activate laser");
					comp.StaffLaser();
				});
			}
		}

		private void CheckDuck(GameObject obj)
		{
			ItemRubberDuck comp = obj.GetComponentInChildren<ItemRubberDuck>();
			if (!((Object)(object)comp == (Object)null))
			{
				((HelperLog)Utils.logger).LogInfo((object)"prepare activating duck");
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)comp, 2, delegate
				{
					((HelperLog)Utils.logger).LogInfo((object)"try to activate duck");
					Rigidbody component = ((Component)comp).GetComponent<Rigidbody>();
					((MonoBehaviour)comp).StartCoroutine(MoveDuck(component));
				});
			}
		}

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

		private void CheckBottle(GameObject obj)
		{
			BottleTrap comp = obj.GetComponentInChildren<BottleTrap>();
			if (!((Object)(object)comp == (Object)null))
			{
				((HelperLog)Utils.logger).LogInfo((object)"prepare activating bottle trap");
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)comp, 1, delegate
				{
					((HelperLog)Utils.logger).LogInfo((object)"try to activate bottle trap");
					comp.TrapActivate();
				});
			}
		}

		private void CheckToggleItems(GameObject obj)
		{
			ItemToggle comp = obj.GetComponent<ItemToggle>();
			if (!((Object)(object)comp == (Object)null))
			{
				((HelperLog)Utils.logger).LogInfo((object)"prepare activating toggle item");
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)comp, 1, delegate
				{
					((HelperLog)Utils.logger).LogInfo((object)"try to activate toggle item");
					comp.ToggleItem(true, -1);
				});
			}
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			string enemyName = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadSpacedString("");
			Vector3 pos = GameUtils.GetClosestSpawnPointTo(((Component)targetPlayer).transform.position);
			Enemy val = ServiceProvider.inst.enemySpawner.SpawnEnemy(enemyName, pos);
			EnemyStateInvestigate invetigate = ((Component)val).GetComponent<EnemyStateInvestigate>();
			if ((Object)(object)invetigate == (Object)null)
			{
				return true;
			}
			CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)val, 1, delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				invetigate.Set(pos, false);
			});
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string text = ((CommandArgsReader)commandArgsReaderWrapper).ReadSpacedString("");
			float length = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float height = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			Transform transform = ((Component)targetPlayer).transform;
			Vector3 spawnPos = GameUtils.GetPlayerForward(transform) + GameUtils.GetForwardOffset(transform, length, height);
			GameUtils.ChargeItem(GameUtils.SpawnItem(text, spawnPos, Quaternion.identity), 0.5f);
			GameUtils.RegisterItemInGame(text);
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string groupName = ((CommandArgsReader)commandArgsReaderWrapper).ReadString("");
			float length = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float height = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			Transform transform = ((Component)targetPlayer).transform;
			Vector3 playerForward = GameUtils.GetPlayerForward(transform);
			string[] randomDropVariantPaths = ServiceProvider.inst.commandListArgManager.GetRandomDropVariantPaths(groupName);
			float num = 1f;
			Vector3 forwardOffset = GameUtils.GetForwardOffset(transform, length, height);
			string[] array = randomDropVariantPaths;
			foreach (string obj in array)
			{
				GameUtils.ChargeItem(GameUtils.SpawnItem(obj, playerForward * num + forwardOffset, Quaternion.identity), 0.5f);
				GameUtils.RegisterItemInGame(obj);
				num += 0.1f;
			}
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string name = ((CommandArgsReader)commandArgsReaderWrapper).ReadSpacedString("");
			float num = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num2 = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float num3 = ((CommandArgsReader)commandArgsReaderWrapper).ReadInt(0);
			float num4 = 360f / num3;
			Vector3 val = ((Component)targetPlayer).transform.position + new Vector3(0f, num, 0f);
			Vector3 forward = ((Component)targetPlayer).transform.forward;
			Vector3 val2 = ((Vector3)(ref forward)).normalized * num2;
			Quaternion rotation = ((Component)targetPlayer).transform.rotation;
			for (int i = 0; (float)i < num3; i++)
			{
				Vector3 spawnPos = val + Quaternion.AngleAxis(num4 * (float)i, Vector3.up) * val2;
				Quaternion rot = rotation * Quaternion.Euler(Vector3.up * num4 * (float)i);
				GameObject obj = GameUtils.SpawnItem(name, spawnPos, rot);
				ActivateItem(obj);
				ActivateFrog(obj);
			}
			return true;
		}

		private void ActivateItem(GameObject obj)
		{
			ItemToggle comp = obj.GetComponent<ItemToggle>();
			if (!((Object)(object)comp == (Object)null))
			{
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)comp, 1, delegate
				{
					comp.ToggleItem(true, -1);
				});
			}
		}

		private void ActivateFrog(GameObject obj)
		{
			FrogTrap comp = obj.GetComponentInChildren<FrogTrap>();
			if (!((Object)(object)comp == (Object)null))
			{
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)comp, 1, delegate
				{
					comp.TrapActivate();
				});
			}
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class SpawnItemsFromPlayer : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		[CompilerGenerated]
		private sealed class <MoveItem>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Transform trans;

			public float forcePower;

			public Rigidbody rb;

			private Vector3 <forwardVec>5__2;

			private int <i>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//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_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: 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_00a8: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					Vector3 forward = trans.forward;
					<forwardVec>5__2 = -((Vector3)(ref forward)).normalized * forcePower;
					<i>5__3 = 0;
					break;
				}
				case 2:
					<>1__state = -1;
					<i>5__3++;
					break;
				}
				if (<i>5__3 < 3)
				{
					rb.AddTorque(Random.insideUnitSphere * 2f, (ForceMode)1);
					rb.AddForce(<forwardVec>5__2, (ForceMode)1);
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

		public string Id => "spawn_items_from_player";

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string text = ((CommandArgsReader)commandArgsReaderWrapper).ReadString("");
			float durationInSec = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float periodInSec = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float height = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float backOffset = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float forcePower = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			string groupName = null;
			string itemName = null;
			bool isGroup = ServiceProvider.inst.commandListArgManager.IsSimpeGroup(text);
			if (isGroup)
			{
				groupName = text;
			}
			else
			{
				itemName = CommandArgsReader.ParseItemPath(text);
			}
			string taskID = $"{Id}_{targetPlayer.photonView.ViewID}";
			ServiceProvider.inst.scheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				id = taskID,
				periodicAction = delegate
				{
					PeriodicSpawn(((Component)targetPlayer).transform, isGroup, height, backOffset, forcePower, itemName, groupName);
				},
				periodInSec = periodInSec
			}, false);
			ServiceProvider.inst.scheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = taskID,
				durationInSec = durationInSec,
				finishAction = delegate
				{
					ServiceProvider.inst.scheduleManager.RemovePeriodicTask(taskID);
				}
			}, true);
			return true;
		}

		private void PeriodicSpawn(Transform trans, bool isGroup, float height, float backOffset, float forcePower, string itemName, string groupName)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = trans.position + new Vector3(0f, height, 0f);
			Vector3 val2 = val;
			Vector3 forward = trans.forward;
			val = val2 - ((Vector3)(ref forward)).normalized * backOffset;
			GameObject val3 = GameUtils.SpawnItem(isGroup ? ServiceProvider.inst.commandListArgManager.GetRandomDropFromSimpleGroup(groupName) : itemName, val, Quaternion.identity, needLog: false);
			if ((Object)(object)val3 == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"spawned item null object. Ignoring activating / force moving.");
				return;
			}
			ActivateItem(val3);
			Rigidbody componentInChildren = val3.GetComponentInChildren<Rigidbody>();
			MonoBehaviour componentInChildren2 = val3.GetComponentInChildren<MonoBehaviour>();
			if ((Object)(object)componentInChildren2 == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"spawned item hasn't a script to start delayed task");
				return;
			}
			componentInChildren2.StartCoroutine(MoveItem(componentInChildren, trans, forcePower));
			PhysGrabObjectImpactDetector impact = val3.GetComponentInChildren<PhysGrabObjectImpactDetector>();
			if ((Object)(object)impact != (Object)null)
			{
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)impact, 1, delegate
				{
					impact.destroyDisable = false;
					Traverse obj = Traverse.Create((object)impact);
					obj.Field<bool>("isIndestructible").Value = false;
					obj.Field<float>("indestructibleSpawnTimer").Value = 0f;
					obj.Field<bool>("destroyDisableTeleport").Value = false;
					obj.Field<bool>("indestructibleBreakEffects").Value = false;
				});
			}
		}

		[IteratorStateMachine(typeof(<MoveItem>d__5))]
		private IEnumerator MoveItem(Rigidbody rb, Transform trans, float forcePower)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MoveItem>d__5(0)
			{
				rb = rb,
				trans = trans,
				forcePower = forcePower
			};
		}

		private void ActivateItem(GameObject obj)
		{
			ItemToggle comp = obj.GetComponent<ItemToggle>();
			if (!((Object)(object)comp == (Object)null))
			{
				CoroutineUtils.StartCoroutineInFrames((MonoBehaviour)(object)comp, 1, delegate
				{
					comp.ToggleItem(true, -1);
				});
			}
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0048: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			CommandArgsReaderWrapper commandArgsReaderWrapper = new CommandArgsReaderWrapper(args);
			string groupName = ((CommandArgsReader)commandArgsReaderWrapper).ReadString("");
			float length = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			float height = ((CommandArgsReader)commandArgsReaderWrapper).ReadFloat(0f);
			Transform transform = ((Component)targetPlayer).transform;
			Vector3 spawnPos = GameUtils.GetPlayerForward(transform) + GameUtils.GetForwardOffset(transform, length, height);
			string randomDropFromSimpleGroup = ServiceProvider.inst.commandListArgManager.GetRandomDropFromSimpleGroup(groupName);
			GameUtils.ChargeItem(GameUtils.SpawnItem(randomDropFromSimpleGroup, spawnPos, Quaternion.identity), 0.5f);
			GameUtils.RegisterItemInGame(randomDropFromSimpleGroup);
			return true;
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			float num = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadFloat(0f);
			Enemy[] enemies = GameUtils.GetEnemies();
			for (int i = 0; i < enemies.Length; i++)
			{
				EnemyStateStunned componentInChildren = ((Component)enemies[i]).GetComponentInChildren<EnemyStateStunned>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					((HelperLog)Utils.logger).LogWarning((object)"doesn't find stun component");
				}
				else
				{
					componentInChildren.Set(num);
				}
			}
			return true;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class SwapPlayerWithClosestEnemy : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		[CompilerGenerated]
		private sealed class <CoroutineTeleport>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Enemy enemy;

			public Vector3 targetPos;

			public PlayerAvatar player;

			private Vector3 <playerPos>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: 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_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_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)enemy != (Object)null)
					{
						((HelperLog)Utils.logger).LogInfo((object)"target enemy teleporting");
						Vector3 freeOfPlayersFarPointFrom = GameUtils.GetFreeOfPlayersFarPointFrom(targetPos);
						enemy.EnemyTeleported(freeOfPlayersFarPointFrom);
						((HelperLog)Utils.logger).LogInfo((object)$"enemy from {targetPos} to buffer {freeOfPlayersFarPointFrom}");
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					((HelperLog)Utils.logger).LogInfo((object)$"player from {((Component)player).transform.position} to random pos {targetPos}");
					GameUtils.TeleportPlayer(player, targetPos, Quaternion.identity);
					break;
				case 1:
					<>1__state = -1;
					<playerPos>5__2 = ((Component)player).transform.position;
					GameUtils.TeleportPlayer(player, targetPos, Quaternion.identity);
					((HelperLog)Utils.logger).LogInfo((object)$"player from {<playerPos>5__2} to enemy {targetPos}");
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					enemy.EnemyTeleported(<playerPos>5__2);
					((HelperLog)Utils.logger).LogInfo((object)$"enemy from {((Component)enemy).transform.position} to old player {<playerPos>5__2}");
					Traverse val = Traverse.Create((object)enemy);
					if (val.Field<bool>("HasStateInvestigate").Value)
					{
						val.Field<EnemyStateInvestigate>("StateInvestigate").Value.Set(<playerPos>5__2, false);
					}
					break;
				}
				}
				return false;
			}

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

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

		public string Id => "swap_player_with_closest_enemy";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			PlayerAvatar randomItemFromList = RandomUtils.GetRandomItemFromList<PlayerAvatar>((IList<PlayerAvatar>)GameUtils.AlivePlayers);
			Enemy closestEnemy = GameUtils.GetClosestEnemy(((Component)randomItemFromList).transform.position);
			Vector3 position;
			if ((Object)(object)closestEnemy != (Object)null)
			{
				position = ((Component)closestEnemy).transform.position;
			}
			else
			{
				((HelperLog)Utils.logger).LogWarning((object)"no enemies found, use random point");
				List<LevelPoint> list = GameUtils.GetLevelPoints(excludePlayerRooms: true);
				if (list.Count == 0)
				{
					((HelperLog)Utils.logger).LogWarning((object)"no player points not found, use all");
					list = SemiFunc.LevelPointsGetInPlayerRooms();
				}
				LevelPoint randomLevelPoint = GameUtils.GetRandomLevelPoint(list, null, useLastUsedPointIfNoOthers: true, needLog: true);
				if ((Object)(object)randomLevelPoint == (Object)null)
				{
					((HelperLog)Utils.logger).LogError((object)"can't find any point");
					return false;
				}
				position = ((Component)randomLevelPoint).transform.position;
			}
			((MonoBehaviour)randomItemFromList).StartCoroutine(CoroutineTeleport(closestEnemy, randomItemFromList, position));
			return true;
		}

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

		[IteratorStateMachine(typeof(<CoroutineTeleport>d__4))]
		private static IEnumerator CoroutineTeleport(Enemy enemy, PlayerAvatar player, Vector3 targetPos)
		{
			//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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoroutineTeleport>d__4(0)
			{
				enemy = enemy,
				player = player,
				targetPos = targetPos
			};
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class TeleportCartsToRandomRoom : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		private LevelPoint lastUsedPoint;

		public string Id => "teleport_carts_to_random_room";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] carts = GameUtils.GetCarts();
			List<LevelPoint> levelPoints = GameUtils.GetLevelPoints(excludePlayerRooms: true);
			GameObject[] array = carts;
			foreach (GameObject val in array)
			{
				lastUsedPoint = GameUtils.GetRandomLevelPoint(levelPoints, lastUsedPoint);
				if ((Object)(object)lastUsedPoint == (Object)null)
				{
					((HelperLog)Utils.logger).LogInfo((object)"valid point not found");
					continue;
				}
				((HelperLog)Utils.logger).LogInfo((object)$"target {((Component)lastUsedPoint).transform.position}");
				PhysGrabCart componentInParent = val.GetComponentInParent<PhysGrabCart>();
				Collider componentInParent2 = ((Component)componentInParent).GetComponentInParent<Collider>();
				float num;
				if ((Object)(object)componentInParent2 == (Object)null)
				{
					num = 1f;
					((HelperLog)Utils.logger).LogWarning((object)"can't find collider");
				}
				else
				{
					Bounds bounds = componentInParent2.bounds;
					num = ((Bounds)(ref bounds)).size.y;
				}
				Rigidbody component = ((Component)componentInParent).GetComponent<Rigidbody>();
				if ((Object)(object)component == (Object)null)
				{
					((HelperLog)Utils.logger).LogWarning((object)"can't find rb");
					continue;
				}
				Vector3 val2 = ((Component)lastUsedPoint).transform.position + new Vector3(0f, num, 0f);
				Vector3 position = component.position;
				component.position = val2;
				TeleportCartsToStart.TeleporInCartItems(componentInParent, val2, position);
			}
			return true;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class TeleportCartsToStart : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		private LevelPoint lastUsedPoint;

		public string Id => "teleport_carts_to_start";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] carts = GameUtils.GetCarts();
			foreach (GameObject val in carts)
			{
				lastUsedPoint = GameUtils.GetRandomLevelPoint(SemiFunc.LevelPointsGetInStartRoom(), lastUsedPoint);
				if ((Object)(object)lastUsedPoint == (Object)null)
				{
					((HelperLog)Utils.logger).LogInfo((object)"valid point not found");
					continue;
				}
				((HelperLog)Utils.logger).LogInfo((object)$"target {((Component)lastUsedPoint).transform.position}");
				PhysGrabCart componentInParent = val.GetComponentInParent<PhysGrabCart>();
				Collider componentInParent2 = ((Component)componentInParent).GetComponentInParent<Collider>();
				float num;
				if ((Object)(object)componentInParent2 == (Object)null)
				{
					num = 1f;
					((HelperLog)Utils.logger).LogWarning((object)"can't find collider");
				}
				else
				{
					Bounds bounds = componentInParent2.bounds;
					num = ((Bounds)(ref bounds)).size.y;
				}
				Rigidbody component = ((Component)componentInParent).GetComponent<Rigidbody>();
				if ((Object)(object)component == (Object)null)
				{
					((HelperLog)Utils.logger).LogWarning((object)"can't find rb");
					continue;
				}
				Vector3 val2 = ((Component)lastUsedPoint).transform.position + new Vector3(0f, num, 0f);
				Vector3 position = component.position;
				component.position = val2;
				TeleporInCartItems(componentInParent, val2, position);
			}
			return true;
		}

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

		internal static void TeleporInCartItems(PhysGrabCart cart, Vector3 newPos, Vector3 oldPos)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			List<PhysGrabObject> value = Traverse.Create((object)cart).Field<List<PhysGrabObject>>("itemsInCart").Value;
			if (value == null)
			{
				return;
			}
			Vector3 val = newPos - oldPos;
			foreach (PhysGrabObject item in value)
			{
				item.Teleport(((Component)item).transform.position + val, ((Component)item).transform.rotation);
			}
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class TeleportClosestCartToStart : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		private LevelPoint lastUsedPoint;

		public string Id => "teleport_cart_to_start";

		public bool Execute(IEnumerable<string> args)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return TeleportCart(((Component)GameUtils.LocalPlayer).transform.position);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return TeleportCart(((Component)targetPlayer).transform.position);
		}

		private bool TeleportCart(Vector3 basePos)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			lastUsedPoint = GameUtils.GetRandomLevelPoint(SemiFunc.LevelPointsGetInStartRoom(), lastUsedPoint);
			if ((Object)(object)lastUsedPoint == (Object)null)
			{
				return false;
			}
			((HelperLog)Utils.logger).LogInfo((object)$"target {((Component)lastUsedPoint).transform.position}");
			GameObject closestCart = GameUtils.GetClosestCart(basePos);
			if ((Object)(object)closestCart == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"can't find cart");
				return false;
			}
			PhysGrabCart componentInParent = closestCart.GetComponentInParent<PhysGrabCart>();
			Collider componentInParent2 = ((Component)componentInParent).GetComponentInParent<Collider>();
			float num;
			if ((Object)(object)componentInParent2 == (Object)null)
			{
				num = 1f;
				((HelperLog)Utils.logger).LogWarning((object)"can't find collider");
			}
			else
			{
				Bounds bounds = componentInParent2.bounds;
				num = ((Bounds)(ref bounds)).size.y;
			}
			Rigidbody component = ((Component)componentInParent).GetComponent<Rigidbody>();
			if ((Object)(object)component == (Object)null)
			{
				((HelperLog)Utils.logger).LogWarning((object)"can't find rb");
				return false;
			}
			Vector3 val = ((Component)lastUsedPoint).transform.position + new Vector3(0f, num, 0f);
			Vector3 position = component.position;
			component.position = val;
			TeleportCartsToStart.TeleporInCartItems(componentInParent, val, position);
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class TeleportPlayerToRandomRoom : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		private LevelPoint lastUsedPoint;

		public string Id => "teleport_player_rnd_point_rnd_room";

		public bool Execute(IEnumerable<string> args)
		{
			bool isMultiplayer = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadBool(false);
			TeleportPlayers(GameUtils.GetPlayerEventTargets(isMultiplayer));
			return true;
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			if (((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadBool(false))
			{
				TeleportPlayers(GameUtils.GetPlayerEventTargets(isMultiplayer: true));
			}
			else
			{
				TeleportPlayers(new List<PlayerAvatar> { targetPlayer });
			}
			return true;
		}

		private void TeleportPlayers(List<PlayerAvatar> players)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			List<LevelPoint> points = SemiFunc.LevelPointsGetAll();
			foreach (PlayerAvatar player in players)
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " process " + GameUtils.GetPlayerName(player)));
				lastUsedPoint = GameUtils.GetRandomLevelPoint(points, lastUsedPoint);
				if (!((Object)(object)lastUsedPoint == (Object)null))
				{
					((HelperLog)Utils.logger).LogInfo((object)$"target {((Component)lastUsedPoint).transform.position}");
					GameUtils.TeleportPlayer(player, ((Component)lastUsedPoint).transform.position, Quaternion.identity);
				}
			}
		}

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

		public string Id => "teleport_player_rnd_point_start_room";

		public bool Execute(IEnumerable<string> args)
		{
			bool isMultiplayer = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadBool(false);
			TeleportPlayers(GameUtils.GetPlayerEventTargets(isMultiplayer));
			return true;
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			if (((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadBool(false))
			{
				TeleportPlayers(GameUtils.GetPlayerEventTargets(isMultiplayer: true));
			}
			else
			{
				TeleportPlayers(new List<PlayerAvatar> { targetPlayer });
			}
			return true;
		}

		private void TeleportPlayers(List<PlayerAvatar> players)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] playerSpawnPoints = GameUtils.GetPlayerSpawnPoints();
			foreach (PlayerAvatar player in players)
			{
				((HelperLog)Utils.logger).LogInfo((object)(Id + " process " + GameUtils.GetPlayerName(player)));
				lastUsedPoint = GameUtils.GetRandomLevelPoint(playerSpawnPoints, lastUsedPoint);
				if (lastUsedPoint == Vector3.zero)
				{
					((HelperLog)Utils.logger).LogWarning((object)(Id + " zero point got. Executing skipped"));
					continue;
				}
				((HelperLog)Utils.logger).LogInfo((object)$"target {lastUsedPoint}");
				GameUtils.TeleportPlayer(player, lastUsedPoint, Quaternion.identity);
			}
		}

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

		public bool Execute(IEnumerable<string> args)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			if (ServiceProvider.inst.scheduleManager.IsTaskExists(Id))
			{
				((HelperLog)Utils.logger).LogWarning((object)(Id + " spams too much. Old teleport is not finished"));
				return true;
			}
			ServiceProvider.inst.scheduleManager.NewTimerTask(new TimerTaskData
			{
				id = Id,
				durationInSec = 1f,
				finishAction = delegate
				{
					//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
					List<PlayerAvatar> list = GameUtils.Players.Where((PlayerAvatar p) => (Object)(object)((Component)p).transform != (Object)null).ToList();
					List<GameUtils.Coords> list2 = Utils.ShuffleForceRandom(list.Select(delegate(PlayerAvatar p)
					{
						//IL_0010: Unknown result type (might be due to invalid IL or missing references)
						//IL_0015: Unknown result type (might be due to invalid IL or missing references)
						//IL_0022: Unknown result type (might be due to invalid IL or missing references)
						//IL_0027: Unknown result type (might be due to invalid IL or missing references)
						GameUtils.Coords result = default(GameUtils.Coords);
						result.pos = ((Component)p).transform.position;
						result.rot = ((Component)p).transform.rotation;
						return result;
					}));
					((HelperLog)Utils.logger).LogInfo((object)$"{Id} found {list.Count} players and {list2.Count} positions");
					if (list2.Count != list.Count)
					{
						((HelperLog)Utils.logger).LogError((object)(Id + " wrong arr sizes"));
					}
					else
					{
						for (int i = 0; i < list.Count; i++)
						{
							GameUtils.TeleportPlayer(list[i], list2[i].pos, list2[i].rot);
						}
					}
				}
			}, false);
			return true;
		}

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

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class UpgradePlayerCrouchRest : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_crouch_rest";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeCrouchRest;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerCrouchRest(s, 1);
	}
	internal class UpgradePlayerExtraJump : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_extra_jump";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeExtraJump;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerExtraJump(s, 1);
	}
	internal class UpgradePlayerGrabRange : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_grab_range";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeRange;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerGrabRange(s, 1);
	}
	internal class UpgradePlayerGrabStrength : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_grab_strength";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeStrength;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerGrabStrength(s, 1);
	}
	internal class UpgradePlayerHealth : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_health";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeHealth;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerHealth(s, 1);
	}
	internal class UpgradePlayerSprintSpeed : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_sprint_speed";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeSpeed;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerSprintSpeed(s, 1);
	}
	internal class UpgradePlayerStamina : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_stamina";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeStamina;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerEnergy(s, 1);
	}
	internal abstract class UpgradePlayerStatsBase : IRepoStandaloneCommand, IConsoleCommand, INetworkCommand
	{
		public abstract string Id { get; }

		public abstract Dictionary<string, int> Stats { get; }

		public abstract Func<string, int> UpgraderFunc { get; }

		public virtual bool Execute(IEnumerable<string> args)
		{
			return Execute(args, GameUtils.LocalPlayer);
		}

		public bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer)
		{
			int num = ((CommandArgsReader)new CommandArgsReaderWrapper(args)).ReadInt(1);
			((HelperLog)Utils.logger).LogInfo((object)$"{Id} upgrade count: {num}");
			string text = SemiFunc.PlayerGetSteamID(targetPlayer);
			Dictionary<string, int> stats = Stats;
			if (!stats.ContainsKey(text))
			{
				stats[text] = 0;
			}
			for (int i = 0; i < num; i++)
			{
				UpgraderFunc(text);
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			throw new NotImplementedException();
		}
	}
	internal class UpgradePlayerThrow : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_throw";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeThrow;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerThrowStrength(s, 1);
	}
	internal class UpgradePlayerTumbleLaunch : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_tumble_launch";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeLaunch;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerTumbleLaunch(s, 1);
	}
	internal class UpgradePlayerWings : UpgradePlayerStatsBase
	{
		public override string Id => "upgrade_player_wings";

		public override Dictionary<string, int> Stats => StatsManager.instance.playerUpgradeTumbleWings;

		public override Func<string, int> UpgraderFunc => (string s) => PunManager.instance.UpgradePlayerTumbleWings(s, 1);
	}
}
namespace REPO_BFT_BepInEx.Commands.Interfaces
{
	public interface INetworkCommand : IConsoleCommand
	{
		bool Execute(IEnumerable<string> args, PlayerAvatar targetPlayer);
	}
	public interface IRepoStandaloneCommand : IConsoleCommand
	{
	}
	public interface IRepoStandaloneCommandWithData : IRepoStandaloneCommand, IConsoleCommand, IConsoleCommandWithData
	{
	}
	public interface IForceEnd : IRepoStandaloneCommand, IConsoleCommand
	{
		bool IsActive { get; }

		void ForceEnd();
	}
	public interface IDuration : IRepoStandaloneCommand, IConsoleCommand
	{
		float DurationInSec { get; }
	}
}