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

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

		public string Cost { get; set; }

		public string EventID { get; set; }

		public string Lang { get; set; }

		public string ExtraInfo { get; set; }

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

		internal static readonly char clientAppSepChar = '&';

		internal static readonly string clientAppEqual = "=";

		internal static readonly char clientAppEqualChar = '=';

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

		string IEventsDataEncoderParams.ClientAppSep => clientAppSep;

		char IEventsDataEncoderParams.ClientAppSepChar => clientAppSepChar;

		string IEventsDataEncoderParams.ClientAppEqual => clientAppEqual;

		char IEventsDataEncoderParams.ClientAppEqualChar => clientAppEqualChar;

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

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

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

		public bool isLogInfoError = true;

		public bool isLogSkipEmpty;

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

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

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

		protected EventsData data;

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

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

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

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

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

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

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

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

		protected readonly IEventsDataParser parser;

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

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

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

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

		protected readonly float delay;

		protected float delayCounter;

		protected float initDelay;

		protected float initCounter;

		protected readonly float checkPeriod;

		protected float periodCounter;

		protected readonly Action<IEventsData> processEvent;

		protected readonly IEventsDataParser parser;

		protected IEnumerator<IEventsData> eventsData;

		protected readonly string path;

		private bool isDelayEveryProcessing;

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

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

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

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

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

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

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

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

		protected readonly Action<string> logError;

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

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

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

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

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

		string Cost { get; }

		string EventID { get; }

		string Lang { get; }

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

		char ClientAppSepChar { get; }

		string ClientAppEqual { get; }

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

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

		void SetEventID(string s);

		void SetCost(string s);

		void SetLang(string s);

		void SetExtraInfo(string s);

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

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

		bool IsProcessEnd();

		void ProcessAllWithDelayOnFrame(float dt);

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

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using EventsIO;
using EventsIO.Interfaces;
using HarmonyLib;
using ModHelper;
using ModHelper.Interfaces;
using ModHelperUnity;
using ModHelperUnity.Interfaces;
using ModHelperUnity.UtilityGUI;
using RoR2;
using RoR2.CharacterAI;
using RoR2.ConVar;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using WebSocketIO;
using ror2_interactive_mod.Commands;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ror2_interactive_mod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ror2_interactive_mod")]
[assembly: AssemblyCopyright("Copyright ©  2020")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("0fdefecb-0e54-4f2d-90d1-44b98749c3df")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ror2_interactive_mod
{
	internal class HelperUnit
	{
		public static void SpawnUnit(Vector3 pos, GameObject unitPrefab, EliteIndex eliteIndex, TeamIndex teamIndex = 2, bool braindead = false)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_001f: 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_002c: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Invalid comparison between Unknown and I4
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Invalid comparison between Unknown and I4
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = Object.Instantiate<GameObject>(unitPrefab, pos, Quaternion.identity);
				CharacterMaster component = val.GetComponent<CharacterMaster>();
				NetworkServer.Spawn(val);
				component.SpawnBody(pos, Quaternion.identity);
				if ((int)eliteIndex != -1)
				{
					component.inventory.SetEquipmentIndex(EliteCatalog.GetEliteDef(eliteIndex).eliteEquipmentDef.equipmentIndex);
					EliteTierDef tierDef = Tools.GetTierDef(eliteIndex);
					if (tierDef != null && tierDef.eliteTypes?.Length > 0)
					{
						EliteDef val2 = tierDef.eliteTypes[0];
						float num = (val2?.healthBoostCoefficient ?? 1f) * 10f;
						Tools.Logger.LogDebugInfo((object)$"healthBoostCoefficient {val2?.healthBoostCoefficient}");
						component.inventory.GiveItem(Items.BoostHp, Mathf.RoundToInt(num));
						num = (val2?.damageBoostCoefficient ?? 1f) * 10f;
						Tools.Logger.LogDebugInfo((object)$"damageBoostCoefficient {val2?.damageBoostCoefficient}");
						component.inventory.GiveItem(Items.BoostDamage, Mathf.RoundToInt(num));
					}
				}
				GameObject bodyObject = component.GetBodyObject();
				DeathRewards val3 = bodyObject.GetComponent<DeathRewards>();
				if ((Object)(object)val3 == (Object)null)
				{
					Tools.Log("add rewards");
					val3 = bodyObject.AddComponent<DeathRewards>();
				}
				val3.expReward = (uint)(0.4f * Run.instance.compensatedDifficultyCoefficient);
				if (val3.expReward < 3)
				{
					val3.expReward = 3u;
				}
				val3.goldReward = (uint)(0.8f * Run.instance.compensatedDifficultyCoefficient);
				if (val3.goldReward < 3)
				{
					val3.goldReward = 3u;
				}
				if (braindead)
				{
					Object.Destroy((Object)(object)((Component)component).GetComponent<BaseAI>());
				}
				if ((int)teamIndex >= -1 && (int)teamIndex < 5)
				{
					component.teamIndex = teamIndex;
					component.GetBody().teamComponent.teamIndex = teamIndex;
				}
			}
			catch (Exception arg)
			{
				Tools.Log($"SpawnUnit error: {arg}");
			}
		}

		public static string GetBodyName(string name)
		{
			if (name == null)
			{
				Tools.Log("GetBodyName error: incorrect name " + name);
				return string.Empty;
			}
			try
			{
				int num = 0;
				foreach (CharacterBody allBodyPrefabBodyBodyComponent in BodyCatalog.allBodyPrefabBodyBodyComponents)
				{
					if ((Object)(object)allBodyPrefabBodyBodyComponent == (Object)null || ((Object)allBodyPrefabBodyBodyComponent).name == null)
					{
						num++;
						continue;
					}
					if ((int.TryParse(name, out var result) && num == result) || ((Object)allBodyPrefabBodyBodyComponent).name.Equals(name, StringComparison.InvariantCultureIgnoreCase) || ((Object)allBodyPrefabBodyBodyComponent).name.ToLower().Replace("body", string.Empty).Equals(name, StringComparison.InvariantCultureIgnoreCase))
					{
						return ((Object)allBodyPrefabBodyBodyComponent).name;
					}
					num++;
				}
			}
			catch (Exception arg)
			{
				Tools.Log($"GetBodyName error: {arg}");
			}
			return string.Empty;
		}

		public static string GetMasterName(string name)
		{
			if (name == null)
			{
				Tools.Log("GetMasterName error: incorrect name");
				return string.Empty;
			}
			try
			{
				int num = 0;
				IEnumerable<CharacterMaster> allAiMasters = MasterCatalog.allAiMasters;
				if (allAiMasters == null)
				{
					Tools.Log("GetMasterName error: MasterCatalog.allAiMasters");
					return string.Empty;
				}
				foreach (CharacterMaster item in allAiMasters)
				{
					if ((Object)(object)item == (Object)null || ((Object)item).name == null)
					{
						num++;
						continue;
					}
					if ((int.TryParse(name, out var result) && num == result) || ((Object)item).name.Equals(name, StringComparison.InvariantCultureIgnoreCase) || ((Object)item).name.ToLower().Replace("master", string.Empty).Equals(name, StringComparison.InvariantCultureIgnoreCase))
					{
						return ((Object)item).name;
					}
					num++;
				}
			}
			catch (Exception arg)
			{
				Tools.Log($"GetMasterName error: {arg}");
			}
			return string.Empty;
		}
	}
	public class HelperEquip
	{
		public static EquipmentIndex GetEquipFromString(string name)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return EquipmentCatalog.FindEquipmentIndex(name);
			}
			catch (Exception arg)
			{
				Tools.Log($"GetEquipFromString error: {arg}");
			}
			return (EquipmentIndex)(-1);
		}

		public static ItemIndex GetItemFromString(string name)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ItemCatalog.FindItemIndex(name);
			}
			catch (Exception arg)
			{
				Tools.Log($"GetItemFromString error: {arg}");
			}
			return (ItemIndex)(-1);
		}
	}
	public class InteractiveMod
	{
		private WebSocketEventsReader<SettingsData> eventsReader;

		private IEventsReaderOnKey eventsReaderByKey;

		private IEventsDataParser eventsParser;

		private ICommandManager commandManager;

		private ITranslation translateManager;

		private IComponentTypedNotify notifyManager;

		private string keyEventsPath;

		private bool isNeedFirstInit = true;

		private bool isQuiting;

		private GameObject gameObject;

		private Dictionary<string, ICommandExecutor> commandsDict;

		private float firstDelay = 4f;

		public InteractiveMod(BepInExPlugin plugin)
		{
			gameObject = ((Component)plugin).gameObject;
		}

		public void Awake()
		{
			Tools.Log("InteractiveMod Awake");
			MainPatcher.InitPatch();
		}

		public void OnDestroy()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			Tools.Log("InteractiveMod OnDestroy");
			if (!isQuiting)
			{
				Tools.Log("InteractiveMod reinit mod script");
				GameObject val = new GameObject();
				val.AddComponent(typeof(InteractiveMod));
				val.SetActive(true);
				Loader.HookObj = val;
			}
		}

		public void OnApplicationQuit()
		{
			Tools.Log("InteractiveMod OnApplicationQuit");
			isQuiting = true;
		}

		public void InitCommandsWithNotify()
		{
			commandsDict = new Dictionary<string, ICommandExecutor>
			{
				{
					"spawn_as",
					new CommandChangeBody()
				},
				{
					"give_equip",
					new CommandGiveEquip()
				},
				{
					"give_item",
					new CommandGiveItem()
				},
				{
					"kill_all",
					new CommandKillAll()
				},
				{
					"remove_item",
					new CommandRemoveItem()
				},
				{
					"spawn_ai",
					new CommandSpawnAI()
				},
				{
					"give_item_or_equip",
					new CommandGiveItemOrEquip()
				}
			};
		}

		private string GetBasePath(string filename)
		{
			return Path.Combine(UtilitySettings.BaseFolder, filename);
		}

		public void InitCommands()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			Tools.Log("init HelperCommandManager");
			commandManager = (ICommandManager)new HelperCommandManagerFormatted(Tools.Logger);
			commandManager.InitFromFile(GetBasePath("commands.data"));
			Tools.Log("init HelperLanguages");
			translateManager = (ITranslation)new HelperLanguagesFormatted(Tools.Logger);
			translateManager.InitFromFile(GetBasePath("langs.data"));
			InitCommandsWithNotify();
		}

		public void Start()
		{
			Tools.Log("InteractiveMod OnStart");
		}

		public void FirstInit()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			Tools.Log("FirstInit");
			eventsParser = (IEventsDataParser)new EventsDataParser((Action<string>)Tools.Log);
			Tools.Log("init EventsReaderOnFrame");
			if (eventsReader == null)
			{
				eventsReader = new WebSocketEventsReader<SettingsData>((Action<IEventsData>)ProcessEvent, eventsParser, (Action<string>)Tools.Log, (Action<string>)Tools.Log, 1f, 1f, 0.5f);
				eventsReader.InitDefaultSocket(UtilitySettings.BaseFolder, "chaostricks_ror2", 13715, "127.0.0.1");
				eventsReader.OpenSocket(true);
			}
			Tools.Log("init EventsReaderOnKey");
			keyEventsPath = GetBasePath("events_key.txt");
			eventsReaderByKey = (IEventsReaderOnKey)new EventsReaderOnKey((Action<IEventsData>)ProcessEvent, eventsParser, (Action<string>)Tools.Log, (Action<string>)null);
			InitCommands();
			if (notifyManager == null)
			{
				notifyManager = (IComponentTypedNotify)(object)gameObject.AddComponent<TypedNotifyOnGUI>();
			}
			IComponentTypedNotify obj = notifyManager;
			if (obj != null)
			{
				obj.PostInit(UtilitySettings.BaseFolder, Tools.Logger, (Func<string, byte[]>)null);
			}
			SettingsManager.LoadSettings();
			Tools.Log("InteractiveMod init ended (1.0.0)");
		}

		private bool ExecuteCommandOnePlayer(ICommandExecutor command, ConCommandArgs args)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Tools.Log("run command for single player");
			args.sender = NetworkUser.readOnlyLocalPlayersList[0];
			try
			{
				command.Execute(args);
				return true;
			}
			catch (Exception arg)
			{
				Tools.Log($"command run error: {arg}");
				return false;
			}
		}

		private bool ExecuteCommandAllPlayers(ICommandExecutor command, ConCommandArgs args)
		{
			//IL_009e: 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)
			if (SettingsManager.Data.isAllPlayers)
			{
				bool result = true;
				foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
				{
					try
					{
						Tools.Log("run command for player " + readOnlyInstances?.userName);
						args.sender = readOnlyInstances;
						command.Execute(args);
					}
					catch (Exception arg)
					{
						Tools.Log($"run command for player {readOnlyInstances?.userName} error: {arg}");
						result = false;
					}
				}
				return result;
			}
			return ExecuteCommandOnePlayer(command, args);
		}

		private bool ExecuteCommand(ICommandExecutor command, string[] args)
		{
			//IL_0024: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			Tools.EnableCheats();
			Tools.Log("command: '" + ((ICommand)command).Id + "'");
			ConCommandArgs args2 = default(ConCommandArgs);
			List<string> list = new List<string>(args);
			list.RemoveAt(0);
			args2.userArgs = list;
			if (command is ICommandTargets)
			{
				return ExecuteCommandAllPlayers(command, args2);
			}
			return ExecuteCommandOnePlayer(command, args2);
		}

		private void ProcessEvent(IEventsData data)
		{
			string eventID = data.EventID;
			if (string.IsNullOrWhiteSpace(eventID))
			{
				return;
			}
			if (eventID == UtilitySettings.CommandUpdateSettingsID)
			{
				SettingsManager.LoadSettings();
				Tools.Log("settings reloaded");
				return;
			}
			Tools.Log("try to execute event: '" + eventID + "'");
			string text = string.Empty;
			string commandData = commandManager.GetCommandData(eventID, true);
			string[] array = commandData.Split();
			if (array.Length != 0)
			{
				text = array[0].Trim();
			}
			if (commandsDict.TryGetValue(text, out var value))
			{
				if (!ExecuteCommand(value, array))
				{
					Tools.Log("event '" + eventID + "' executing is failed");
				}
			}
			else
			{
				Tools.Log("command not found " + text);
			}
			Tools.Log("event '" + eventID + "' executing is completed");
			ICommandNotify val = (ICommandNotify)((value is ICommandNotify) ? value : null);
			if (val != null)
			{
				IComponentTypedNotify obj = notifyManager;
				if (obj != null)
				{
					obj.AddNotifyToQueue(data, translateManager, (Func<string, string>)val.ProcessMsg);
				}
			}
			else
			{
				IComponentTypedNotify obj2 = notifyManager;
				if (obj2 != null)
				{
					obj2.AddNotifyToQueue(data, translateManager, (Func<string, string>)null);
				}
			}
		}

		public bool IsAllPlayersDeadAndNoLifes(IReadOnlyCollection<NetworkUser> list)
		{
			if (list == null)
			{
				return true;
			}
			foreach (NetworkUser item in list)
			{
				if (item != null)
				{
					CharacterMaster master = item.master;
					if (((master != null) ? new bool?(master.IsDeadAndOutOfLivesServer()) : null) == false)
					{
						return false;
					}
				}
			}
			return true;
		}

		public bool IsNotReadyForCheckEvent()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			int num = NetworkUser.readOnlyLocalPlayersList?.Count ?? 0;
			if (num <= 0)
			{
				return true;
			}
			ReadOnlyCollection<NetworkUser> readOnlyInstancesList = NetworkUser.readOnlyInstancesList;
			if (readOnlyInstancesList != null && readOnlyInstancesList.Count > 1)
			{
				if (IsAllPlayersDeadAndNoLifes(NetworkUser.readOnlyInstancesList))
				{
					return true;
				}
			}
			else if (IsAllPlayersDeadAndNoLifes(NetworkUser.readOnlyLocalPlayersList))
			{
				return true;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name?.ToLower();
			return "intro" == text || "title" == text || "lobby" == text || MasterCatalog.allAiMasters == null;
		}

		public void Update()
		{
			//IL_00fd: 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)
			if (Input.GetKeyDown((KeyCode)278))
			{
				InitCommands();
			}
			if (IsNotReadyForCheckEvent())
			{
				return;
			}
			if (isNeedFirstInit)
			{
				FirstInit();
				isNeedFirstInit = false;
			}
			firstDelay -= Time.deltaTime;
			if (firstDelay > 0f)
			{
				return;
			}
			if (Input.GetKey((KeyCode)306) && Input.GetKeyDown((KeyCode)261))
			{
				eventsReaderByKey.ReadAndProcessAllOnKey(keyEventsPath, false);
			}
			if (Input.GetKey((KeyCode)306) && Input.GetKeyDown((KeyCode)112))
			{
				try
				{
					NetworkUser val = NetworkUser.readOnlyLocalPlayersList[0];
					CharacterBody body = val.master.GetBody();
					if (Object.op_Implicit((Object)(object)((body != null) ? body.healthComponent : null)))
					{
						body.healthComponent.Suicide((GameObject)null, (GameObject)null, default(DamageTypeCombo));
					}
				}
				catch (Exception arg)
				{
					((ILogger)Tools.Logger).Log((object)$"Selfkill error: {arg}");
				}
			}
			((EventsReaderOnFrame)eventsReader).ReadAndProcessAllWithDelayOnFrame(Time.deltaTime);
		}
	}
	internal interface ICommandExecutor : ICommand
	{
		void Execute(ConCommandArgs args);
	}
	public class MainPatcher
	{
		public static void InitPatch()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			try
			{
				((ILogger)Tools.Logger).Log((object)"HelperPatcher init");
				Harmony val = new Harmony("com.Loki.patch");
				val.PatchAll();
			}
			catch (Exception arg)
			{
				((ILogger)Tools.Logger).Log((object)$"HelperPatcher error: {arg}");
			}
		}
	}
	public class SettingsData
	{
		public bool isAllPlayers = true;
	}
	public class SettingsManager
	{
		private static SettingsData data = new SettingsData();

		public static SettingsData Data => data;

		public static void LoadSettings()
		{
			try
			{
				SettingsData settingsData = UtilitySettings.LoadSettings<SettingsData>(Tools.Logger);
				if (settingsData != null)
				{
					data = settingsData;
				}
				else
				{
					Tools.Log("LoadSettings using default.");
				}
			}
			catch (Exception arg)
			{
				Tools.Log($"LoadSettings error: {arg}");
			}
		}
	}
	[BepInPlugin("bft.chaostricks", "Chaos Tricks", "1.0.0")]
	public class BepInExPlugin : BaseUnityPlugin
	{
		private ManualLogSource loggerHook;

		private InteractiveMod mod;

		public const string pluginGuid = "bft.chaostricks";

		public const string pluginName = "Chaos Tricks";

		public const string pluginVersion = "1.0.0";

		public void Awake()
		{
			loggerHook = ((BaseUnityPlugin)this).Logger;
			try
			{
				UtilitySettings.BaseFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				((ILogger)Tools.Logger).LogClear();
			}
			catch (Exception ex)
			{
				ManualLogSource obj = loggerHook;
				if (obj != null)
				{
					obj.LogError((object)ex);
				}
			}
			mod = new InteractiveMod(this);
			mod.Awake();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"plugin init finished");
		}

		public void OnDestroy()
		{
			mod?.OnDestroy();
		}

		public void Start()
		{
			mod?.Start();
		}

		public void Update()
		{
			mod?.Update();
		}
	}
	public static class Tools
	{
		private static readonly Lazy<IDebugLogger> instance;

		public static IDebugLogger Logger => instance.Value;

		public static IParseManager ParseManager { get; }

		static Tools()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			instance = new Lazy<IDebugLogger>((Func<IDebugLogger>)(() => (IDebugLogger)new BufferedLogger(UtilitySettings.BaseFolder, "interactive_mod_log.txt", true, 50)));
			ParseManager = (IParseManager)new HelperParse((ILogger)(object)Logger);
		}

		public static void Log(string text)
		{
			((ILogger)Logger).Log((object)text);
		}

		public static bool EnableCheats()
		{
			try
			{
				if (CheatsConVar.instance.boolValue)
				{
					return true;
				}
				Log("try to enable cheats");
				Type type = ((object)CheatsConVar.instance).GetType();
				if (type == null)
				{
					Log("can't get type");
					return false;
				}
				FieldInfo field = type.GetField("_boolValue", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					Log("can't get field1");
					return false;
				}
				field.SetValue(CheatsConVar.instance, true);
				((BaseConVar)CheatsConVar.instance).SetString("1");
				return CheatsConVar.instance.boolValue;
			}
			catch (Exception arg)
			{
				Log($"cheats enable error: {arg}");
			}
			return false;
		}

		public static EliteTierDef GetTierDef(EliteIndex index)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0088: 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)
			try
			{
				object value = typeof(CombatDirector).GetField("eliteTiers").GetValue(null);
				EliteTierDef[] array = (EliteTierDef[])value;
				if (array == null)
				{
					Log("GetTierDef error: can't get tiers");
					return null;
				}
				if ((int)index <= -1 || (int)index >= EliteCatalog.eliteList.Count)
				{
					Log("GetTierDef error: index out");
					return null;
				}
				int num = 0;
				for (int i = 0; i < array.Length; i++)
				{
					for (int j = 0; j < array[i].eliteTypes.Length; j++)
					{
						if (array[i].eliteTypes[j].eliteIndex == index)
						{
							num = i;
							break;
						}
					}
				}
				return array[num];
			}
			catch (Exception arg)
			{
				Log($"GetTierDef error: {arg}");
				return null;
			}
		}

		public static List<string> GetItemsFromFileByListName(string listName, bool isCreateFileIfNotExist = true)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			string text = null;
			try
			{
				text = Path.Combine(UtilitySettings.BaseFolder, listName + ".data");
				HelperJson val = new HelperJson(Logger, false);
				List<string> list = val.FromFile<List<string>>(text);
				if (list == null)
				{
					list = new List<string>();
				}
				Log($"Items from file: found {listName} {list.Count}");
				foreach (string item in list)
				{
					Log("found value: " + item);
				}
				return list;
			}
			catch (FileNotFoundException)
			{
				if (isCreateFileIfNotExist)
				{
					try
					{
						File.Create(text);
					}
					catch (Exception arg)
					{
						Log($"Items from file: create file error {arg}");
					}
				}
			}
			catch (Exception arg2)
			{
				Log($"Items from file: load error {arg2}");
			}
			return new List<string>();
		}

		private static string GetTabs(string text, int stringMaxLength)
		{
			return new string(' ', stringMaxLength - text.Length + 4);
		}

		public static void DebugPrintPrefabs()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Items:");
			GenericStaticEnumerable<ItemIndex, AllItemsEnumerator> allItems = ItemCatalog.allItems;
			AllItemsEnumerator enumerator = allItems.GetEnumerator();
			try
			{
				while (((AllItemsEnumerator)(ref enumerator)).MoveNext())
				{
					ItemIndex current = ((AllItemsEnumerator)(ref enumerator)).Current;
					ItemDef itemDef = ItemCatalog.GetItemDef(current);
					string localizedStringByToken = Language.currentLanguage.GetLocalizedStringByToken(itemDef.nameToken);
					string tabs = GetTabs(((object)(ItemIndex)(ref current)).ToString(), 3);
					string tabs2 = GetTabs(((Object)itemDef).name, 25);
					stringBuilder.AppendLine($"Item: index {current}{tabs}prefabName {((Object)itemDef).name}{tabs2}gameName {localizedStringByToken}");
				}
			}
			finally
			{
				((IDisposable)(AllItemsEnumerator)(ref enumerator)).Dispose();
			}
			stringBuilder.AppendLine("\n---------------\nEquipments:");
			GenericStaticEnumerable<EquipmentIndex, AllEquipmentEnumerator> allEquipment = EquipmentCatalog.allEquipment;
			AllEquipmentEnumerator enumerator2 = allEquipment.GetEnumerator();
			try
			{
				while (((AllEquipmentEnumerator)(ref enumerator2)).MoveNext())
				{
					EquipmentIndex current2 = ((AllEquipmentEnumerator)(ref enumerator2)).Current;
					EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(current2);
					string localizedStringByToken2 = Language.currentLanguage.GetLocalizedStringByToken(equipmentDef.nameToken);
					string tabs3 = GetTabs(((object)(EquipmentIndex)(ref current2)).ToString(), 3);
					string tabs4 = GetTabs(((Object)equipmentDef).name, 20);
					stringBuilder.AppendLine($"Equipment: index {current2}{tabs3}prefabName {((Object)equipmentDef).name}{tabs4}name {localizedStringByToken2}");
				}
			}
			finally
			{
				((IDisposable)(AllEquipmentEnumerator)(ref enumerator2)).Dispose();
			}
			stringBuilder.AppendLine("\n---------------\nMasters:");
			foreach (CharacterMaster allMaster in MasterCatalog.allMasters)
			{
				string tabs5 = GetTabs(((Object)allMaster.bodyPrefab).name, 22);
				stringBuilder.AppendLine("nMasters: bodyName " + ((Object)allMaster.bodyPrefab).name + tabs5 + "prefabName " + ((Object)allMaster).name);
			}
			stringBuilder.AppendLine("\n---------------\nMasters AI:");
			foreach (CharacterMaster allAiMaster in MasterCatalog.allAiMasters)
			{
				string tabs6 = GetTabs(((Object)allAiMaster.bodyPrefab).name, 22);
				stringBuilder.AppendLine("Masters AI: index " + ((Object)allAiMaster.bodyPrefab).name + tabs6 + "prefabName " + ((Object)allAiMaster).name);
			}
			stringBuilder.AppendLine("\n---------------\nBody models:");
			foreach (CharacterBody allBodyPrefabBodyBodyComponent in BodyCatalog.allBodyPrefabBodyBodyComponents)
			{
				string bodyName = HelperUnit.GetBodyName(((Object)allBodyPrefabBodyBodyComponent).name);
				string tabs7 = GetTabs(((object)(BodyIndex)(ref allBodyPrefabBodyBodyComponent.bodyIndex)).ToString(), 3);
				string tabs8 = GetTabs(((Object)allBodyPrefabBodyBodyComponent).name, 28);
				stringBuilder.AppendLine($"Equipment: index {allBodyPrefabBodyBodyComponent.bodyIndex}{tabs7}prefabName {((Object)allBodyPrefabBodyBodyComponent).name}{tabs8}{bodyName}");
			}
			Log(stringBuilder.ToString());
		}
	}
}
namespace ror2_interactive_mod.Commands
{
	public class CommandGiveItemOrEquip : ICommandExecutor, ICommand, ICommandNotify, ICommandTargets
	{
		public const string name = "give_item_or_equip";

		private const string itemsRandomName = "RandomBlue";

		private readonly List<string> itemsRandom;

		private EquipmentIndex lastEquip;

		private ItemIndex lastItem;

		private bool lastIsItem;

		public string Id => "give_item_or_equip";

		public bool IsAllPlayers { get; set; } = true;


		public CommandGiveItemOrEquip()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			itemsRandom = Tools.GetItemsFromFileByListName("RandomBlue");
			for (int num = itemsRandom.Count - 1; num >= 0; num--)
			{
				string text = itemsRandom[num];
				if ((int)HelperEquip.GetEquipFromString(text) == -1 && (int)HelperEquip.GetItemFromString(text) == -1)
				{
					Tools.Log("Command give_item_or_equip error: missed equip or item - " + text + " in category RandomBlue");
					itemsRandom.RemoveAt(num);
				}
			}
		}

		public string ProcessMsg(string msg)
		{
			//IL_0023: 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)
			try
			{
				string text = ((!lastIsItem) ? EquipmentCatalog.GetEquipmentDef(lastEquip).nameToken : ItemCatalog.GetItemDef(lastItem).nameToken);
				string localizedStringByToken = Language.currentLanguage.GetLocalizedStringByToken(text);
				msg = msg.Replace("%value%", localizedStringByToken);
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} process msg error: {1}", "give_item_or_equip", arg));
			}
			return msg;
		}

		public void Execute(ConCommandArgs args)
		{
			//IL_0023: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00c7: Invalid comparison between Unknown and I4
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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_00fe: Invalid comparison between Unknown and I4
			//IL_00d5: 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)
			try
			{
				if (((ConCommandArgs)(ref args)).Count < 1)
				{
					Tools.Log("Command give_item_or_equip wrong args count");
					return;
				}
				NetworkUser sender = args.sender;
				if ((Object)(object)sender == (Object)null)
				{
					Tools.Log("Command give_item_or_equip, error: player not found");
					return;
				}
				NetworkUser sender2 = args.sender;
				Inventory val = ((sender2 != null) ? sender2.master.inventory : null);
				if ((Object)(object)val == (Object)null)
				{
					Tools.Log("Command give_item_or_equip, error: inventory not found");
					return;
				}
				string text = ((ConCommandArgs)(ref args))[0];
				string text2 = ((!text.Equals("RandomBlue", StringComparison.InvariantCultureIgnoreCase)) ? text : UtilityRandom.GetRandomItemFromList<string>((IList<string>)itemsRandom));
				lastItem = (ItemIndex)(-1);
				lastEquip = HelperEquip.GetEquipFromString(text2);
				if ((int)lastEquip != -1)
				{
					val.SetEquipmentIndex(lastEquip);
					lastIsItem = false;
				}
				else
				{
					lastItem = HelperEquip.GetItemFromString(text2);
					if ((int)lastItem != -1)
					{
						val.GiveItem(lastItem, 1);
						lastIsItem = true;
					}
					else
					{
						Tools.Log("Command give_item_or_equip, error: item/equip not found " + ((ConCommandArgs)(ref args))[0] + " : " + text2);
					}
				}
				Tools.Log("Command give_item_or_equip: player " + sender.masterController.GetDisplayName() + " got " + text2);
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} error: {1}", "give_item_or_equip", arg));
			}
		}
	}
	public class CommandGiveItem : ICommandExecutor, ICommand, ICommandNotify, ICommandTargets
	{
		public const string name = "give_item";

		private readonly Dictionary<string, List<string>> itemsLists;

		private readonly string[] listNames = new string[5] { "RandomWhite", "RandomGreen", "RandomYellow", "RandomRed", "RandomAll" };

		private ItemIndex lastItem;

		public bool IsAllPlayers { get; set; } = true;


		public string Id => "give_item";

		public CommandGiveItem()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Invalid comparison between Unknown and I4
			itemsLists = new Dictionary<string, List<string>>(listNames.Length);
			string[] array = listNames;
			foreach (string text in array)
			{
				List<string> itemsFromFileByListName = Tools.GetItemsFromFileByListName(text);
				itemsLists[text] = itemsFromFileByListName;
				for (int num = itemsFromFileByListName.Count - 1; num >= 0; num--)
				{
					string text2 = itemsFromFileByListName[num];
					if ((int)HelperEquip.GetItemFromString(text2) == -1)
					{
						Tools.Log("Command " + Id + " error: missed item - " + text2 + " in category " + text);
						itemsFromFileByListName.RemoveAt(num);
					}
				}
			}
		}

		public string ProcessMsg(string msg)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ItemDef itemDef = ItemCatalog.GetItemDef(lastItem);
				string localizedStringByToken = Language.currentLanguage.GetLocalizedStringByToken(itemDef.nameToken);
				msg = msg.Replace("%value%", localizedStringByToken);
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} process msg error: {1}", "give_item", arg));
			}
			return msg;
		}

		public void Execute(ConCommandArgs args)
		{
			//IL_0023: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Invalid comparison between Unknown and I4
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (((ConCommandArgs)(ref args)).Count < 1)
				{
					Tools.Log("Command give_item wrong args count");
					return;
				}
				NetworkUser sender = args.sender;
				if ((Object)(object)sender == (Object)null)
				{
					Tools.Log("Command give_item, error: player not found");
					return;
				}
				NetworkUser sender2 = args.sender;
				Inventory val = ((sender2 != null) ? sender2.master.inventory : null);
				if ((Object)(object)val == (Object)null)
				{
					Tools.Log("Command give_item, error: inventory not found");
					return;
				}
				if (((ConCommandArgs)(ref args)).Count < 2 || !int.TryParse(((ConCommandArgs)(ref args))[1], out var result))
				{
					result = 1;
				}
				string text = ((ConCommandArgs)(ref args))[0];
				string text2 = ((!itemsLists.ContainsKey(text)) ? text : UtilityRandom.GetRandomItemFromList<string>((IList<string>)itemsLists[text]));
				ItemIndex val2 = (lastItem = HelperEquip.GetItemFromString(text2));
				if ((int)val2 != -1)
				{
					val.GiveItem(val2, result);
					Tools.Log(string.Format("Command {0}: player {1} got {2} named {3}", "give_item", sender.masterController.GetDisplayName(), val2, text2));
				}
				else
				{
					Tools.Log("Command give_item, error: item " + text2 + " from " + text + " not found");
				}
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} error: {1}", "give_item", arg));
			}
		}
	}
	public class CommandSpawnAI : ICommandExecutor, ICommand, ICommandNotify, ICommandTargets
	{
		public const string name = "spawn_ai";

		private readonly Dictionary<string, List<string>> enemiesLists;

		private readonly string[] listNames = new string[2] { "T1Mobs", "T2Mobs" };

		public string Id => "spawn_ai";

		public bool IsAllPlayers { get; set; } = true;


		public CommandSpawnAI()
		{
			enemiesLists = new Dictionary<string, List<string>>(listNames.Length);
			string[] array = listNames;
			foreach (string text in array)
			{
				List<string> itemsFromFileByListName = Tools.GetItemsFromFileByListName(text);
				enemiesLists[text] = itemsFromFileByListName;
				for (int num = itemsFromFileByListName.Count - 1; num >= 0; num--)
				{
					string text2 = itemsFromFileByListName[num];
					if ((Object)(object)GetUnitPrefabByName(text2, text) == (Object)null)
					{
						Tools.Log("Command " + Id + " error: missed enemy - " + text2 + " in category " + text);
						itemsFromFileByListName.RemoveAt(num);
					}
				}
			}
		}

		public string ProcessMsg(string msg)
		{
			return msg;
		}

		private GameObject GetUnitPrefabByName(string unitName, string categoryTextLog = null)
		{
			string text = ((categoryTextLog == null) ? string.Empty : (" in category " + categoryTextLog));
			if (string.IsNullOrWhiteSpace(unitName))
			{
				Tools.Log("Command spawn_ai error: missed mob with name " + unitName + text);
				return null;
			}
			string masterName = HelperUnit.GetMasterName(unitName);
			GameObject val = MasterCatalog.FindMasterPrefab(masterName);
			if ((Object)(object)val == (Object)null)
			{
				Tools.Log("Command spawn_ai error: missed prefab for mob " + masterName + " with name " + unitName + text);
				return null;
			}
			return val;
		}

		private GameObject GetUnitPrefab(string unitCategory)
		{
			string unitName = ((!enemiesLists.ContainsKey(unitCategory)) ? unitCategory : UtilityRandom.GetRandomItemFromList<string>((IList<string>)enemiesLists[unitCategory]));
			return GetUnitPrefabByName(unitName, unitCategory);
		}

		public void Execute(ConCommandArgs args)
		{
			//IL_0023: 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_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (((ConCommandArgs)(ref args)).Count < 1)
				{
					Tools.Log("Command spawn_ai wrong args count");
					return;
				}
				NetworkUser sender = args.sender;
				NetworkUser sender2 = args.sender;
				Inventory val = ((sender2 != null) ? sender2.master.inventory : null);
				if ((Object)(object)sender == (Object)null)
				{
					Tools.Log("Command spawn_ai, error: player not found");
					return;
				}
				float result = 1f;
				if (((ConCommandArgs)(ref args)).Count > 1 && !float.TryParse(((ConCommandArgs)(ref args))[1], out result))
				{
					Tools.Log("Command spawn_ai can't parse spawn range min offset " + ((ConCommandArgs)(ref args))[1]);
					return;
				}
				float result2 = 2f;
				if (((ConCommandArgs)(ref args)).Count > 2 && !float.TryParse(((ConCommandArgs)(ref args))[2], out result2))
				{
					Tools.Log("Command spawn_ai can't parse spawn range max offset " + ((ConCommandArgs)(ref args))[2]);
					return;
				}
				if (result > result2)
				{
					Tools.Log(string.Format("Command {0} error: spawn range min offset {1} > max offset {2}", "spawn_ai", result, result2));
					return;
				}
				int result3 = 1;
				if (((ConCommandArgs)(ref args)).Count > 3 && !int.TryParse(((ConCommandArgs)(ref args))[3], out result3))
				{
					Tools.Log("Command spawn_ai can't parse count of unit " + ((ConCommandArgs)(ref args))[3]);
					return;
				}
				if (result3 <= 0)
				{
					Tools.Log(string.Format("Command {0} error: incorrect count {1}", "spawn_ai", result3));
					return;
				}
				EliteIndex eliteIndex = default(EliteIndex);
				if (((ConCommandArgs)(ref args)).Count <= 4 || !Tools.ParseManager.TryParseEnum<EliteIndex>(((ConCommandArgs)(ref args))[4], ref eliteIndex, (EliteIndex)0))
				{
					eliteIndex = (EliteIndex)(-1);
				}
				bool braindead = default(bool);
				if (((ConCommandArgs)(ref args)).Count <= 5 || !Tools.ParseManager.TryParseBool(((ConCommandArgs)(ref args))[5], ref braindead, false))
				{
					braindead = false;
				}
				TeamIndex teamIndex = default(TeamIndex);
				if (((ConCommandArgs)(ref args)).Count <= 6 || !Tools.ParseManager.TryParseEnum<TeamIndex>(((ConCommandArgs)(ref args))[6], ref teamIndex, (TeamIndex)0))
				{
					teamIndex = (TeamIndex)2;
				}
				string text = ((ConCommandArgs)(ref args))[0];
				for (int i = 0; i < result3; i++)
				{
					Vector3 position = ((Component)sender.master.GetBody()).transform.position;
					int num = ((text == "ClayBoss") ? 5 : 2);
					Vector3 val2 = position;
					float num2 = result;
					float num3 = result2;
					float num4 = num;
					LayerIndex world = LayerIndex.world;
					position = MathUtility.FindRandomSpawnPointNearPositionFixY(val2, num2, num3, num4, ((LayerIndex)(ref world)).mask);
					GameObject unitPrefab = GetUnitPrefab(text);
					HelperUnit.SpawnUnit(position, unitPrefab, eliteIndex, teamIndex, braindead);
					Tools.Log("Command spawn_ai spawn " + ((Object)unitPrefab).name);
				}
				Tools.Log(string.Format("Command {0} total spawns count {1}", "spawn_ai", result3));
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} error: {1}", "spawn_ai", arg));
			}
		}
	}
	public class CommandRemoveItem : ICommandExecutor, ICommand, ICommandNotify, ICommandTargets
	{
		public const string name = "remove_item";

		public string Id => "remove_item";

		public bool IsAllPlayers { get; set; } = true;


		public string ProcessMsg(string msg)
		{
			return msg;
		}

		public void Execute(ConCommandArgs args)
		{
			//IL_0023: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Invalid comparison between Unknown and I4
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (((ConCommandArgs)(ref args)).Count < 1)
				{
					Tools.Log("Command remove_item wrong args count");
					return;
				}
				NetworkUser sender = args.sender;
				if ((Object)(object)sender == (Object)null)
				{
					Tools.Log("Command remove_item, error: player not found");
					return;
				}
				NetworkUser sender2 = args.sender;
				Inventory val = ((sender2 != null) ? sender2.master.inventory : null);
				if ((Object)(object)val == (Object)null)
				{
					Tools.Log("Command remove_item, error: inventory not found");
					return;
				}
				if ("all".Equals(((ConCommandArgs)(ref args))[0], StringComparison.InvariantCultureIgnoreCase))
				{
					val.CopyItemsFrom(new GameObject().AddComponent<Inventory>());
					Tools.Log("Command remove_item: removing inventory");
					return;
				}
				if (((ConCommandArgs)(ref args)).Count < 2)
				{
					Tools.Log("Command remove_item wrong args count.");
					return;
				}
				ItemIndex itemFromString = HelperEquip.GetItemFromString(((ConCommandArgs)(ref args))[0]);
				if ((int)itemFromString != -1)
				{
					int result;
					if ("all".Equals(((ConCommandArgs)(ref args))[1], StringComparison.InvariantCultureIgnoreCase))
					{
						result = val.GetItemCount(itemFromString);
					}
					else
					{
						int.TryParse(((ConCommandArgs)(ref args))[1], out result);
					}
					if (result > 0)
					{
						val.RemoveItem(itemFromString, result);
					}
					Tools.Log(string.Format("Command {0}: removed {1} {2} from {3}", "remove_item", result, itemFromString, sender.masterController.GetDisplayName()));
				}
				else
				{
					Tools.Log("Command remove_item: item " + ((ConCommandArgs)(ref args))[0] + " not found");
				}
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} error: {1}", "remove_item", arg));
			}
		}
	}
	public class CommandKillAll : ICommandExecutor, ICommand, ICommandNotify
	{
		public const string name = "kill_all";

		public string Id => "kill_all";

		public string ProcessMsg(string msg)
		{
			return msg;
		}

		public void Execute(ConCommandArgs args)
		{
			//IL_002c: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				TeamIndex val = default(TeamIndex);
				if (((ConCommandArgs)(ref args)).Count == 0 || !Tools.ParseManager.TryParseEnum<TeamIndex>(((ConCommandArgs)(ref args))[0], ref val, (TeamIndex)0))
				{
					val = (TeamIndex)2;
				}
				int num = 0;
				CharacterMaster[] array = Object.FindObjectsOfType<CharacterMaster>();
				foreach (CharacterMaster val2 in array)
				{
					if (val2.teamIndex == val)
					{
						CharacterBody val3 = ((val2 != null) ? val2.GetBody() : null);
						if (Object.op_Implicit((Object)(object)((val3 != null) ? val3.healthComponent : null)))
						{
							val3.healthComponent.Suicide((GameObject)null, (GameObject)null, default(DamageTypeCombo));
							num++;
						}
					}
				}
				Tools.Log(string.Format("Command {0}: killed {1} of team {2}", "kill_all", num, val));
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} error: {1}", "kill_all", arg));
			}
		}
	}
	public class CommandChangeBody : ICommandExecutor, ICommand, ICommandNotify, ICommandTargets
	{
		public const string name = "spawn_as";

		private string lastMasterBodyName;

		private readonly List<string> bodyRandom;

		private const string bodyRandomName = "RandomBody";

		public string Id => "spawn_as";

		public bool IsAllPlayers { get; set; } = true;


		public CommandChangeBody()
		{
			bodyRandom = Tools.GetItemsFromFileByListName("RandomBody");
		}

		public string ProcessMsg(string msg)
		{
			try
			{
				msg = msg.Replace("%value%", lastMasterBodyName);
				Tools.Log("trans " + lastMasterBodyName);
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} process msg error: {1}", "spawn_as", arg));
			}
			return msg;
		}

		private void Respawn(CharacterMaster master)
		{
			//IL_000d: 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)
			master.Respawn(((Component)master.GetBody()).transform.position, ((Component)master.GetBody()).transform.rotation, false);
		}

		public void Execute(ConCommandArgs args)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			try
			{
				if (((ConCommandArgs)(ref args)).Count < 1)
				{
					Tools.Log("Command spawn_as wrong args count");
					return;
				}
				NetworkUser sender = args.sender;
				if ((Object)(object)sender == (Object)null)
				{
					Tools.Log("Command spawn_as, error: player not found");
					return;
				}
				CharacterMaster master = sender.master;
				if (!Object.op_Implicit((Object)(object)master.GetBody()))
				{
					Tools.Log("Command spawn_as, error: can't find player body. Probably player despawned.");
					return;
				}
				string text = ((ConCommandArgs)(ref args))[0];
				string currentName = ((Object)sender.master.GetBody()).name;
				int num = currentName.IndexOf("(");
				if (num != -1)
				{
					currentName = currentName.Substring(0, num);
				}
				currentName = HelperUnit.GetBodyName(currentName);
				Tools.Log("current body base " + ((Object)sender.master.GetBody()).name + ", processed " + currentName);
				if (text.Equals("RandomBody", StringComparison.InvariantCultureIgnoreCase))
				{
					List<string> list = bodyRandom.Where((string name) => !string.Equals(HelperUnit.GetBodyName(name), currentName, StringComparison.OrdinalIgnoreCase)).ToList();
					text = UtilityRandom.GetRandomItemFromList<string>((IList<string>)list);
				}
				text = HelperUnit.GetBodyName(text);
				if (string.IsNullOrWhiteSpace(text))
				{
					Tools.Log("Command spawn_as, error: can't find body index " + text);
					return;
				}
				GameObject bodyPrefab = BodyCatalog.FindBodyPrefab(text);
				master.bodyPrefab = bodyPrefab;
				Tools.Log("Command spawn_as: " + sender.userName + " is spawning as " + text);
				BoolConVar val = (BoolConVar)(typeof(Stage).GetField("stage1PodConVar")?.GetValue(null));
				if (val != null)
				{
					bool value = val.value;
					val.SetBool(false);
					Respawn(master);
					val.SetBool(value);
				}
				else
				{
					Respawn(master);
				}
				lastMasterBodyName = master.GetBody().GetDisplayName();
				Tools.Log("Command spawn_as: spawning " + lastMasterBodyName + " end");
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} error: {1}", "spawn_as", arg));
			}
		}
	}
	public class CommandGiveEquip : ICommandExecutor, ICommand, ICommandNotify, ICommandTargets
	{
		public const string name = "give_equip";

		private const string equipRandomName = "RandomEquip";

		private readonly List<string> equipRandom;

		private EquipmentIndex lastEquip;

		public string Id => "give_equip";

		public bool IsAllPlayers { get; set; } = true;


		public CommandGiveEquip()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			equipRandom = Tools.GetItemsFromFileByListName("RandomEquip");
			for (int num = equipRandom.Count - 1; num >= 0; num--)
			{
				string text = equipRandom[num];
				if ((int)HelperEquip.GetEquipFromString(text) == -1)
				{
					Tools.Log("Command give_equip error: missed equip item - " + text + " in category RandomEquip");
					equipRandom.RemoveAt(num);
				}
			}
		}

		public string ProcessMsg(string msg)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(lastEquip);
				string localizedStringByToken = Language.currentLanguage.GetLocalizedStringByToken(equipmentDef.nameToken);
				msg = msg.Replace("%value%", localizedStringByToken);
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} process msg error: {1}", "give_equip", arg));
			}
			return msg;
		}

		public void Execute(ConCommandArgs args)
		{
			//IL_0023: 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_00ae: 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_00b6: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_00eb: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (((ConCommandArgs)(ref args)).Count < 1)
				{
					Tools.Log("Command give_equip wrong args count");
					return;
				}
				NetworkUser sender = args.sender;
				if ((Object)(object)sender == (Object)null)
				{
					Tools.Log("Command give_equip, error: player not found");
					return;
				}
				NetworkUser sender2 = args.sender;
				Inventory val = ((sender2 != null) ? sender2.master.inventory : null);
				if ((Object)(object)val == (Object)null)
				{
					Tools.Log("Command give_equip, error: inventory not found");
					return;
				}
				string text = ((ConCommandArgs)(ref args))[0];
				string text2 = ((!text.Equals("RandomEquip", StringComparison.InvariantCultureIgnoreCase)) ? text : UtilityRandom.GetRandomItemFromList<string>((IList<string>)equipRandom));
				EquipmentIndex val2 = (lastEquip = HelperEquip.GetEquipFromString(text2));
				if ((int)val2 != -1)
				{
					val.SetEquipmentIndex(val2);
				}
				else
				{
					Tools.Log(string.Format("Command {0}, error: item not found {1} : {2}", "give_equip", ((ConCommandArgs)(ref args))[0], val2));
				}
				Tools.Log(string.Format("Command {0}: player {1} got {2}", "give_equip", sender.masterController.GetDisplayName(), val2));
			}
			catch (Exception arg)
			{
				Tools.Log(string.Format("Command {0} error: {1}", "give_equip", arg));
			}
		}
	}
}