using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using MelonLoader;
using Microsoft.CodeAnalysis;
using Mirror;
using Multi_Class_Ban;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(MelonLoad), "Multi Class Ban", "1.0.0", "Lilly", null)]
[assembly: MelonGame("KisSoft", "ATLYSS")]
[assembly: MelonOptionalDependencies(new string[] { "BepInEx" })]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Multi_Class_Ban")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Multi_Class_Ban")]
[assembly: AssemblyTitle("Multi_Class_Ban")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Multi_Class_Ban
{
	[BepInPlugin("9d4aafba-3988-4f94-b5f1-a34bd644131a", "Multi Class Ban", "1.0.0")]
	public class Bepin : BaseUnityPlugin
	{
		private ConfigEntry<bool> pvpBan;

		private MultiClassBanCore multiclassbancore;

		private void Awake()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			pvpBan = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "CameralCollision", true, "Toggles Camera Colision and Infinite Zoom");
			if (!((Object)(object)MultiClassBanCore.MultiClassBaninstance != (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(GameObject.CreatePrimitive((PrimitiveType)3));
				((Object)val).hideFlags = (HideFlags)61;
				multiclassbancore = val.AddComponent<MultiClassBanCore>();
				multiclassbancore.Logger = logger;
				multiclassbancore.saveConfig = saveSettings;
				Harmony val2 = new Harmony("Lilly's Beyond Limits");
				val2.PatchAll();
			}
		}

		public bool saveSettings(string _)
		{
			try
			{
				((BaseUnityPlugin)this).Config.Save();
				return true;
			}
			catch (Exception ex)
			{
				logger(ex.ToString());
				return false;
			}
		}

		private void OnApplicationQuit()
		{
		}

		public bool logger(string mesg)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)(mesg ?? ""));
			return true;
		}
	}
	public class MultiClassBanCore : MonoBehaviour
	{
		[HarmonyPatch(typeof(Player), "OnGameConditionChange")]
		public static class lillyCred
		{
			[HarmonyPrefix]
			private static void Prefix(ref Player __instance)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Invalid comparison between Unknown and I4
				try
				{
					if ((int)__instance.Network_currentGameCondition != 1)
					{
						return;
					}
					if (__instance._pStats._syncClass == "Fighter")
					{
						foreach (SkillStruct playerSkillStruct in __instance._pCasting._playerSkillStructs)
						{
							if (MultiClassBaninstance.Mystic.Contains(playerSkillStruct._skillName) || MultiClassBaninstance.Bandit.Contains(playerSkillStruct._skillName))
							{
								int connectionId = ((NetworkConnection)((NetworkBehaviour)__instance).connectionToClient).connectionId;
								if (connectionId != 0)
								{
									MultiClassBaninstance.Logger(__instance._nickname + " Was Multi-Classed");
									MultiClassBaninstance.kick(connectionId, __instance._nickname);
									break;
								}
							}
						}
						return;
					}
					if (__instance._pStats._syncClass == "Mystic")
					{
						foreach (SkillStruct playerSkillStruct2 in __instance._pCasting._playerSkillStructs)
						{
							if (MultiClassBaninstance.Fighter.Contains(playerSkillStruct2._skillName) || MultiClassBaninstance.Bandit.Contains(playerSkillStruct2._skillName))
							{
								int connectionId2 = ((NetworkConnection)((NetworkBehaviour)__instance).connectionToClient).connectionId;
								if (connectionId2 != 0)
								{
									MultiClassBaninstance.Logger(__instance._nickname + " Was Multi-Classed");
									MultiClassBaninstance.kick(connectionId2, __instance._nickname);
									break;
								}
							}
						}
						return;
					}
					if (!(__instance._pStats._syncClass == "Bandit"))
					{
						return;
					}
					foreach (SkillStruct playerSkillStruct3 in __instance._pCasting._playerSkillStructs)
					{
						if (MultiClassBaninstance.Mystic.Contains(playerSkillStruct3._skillName) || MultiClassBaninstance.Fighter.Contains(playerSkillStruct3._skillName))
						{
							int connectionId3 = ((NetworkConnection)((NetworkBehaviour)__instance).connectionToClient).connectionId;
							if (connectionId3 != 0)
							{
								MultiClassBaninstance.Logger(__instance._nickname + " Was Multi-Classed");
								MultiClassBaninstance.kick(connectionId3, __instance._nickname);
								break;
							}
						}
					}
				}
				catch (Exception ex)
				{
					MultiClassBaninstance.Logger(ex.ToString());
				}
			}
		}

		public static MultiClassBanCore MultiClassBaninstance;

		public Func<string, bool> Logger;

		public Func<string, bool> saveConfig;

		private List<string> Fighter = new List<string>(new <>z__ReadOnlyArray<string>(new string[8] { "Stomp", "Rage", "Leathal Strike", "Blood Gush", "Cyclone", "Shield Bash", "Bulwark", "Reflect" }));

		private List<string> Mystic = new List<string>(new <>z__ReadOnlyArray<string>(new string[9] { "Fluxbolt", "Manaflow", "Blink", "Restora", "Imbue", "Prism", "Nova", "Cross", "Fluxspear" }));

		private List<string> Bandit = new List<string>(new <>z__ReadOnlyArray<string>(new string[8] { "Agile Technique", "Devious Signet", "Mist Veil", "Bomb Trap", "Pay Day", "Volley", "Killer Jab", "Venom Shot" }));

		public void kick(int _connID, string name)
		{
			name = Regex.Replace(name, "<.*?>", "");
			string text = name + ", Multi-Classing Is Not Allowed";
			HostConsole._current.Init_ServerMessage(name + ",");
			HostConsole._current.Init_ServerMessage("Multi-Classing Is Not Allowed");
			HostConsole._current.Init_ServerMessage("Kicking In 10");
			((MonoBehaviour)this).StartCoroutine(delayKick(_connID, name));
		}

		public IEnumerator delayKick(int _connID, string name)
		{
			yield return (object)new WaitForSecondsRealtime(15f);
			((NetworkConnection)NetworkServer.connections[_connID]).Disconnect();
		}

		public void Start()
		{
			MultiClassBaninstance = this;
		}
	}
	public class MelonLoad : MelonMod
	{
		private MelonPreferences_Category general;

		private MelonPreferences_Entry<bool> pvpBan;

		private MultiClassBanCore multiclassbancore;

		public override void OnInitializeMelon()
		{
			if (!((Object)(object)MultiClassBanCore.MultiClassBaninstance != (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(GameObject.CreatePrimitive((PrimitiveType)3));
				((Object)val).hideFlags = (HideFlags)61;
				multiclassbancore = val.AddComponent<MultiClassBanCore>();
				multiclassbancore.Logger = logger;
				multiclassbancore.saveConfig = saveSettings;
			}
		}

		public bool saveSettings(string _)
		{
			try
			{
				MelonPreferences.Save();
				return true;
			}
			catch (Exception ex)
			{
				logger(ex.ToString());
				return false;
			}
		}

		public override void OnApplicationQuit()
		{
		}

		public bool logger(string mesg)
		{
			MelonLogger.Msg(mesg);
			return true;
		}
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}