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

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

		public string Cost { get; set; }

		public string EventID { get; set; }

		public string Lang { get; set; }

		public string ExtraInfo { get; set; }

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

		internal static readonly char clientAppSepChar = '&';

		internal static readonly string clientAppEqual = "=";

		internal static readonly char clientAppEqualChar = '=';

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

		string IEventsDataEncoderParams.ClientAppSep => clientAppSep;

		char IEventsDataEncoderParams.ClientAppSepChar => clientAppSepChar;

		string IEventsDataEncoderParams.ClientAppEqual => clientAppEqual;

		char IEventsDataEncoderParams.ClientAppEqualChar => clientAppEqualChar;

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

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

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

		public bool isLogInfoError = true;

		public bool isLogSkipEmpty;

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

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

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

		protected EventsData data;

		protected readonly IEventsDataEncoder encoder;

		protected readonly IEventsDataEncoderParams encoderParams;

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

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

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

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

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

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

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

		protected readonly IEventsDataParser parser;

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

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

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

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

		protected readonly float delay;

		protected float delayCounter;

		protected float initDelay;

		protected float initCounter;

		protected readonly float checkPeriod;

		protected float periodCounter;

		protected readonly Action<IEventsData> processEvent;

		protected readonly IEventsDataParser parser;

		protected IEnumerator<IEventsData> eventsData;

		protected readonly string path;

		private bool isDelayEveryProcessing;

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

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

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

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

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

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

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

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

		protected readonly Action<string> logError;

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

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

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

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

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

		string Cost { get; }

		string EventID { get; }

		string Lang { get; }

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

		char ClientAppSepChar { get; }

		string ClientAppEqual { get; }

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

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

		void SetEventID(string s);

		void SetCost(string s);

		void SetLang(string s);

		void SetExtraInfo(string s);

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

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

		bool IsProcessEnd();

		void ProcessAllWithDelayOnFrame(float dt);

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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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 TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WebSocketIO;
using valheim_mod.Commands;
using valheim_mod.Patchers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ChaosTricks Valheim mod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("BFT")]
[assembly: AssemblyProduct("ChaosTricks Valheim mod")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("BFT")]
[assembly: ComVisible(false)]
[assembly: Guid("e1bf112d-820d-4486-a4e7-d44d7400fee6")]
[assembly: AssemblyFileVersion("2.2.2.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("2.2.2.0")]
namespace valheim_mod
{
	public class DamageRanges
	{
		public float MinPhysicalDamage { get; set; }

		public float MaxPhysicalDamage { get; set; }

		public float MinElementalDamage { get; set; }

		public float MaxElementalDamage { get; set; }

		public void ReadFromArgs(IEnumerator<string> argsEnumerator)
		{
			ReadPhysicalDamageFromArgs(argsEnumerator);
			ReadElementalDamageFromArgs(argsEnumerator);
		}

		public void ReadPhysicalDamageFromArgs(IEnumerator<string> argsEnumerator)
		{
			float val = CommandsArgsReader.ReadFloat(argsEnumerator, 1f);
			float val2 = CommandsArgsReader.ReadFloat(argsEnumerator, 1f);
			MinPhysicalDamage = Math.Min(val, val2);
			MaxPhysicalDamage = Math.Max(val, val2);
		}

		public void ReadElementalDamageFromArgs(IEnumerator<string> argsEnumerator)
		{
			float val = CommandsArgsReader.ReadFloat(argsEnumerator, 0f);
			float val2 = CommandsArgsReader.ReadFloat(argsEnumerator, 0f);
			MinElementalDamage = Math.Min(val, val2);
			MaxElementalDamage = Math.Max(val, val2);
		}

		private static bool IsValidPair(IEnumerator<string> argsEnumerator, bool isSkippable)
		{
			if (CommandsValidator.IsValidFloat(argsEnumerator, 0f, 200f, isSkippable))
			{
				return CommandsValidator.IsValidFloat(argsEnumerator, 0f, 200f, isSkippable);
			}
			return false;
		}

		public static bool IsValidPhysicalDamage(IEnumerator<string> argsEnumerator, bool isSkippable)
		{
			return IsValidPair(argsEnumerator, isSkippable);
		}

		public static bool IsValidElementalDamage(IEnumerator<string> argsEnumerator, bool isSkippable)
		{
			return IsValidPair(argsEnumerator, isSkippable);
		}

		public static bool IsValidDamage(IEnumerator<string> argsEnumerator, bool isSkippable)
		{
			if (IsValidPhysicalDamage(argsEnumerator, isSkippable))
			{
				return IsValidElementalDamage(argsEnumerator, isSkippable);
			}
			return false;
		}
	}
	public static class CommandsArgsReader
	{
		public static int ReadInt(IEnumerator<string> args, int defaultValue)
		{
			if (args == null || !args.MoveNext())
			{
				return defaultValue;
			}
			int result = defaultValue;
			try
			{
				result = int.Parse(args.Current);
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"CommandsArgsReader error: {arg}");
			}
			return result;
		}

		public static float ReadFloat(IEnumerator<string> args, float defaultValue)
		{
			if (args == null || !args.MoveNext())
			{
				return defaultValue;
			}
			float result = defaultValue;
			try
			{
				result = float.Parse(args.Current, CultureInfo.InvariantCulture.NumberFormat);
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"CommandsArgsReader error: {arg}");
			}
			return result;
		}

		public static string ReadString(IEnumerator<string> args, string defaultValue = "")
		{
			if (args == null || !args.MoveNext())
			{
				return defaultValue;
			}
			return args.Current;
		}

		public static bool ReadBool(IEnumerator<string> args, bool defaultValue = false)
		{
			if (args == null || !args.MoveNext())
			{
				return defaultValue;
			}
			try
			{
				return bool.Parse(args.Current.ToLower());
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"CommandArgsReader: {arg}");
				return defaultValue;
			}
		}
	}
	public static class CommandsValidator
	{
		public static bool IsZeroArgs(IEnumerable<string> args)
		{
			int num = args?.Count() ?? 0;
			if (num != 0)
			{
				LoggerFactory.Logger.LogDebugError((object)$"wrong args count {num} (must be 0)");
				return false;
			}
			return true;
		}

		public static bool IsZeroArgs(IEnumerator<string> args)
		{
			if (args == null || !args.MoveNext())
			{
				return true;
			}
			LoggerFactory.Logger.LogDebugError((object)"wrong args count (more than needed)");
			return false;
		}

		private static bool IsInvalidArgsCount(IEnumerator<string> args)
		{
			if (args == null || !args.MoveNext())
			{
				return true;
			}
			return false;
		}

		public static bool IsValidInt(IEnumerator<string> args, int minValue, int maxValue, bool isSkippable = false)
		{
			if (IsInvalidArgsCount(args))
			{
				if (isSkippable)
				{
					return true;
				}
				LoggerFactory.Logger.LogDebugError((object)"wrong args count");
				return false;
			}
			try
			{
				int num = int.Parse(args.Current);
				if (num < minValue || num > maxValue)
				{
					string text = $"wrong integer value {num} (must be in range from {minValue} to {maxValue})";
					LoggerFactory.Logger.LogDebugError((object)text);
					return false;
				}
			}
			catch (Exception)
			{
				LoggerFactory.Logger.LogDebugError((object)("can't parse integer value from '" + args.Current + "'"));
				return false;
			}
			return true;
		}

		public static bool IsValidFloat(IEnumerator<string> args, float minValue, float maxValue, bool isSkippable = false)
		{
			if (IsInvalidArgsCount(args))
			{
				if (isSkippable)
				{
					return true;
				}
				LoggerFactory.Logger.LogDebugError((object)"wrong args count");
				return false;
			}
			try
			{
				float num = float.Parse(args.Current, CultureInfo.InvariantCulture.NumberFormat);
				if (num < minValue || num > maxValue)
				{
					string text = $"wrong float value {num} (must be in range from {minValue} to {maxValue})";
					LoggerFactory.Logger.LogDebugError((object)text);
					return false;
				}
			}
			catch (Exception)
			{
				LoggerFactory.Logger.LogDebugError((object)("can't parse float value from '" + args.Current + "'"));
			}
			return true;
		}

		public static bool IsValidString(IEnumerator<string> args, Func<string, bool> validator, bool isSkippable = false)
		{
			if (IsInvalidArgsCount(args))
			{
				if (isSkippable)
				{
					return true;
				}
				LoggerFactory.Logger.LogDebugError((object)"wrong args count");
				return false;
			}
			if (validator == null)
			{
				return true;
			}
			if (validator(args.Current))
			{
				return true;
			}
			LoggerFactory.Logger.LogDebugError((object)("wrong string value " + args.Current));
			return false;
		}

		public static bool IsValidBool(IEnumerator<string> args, bool isSkippable = true)
		{
			if (IsInvalidArgsCount(args))
			{
				if (isSkippable)
				{
					return true;
				}
				LoggerFactory.Logger.LogDebugError((object)"wrong args count");
				return false;
			}
			LoggerFactory.Logger.LogDebugError((object)("wrong bool value " + args.Current));
			return false;
		}
	}
	public static class GameProxy
	{
		public static readonly string CustomNameId = "custom_name";

		public static readonly string PlayerNameSpawnId = "PlayerNameSpawn";

		public static readonly string CustomSpeedTriggerId = "CustomSpeedTrigger";

		private static bool isNeedHudsErrorLog = true;

		private static ScheduleManager scheduleManager;

		private static bool isDebugInited;

		private static bool isDebug;

		public static Player CurrentPlayer => Player.m_localPlayer;

		public static Player[] TargetPlayers
		{
			get
			{
				if (!InteractiveMod.Settings.isAllPlayers)
				{
					return (Player[])(object)new Player[1] { CurrentPlayer };
				}
				return Player.GetAllPlayers().ToArray();
			}
		}

		public static ScheduleManager ScheduleManager
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				if (scheduleManager == null)
				{
					scheduleManager = new ScheduleManager((ILogger)(object)LoggerFactory.Logger);
				}
				return scheduleManager;
			}
		}

		public static void RunGameConsoleCommand(string command)
		{
			try
			{
				if (!IsCheater())
				{
					((ILogger)LoggerFactory.Logger).Log((object)"Standard command try to enable cheats");
					StandardConsoleManager.instance.InstantlyRunCommand("devcommands");
				}
				StandardConsoleManager.instance.AddCommandToQueue(command);
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"Standard command error: {arg}");
			}
		}

		public static bool IsCheater()
		{
			try
			{
				return (Object)(object)Console.instance != (Object)null && ((Terminal)Console.instance).IsCheatsEnabled();
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"IsCheater error: {arg}");
				return false;
			}
		}

		private static void DebugLogReflection(string msg)
		{
			((ILogger)LoggerFactory.Logger).Log((object)msg);
		}

		private static void VerboseDebugLogReflection(string msg, bool isVerboseDebugLog)
		{
			if (isVerboseDebugLog)
			{
				LoggerFactory.Logger.LogDebugInfo((object)msg);
			}
		}

		public static void UpdateEnemyHudNames(bool isVerboseDebugLog = false)
		{
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			EnemyHud instance = EnemyHud.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				FieldInfo field = typeof(EnemyHud).GetField("m_huds", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					DebugLogReflection("UpdateEnemyHudNames info null");
					return;
				}
				object value = field.GetValue(instance);
				if (value == null)
				{
					DebugLogReflection("UpdateEnemyHudNames dictHudData null");
					return;
				}
				if (!(value is IDictionary dictionary))
				{
					DebugLogReflection("UpdateEnemyHudNames m_huds null");
					return;
				}
				VerboseDebugLogReflection($"UpdateEnemyHudNames m_huds {dictionary.Count}", isVerboseDebugLog);
				foreach (object key in dictionary.Keys)
				{
					object obj = dictionary[key];
					if (obj == null)
					{
						VerboseDebugLogReflection("UpdateEnemyHudNames objData null", isVerboseDebugLog);
						continue;
					}
					Character val = (Character)((key is Character) ? key : null);
					if ((Object)(object)val == (Object)null || val.IsPlayer())
					{
						VerboseDebugLogReflection($"UpdateEnemyHudNames char skipped {(Object)(object)val == (Object)null}", isVerboseDebugLog);
						continue;
					}
					ZDO zDO = GetZDO(val);
					int instanceID = ((Object)val).GetInstanceID();
					uint iD = ((ZDOID)(ref zDO.m_uid)).ID;
					string @string = zDO.GetString(CustomNameId, "");
					object[] obj2 = new object[4] { @string, instanceID, iD, null };
					ZDOID zDOID = zDO.GetZDOID(CustomNameId);
					obj2[3] = ((ZDOID)(ref zDOID)).ID;
					VerboseDebugLogReflection(string.Format("UpdateEnemyHudNames: {0}, id {1}, idZDO {2}, zdoid {3}", obj2), isVerboseDebugLog);
					if (string.IsNullOrEmpty(@string))
					{
						continue;
					}
					FieldInfo field2 = obj.GetType().GetField("m_name", BindingFlags.Instance | BindingFlags.Public);
					if (field2 == null)
					{
						DebugLogReflection("UpdateEnemyHudNames textField null");
						continue;
					}
					object? value2 = field2.GetValue(obj);
					Text val2 = (Text)((value2 is Text) ? value2 : null);
					if (val2 != null)
					{
						val2.text = @string;
						VerboseDebugLogReflection("UpdateEnemyHudNames name is set", isVerboseDebugLog);
					}
				}
			}
			catch (Exception arg)
			{
				if (isNeedHudsErrorLog)
				{
					isNeedHudsErrorLog = false;
					((ILogger)LoggerFactory.Logger).Log((object)$"UpdateEnemyHudNames error: {arg}");
				}
			}
		}

		public static ZNetView GetZNetView(object obj)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			try
			{
				return (ZNetView)obj.GetType().GetField("m_nview", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
			}
			catch (Exception arg)
			{
				DebugLogReflection($"GetZNetView error: {arg}");
				return null;
			}
		}

		public static ZDO GetZDO(Character obj)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ZDOMan.instance.GetZDO(obj.GetZDOID());
			}
			catch (Exception arg)
			{
				DebugLogReflection($"GetZDO error: {arg}");
				return null;
			}
		}

		public static ZDO GetZDO(GameObject obj)
		{
			try
			{
				ZNetView componentInChildren = obj.GetComponentInChildren<ZNetView>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					return null;
				}
				return componentInChildren.GetZDO();
			}
			catch (Exception arg)
			{
				DebugLogReflection($"gameObject GetZDO error: {arg}");
				return null;
			}
		}

		public static void TriggerConsoleInputText()
		{
			try
			{
				typeof(Console).GetMethod("InputText", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(Console.instance, null);
			}
			catch (Exception arg)
			{
				DebugLogReflection($"TriggerConsoleInputText error: {arg}");
			}
		}

		public static void ReinitScheduleManager()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			ScheduleManager obj = scheduleManager;
			if (obj != null)
			{
				obj.FinishAllImmediatly();
			}
			scheduleManager = new ScheduleManager((ILogger)(object)LoggerFactory.Logger);
		}

		public static GameObject SpawnProjectile(Vector3 pos, string name)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)ZNetScene.instance == (Object)null)
				{
					((ILogger)LoggerFactory.Logger).LogError((object)"SpawnProjectile ZNetScene null");
					return null;
				}
				GameObject prefab = ZNetScene.instance.GetPrefab(name);
				if ((Object)(object)prefab == (Object)null)
				{
					((ILogger)LoggerFactory.Logger).LogError((object)("Missing projectile prefab" + name));
					return null;
				}
				return Object.Instantiate<GameObject>(prefab, pos, Quaternion.identity);
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).LogError((object)$"SpawnProjectile error: {arg}");
			}
			return null;
		}

		public static Projectile SetupProjectilePhysics(Character owner, GameObject gameObject, Vector3 target, float velocity = 10f, float accuracy = 5f)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a0: 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)
			try
			{
				if ((Object)(object)gameObject == (Object)null)
				{
					((ILogger)LoggerFactory.Logger).LogError((object)"SetupProjectile gameObject null");
					return null;
				}
				Projectile component = gameObject.GetComponent<Projectile>();
				if ((Object)(object)component == (Object)null)
				{
					((ILogger)LoggerFactory.Logger).LogError((object)"SetupProjectile Projectile null error");
					return null;
				}
				Vector3 val = target - ((Component)component).transform.position;
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				Vector3 val2 = Vector3.Cross(normalized, Vector3.up);
				normalized = Quaternion.AngleAxis(Random.Range(0f - accuracy, accuracy), val2) * normalized;
				normalized = Quaternion.AngleAxis(Random.Range(0f - accuracy, accuracy), Vector3.up) * normalized;
				component.Setup(owner, normalized * velocity, -1f, (HitData)null, (ItemData)null, (ItemData)null);
				return component;
			}
			catch (Exception arg)
			{
				LoggerFactory.LogWithUI($"SetupProjectile error: {arg}");
			}
			return null;
		}

		public static void DebugComponents(GameObject gameObject)
		{
			Component[] components = gameObject.GetComponents<Component>();
			if (components == null)
			{
				((ILogger)LoggerFactory.Logger).Log((object)"components not found");
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			Component[] array = components;
			foreach (Component val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					stringBuilder.AppendLine(((object)val).GetType().Name);
				}
			}
			((ILogger)LoggerFactory.Logger).Log((object)$"components list:\n{stringBuilder}");
		}

		public static string[] GetTierNames()
		{
			return new string[5] { "1", "2", "3", "4", "5" };
		}

		public static string GetCurrentTier()
		{
			float bodyArmor = ((Character)CurrentPlayer).GetBodyArmor();
			if (bodyArmor < 10f)
			{
				return "1";
			}
			if (bodyArmor < 21f)
			{
				return "2";
			}
			if (bodyArmor < 41f)
			{
				return "3";
			}
			if (bodyArmor < 61f)
			{
				return "4";
			}
			return "5";
		}

		public static bool IsPlayerCloseToOthers(Player p, ICollection<Player> others, float range)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)p == (Object)null || others == null || others.Count == 0)
			{
				return false;
			}
			if (range <= 0f)
			{
				return true;
			}
			Vector3 position = ((Component)p).transform.position;
			foreach (Player other in others)
			{
				if (Vector3.Distance(((Component)other).transform.position, position) <= range)
				{
					return true;
				}
			}
			return false;
		}

		public static void DebugDamage(DamageTypes damage)
		{
			//IL_000a: 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_0048: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			((ILogger)LoggerFactory.Logger).Log((object)$"m_damage: {damage.m_damage}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_blunt: {damage.m_blunt}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_chop: {damage.m_chop}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_fire: {damage.m_fire}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_frost: {damage.m_frost}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_lightning: {damage.m_lightning}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_pickaxe: {damage.m_pickaxe}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_pierce: {damage.m_pierce}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_poison: {damage.m_poison}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_slash: {damage.m_slash}");
			((ILogger)LoggerFactory.Logger).Log((object)$"m_spirit: {damage.m_spirit}");
		}

		public static bool IsDebugMode()
		{
			if (isDebugInited)
			{
				return isDebug;
			}
			isDebugInited = true;
			isDebug = File.Exists(Path.Combine(UtilitySettings.BaseFolder, ".debug"));
			return isDebug;
		}
	}
	public static class LoggerFactory
	{
		private static IDebugLogger logger;

		public static IDebugLogger Logger
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				if (logger == null)
				{
					logger = (IDebugLogger)new BufferedLogger(UtilitySettings.BaseFolder, "interactive_mod_log.txt", GameProxy.IsDebugMode(), 50);
				}
				return logger;
			}
		}

		public static void LogWithUI(string msg)
		{
			((ILogger)Logger).Log((object)msg);
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				((Character)localPlayer).Message((MessageType)1, msg, 0, (Sprite)null);
			}
		}
	}
	public class SummonController
	{
		public class PackageEnemiesData
		{
			public string name;

			public uint id;

			public long userId;
		}

		public static readonly SummonController instance = new SummonController();

		private readonly List<Character> summonedEnemies = new List<Character>();

		private List<PackageEnemiesData> zpackageEnemies;

		private const float initTimer = 1.8f;

		private float dotTimer = 1.8f;

		private const float initTimerFixCharacters = 1f;

		private float timerFixCharacters = 1f;

		private float killEnemiesTimer = 1f;

		private readonly string[] animalList = new string[6] { "Deer", "Neck", "Boar", "Hare", "Hen", "Lox" };

		public void AddCharacter(Character enemy)
		{
			if ((Object)(object)enemy != (Object)null)
			{
				summonedEnemies.Add(enemy);
			}
		}

		public void AddCharacter(GameObject enemy)
		{
			if ((Object)(object)enemy != (Object)null)
			{
				AddCharacter(enemy.GetComponentInChildren<Character>());
			}
		}

		public void AddPackageCharacter(PackageEnemiesData character)
		{
			if (character != null)
			{
				if (zpackageEnemies == null)
				{
					zpackageEnemies = new List<PackageEnemiesData>();
				}
				zpackageEnemies.Add(character);
			}
		}

		public void ClearEnemies()
		{
			summonedEnemies.Clear();
		}

		private static void InitCharacterHud(Character c)
		{
			try
			{
				Traverse.Create((object)EnemyHud.instance).Method("ShowHud", new object[2] { c, false });
			}
			catch (Exception arg)
			{
				LoggerFactory.Logger.LogDebugError((object)$"InitCharacterHud {arg}");
			}
		}

		private PackageEnemiesData GetPackageEnemyName(uint id, long userId)
		{
			foreach (PackageEnemiesData zpackageEnemy in zpackageEnemies)
			{
				if (zpackageEnemy.id == id && zpackageEnemy.userId == userId)
				{
					return zpackageEnemy;
				}
			}
			return null;
		}

		private void FixHudNames()
		{
			try
			{
				if (zpackageEnemies != null)
				{
					List<PackageEnemiesData> list = new List<PackageEnemiesData>();
					foreach (Character allCharacter in Character.GetAllCharacters())
					{
						if ((Object)(object)allCharacter == (Object)null || allCharacter.IsPlayer())
						{
							continue;
						}
						ZDO zDO = GameProxy.GetZDO(allCharacter);
						if (zDO != null)
						{
							uint iD = ((ZDOID)(ref zDO.m_uid)).ID;
							long userID = ((ZDOID)(ref zDO.m_uid)).UserID;
							PackageEnemiesData packageEnemyName = GetPackageEnemyName(iD, userID);
							if (packageEnemyName != null)
							{
								string text = (allCharacter.m_name = packageEnemyName.name);
								InitCharacterHud(allCharacter);
								zDO.Set(GameProxy.CustomNameId, text);
								list.Add(packageEnemyName);
							}
						}
					}
					if (list.Count > 0)
					{
						List<PackageEnemiesData> list2 = zpackageEnemies.Except(list).ToList();
						zpackageEnemies = ((list2.Count == 0) ? null : list2);
					}
				}
				GameProxy.UpdateEnemyHudNames();
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"SummonController error: {arg}");
			}
		}

		public void KillSpawnedEnemyOnDeath()
		{
			if (!InteractiveMod.networkIsKillSpawnsAfterPlayerDeath)
			{
				return;
			}
			Player[] targetPlayers = GameProxy.TargetPlayers;
			foreach (Player val in targetPlayers)
			{
				if (!(((Character)val).GetHealth() <= 0f))
				{
					continue;
				}
				string playerName = val.GetPlayerName();
				foreach (Character allCharacter in Character.GetAllCharacters())
				{
					if (allCharacter.IsPlayer())
					{
						continue;
					}
					ZDO zDO = GameProxy.GetZDO(allCharacter);
					if (zDO == null)
					{
						continue;
					}
					GameObject prefab = ZNetScene.instance.GetPrefab(zDO.GetPrefab());
					string @string = zDO.GetString(GameProxy.PlayerNameSpawnId, "");
					if (!string.IsNullOrEmpty(@string) && @string == playerName && !animalList.Contains(((Object)prefab).name))
					{
						ZNetView zNetView = GameProxy.GetZNetView(allCharacter);
						if ((Object)(object)zNetView != (Object)null)
						{
							zNetView.Destroy();
						}
						((ILogger)LoggerFactory.Logger).Log((object)("EnemiesRemover " + @string));
					}
				}
			}
		}

		public void KillOutRangeEnemy()
		{
			//IL_0103: 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)
			if (!InteractiveMod.networkIsKillSpawnsAfterPlayerDeath)
			{
				return;
			}
			Player[] targetPlayers = GameProxy.TargetPlayers;
			foreach (Player val in targetPlayers)
			{
				if ((Object)(object)val == (Object)null)
				{
					((ILogger)LoggerFactory.Logger).LogWarning((object)"KillOutRangeEnemy player is null");
					continue;
				}
				foreach (Character allCharacter in Character.GetAllCharacters())
				{
					if ((Object)(object)allCharacter == (Object)null)
					{
						((ILogger)LoggerFactory.Logger).LogWarning((object)"KillOutRangeEnemy character is null");
					}
					else
					{
						if (allCharacter.IsPlayer())
						{
							continue;
						}
						ZDO zDO = GameProxy.GetZDO(allCharacter);
						if (zDO == null)
						{
							((ILogger)LoggerFactory.Logger).LogWarning((object)"KillOutRangeEnemy zdo is null");
							continue;
						}
						string @string = zDO.GetString(GameProxy.PlayerNameSpawnId, "");
						string playerName = val.GetPlayerName();
						if (string.IsNullOrEmpty(@string) || @string != playerName)
						{
							continue;
						}
						if ((Object)(object)((Component)val).transform == (Object)null || (Object)(object)((Component)allCharacter).transform == (Object)null)
						{
							((ILogger)LoggerFactory.Logger).LogWarning((object)"KillOutRangeEnemy transform is null");
						}
						else if (Vector3.Distance(((Component)val).transform.position, ((Component)allCharacter).transform.position) >= 80f)
						{
							ZNetView zNetView = GameProxy.GetZNetView(allCharacter);
							if ((Object)(object)zNetView == (Object)null)
							{
								((ILogger)LoggerFactory.Logger).LogWarning((object)"KillOutRangeEnemy znv is null");
								continue;
							}
							zNetView.Destroy();
							((ILogger)LoggerFactory.Logger).Log((object)"EnemiesRemover KillOutRangeEnemy");
						}
					}
				}
			}
		}

		public void OnUpdate(float dt)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			timerFixCharacters -= dt;
			if (timerFixCharacters <= 0f)
			{
				timerFixCharacters = 1f;
				FixHudNames();
			}
			killEnemiesTimer -= dt;
			if (killEnemiesTimer < 0f)
			{
				killEnemiesTimer = 1f;
				KillOutRangeEnemy();
				KillSpawnedEnemyOnDeath();
			}
			if (!InteractiveMod.networkIsEnableSpawnDeathTimer)
			{
				return;
			}
			dotTimer -= dt;
			if (dotTimer > 0f)
			{
				return;
			}
			dotTimer = 1.8f;
			for (int num = summonedEnemies.Count - 1; num >= 0; num--)
			{
				try
				{
					Character val = summonedEnemies[num];
					if ((Object)(object)val == (Object)null || val.IsDead() || (Object)(object)((Component)val).gameObject == (Object)null || !((Component)val).gameObject.activeInHierarchy)
					{
						summonedEnemies.RemoveAt(num);
						((ILogger)LoggerFactory.Logger).Log((object)"SummonController enemy removed");
					}
					else
					{
						HitData val2 = new HitData();
						float val3 = val.GetMaxHealth() / (float)InteractiveMod.networkSpawnDeathTimerDuration * 1.8f;
						val2.m_damage.m_damage = Math.Max(val3, 0.12f);
						val.Damage(val2);
					}
				}
				catch (Exception arg)
				{
					((ILogger)LoggerFactory.Logger).Log((object)$"SummonController error: {arg}");
				}
			}
		}
	}
	[BepInPlugin("bft.chaostricks", "Chaos Tricks", "2.2.2")]
	public class BepInExPlugin : BaseUnityPlugin
	{
		private ManualLogSource loggerHook;

		public const string pluginGuid = "bft.chaostricks";

		public const string pluginName = "Chaos Tricks";

		public const string pluginVersion = "2.2.2";

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

		public void OnDestroy()
		{
			InteractiveMod.instance?.OnDestroy();
		}

		public void Start()
		{
			InteractiveMod.instance?.Start();
		}

		public void Update()
		{
			InteractiveMod.instance?.Update();
		}
	}
	public class NetworkSpawnData
	{
		public int hitpointsModifier = 100;

		public int spawnDamageModifier = 100;

		public int buildingDamageModifier = 25;

		public bool isSpawnsHaveDrop;

		public bool isKillSpawnsAfterPlayerDeath = true;

		public bool isEnableSpawnDeathTimer = true;

		public int spawnDeathTimerDuration = 150;

		public string argName;

		public int argCount = 1;

		public int argLevel;

		public float argHitsPercent = 0.5f;

		public float argMinPhysicalDamage;

		public float argMaxPhysicalDamage;

		public float argMinElementalDamage;

		public float argMaxElementalDamage;

		public string username = "agent007";
	}
	public class InteractiveMod
	{
		public static InteractiveMod instance;

		private WebSocketEventsReader<SettingsData> eventsReader;

		private IEventsReaderOnKey eventsReaderByKey;

		private IEventsDataParser eventsParser;

		private string keyEventsPath;

		private bool isNeedTriggerOnFirstConnect = true;

		private const int isReadyForCheckEventErrorsLimitBase = 50;

		private int isReadyForCheckEventErrorsLimit = 50;

		private ICommandManager commandManager;

		private ITranslation translationManager;

		public static RainWeather sharedMeteorRain;

		public static RainWeather sharedAcidRain;

		private bool isNeedShowConnectMessage;

		private bool isNeedShowDisconnectMessage;

		private static bool isAppConnected;

		public static UtilityConsole console;

		public static bool networkIsKillSpawnsAfterPlayerDeath = true;

		public static bool networkIsEnableSpawnDeathTimer = true;

		public static int networkSpawnDeathTimerDuration = 150;

		public static bool IsAppConnected => isAppConnected;

		public static SettingsData Settings => instance?.eventsReader?.Settings ?? new SettingsData();

		public void Awake()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			((ILogger)LoggerFactory.Logger).Log((object)"InteractiveMod Awake");
			Game.isModded = true;
			console = new UtilityConsole(LoggerFactory.Logger, (List<string>)null);
			MainPatcher.InitPatch();
			instance = this;
		}

		public void OnDestroy()
		{
			instance = null;
			((ILogger)LoggerFactory.Logger).Log((object)"InteractiveMod destroy");
		}

		public static void ProcessStandardCommand(string command)
		{
			((ILogger)LoggerFactory.Logger).Log((object)("InteractiveMod add standard command '" + command + "' to queue"));
			GameProxy.RunGameConsoleCommand(command);
		}

		public void InitLogFlushTask()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0040: Expected O, but got Unknown
			GameProxy.ScheduleManager.NewPeriodicTask(new PeriodicTaskData
			{
				periodicAction = delegate
				{
					IDebugLogger logger = LoggerFactory.Logger;
					IDebugLogger obj = ((logger is BufferedLogger) ? logger : null);
					if (obj != null)
					{
						((BufferedLogger)obj).Flush(true);
					}
				},
				period = 5f
			}, false);
		}

		public void InitOthersManagers()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			((ILogger)LoggerFactory.Logger).Log((object)"init HelperLanguages");
			translationManager = (ITranslation)new HelperLanguagesFormatted((IDebugLogger)null);
			translationManager.InitFromFile(Path.Combine(UtilitySettings.BaseFolder, "langs.data"));
			((ILogger)LoggerFactory.Logger).Log((object)"init ScheduleManager");
			GameProxy.ReinitScheduleManager();
			InitLogFlushTask();
			isReadyForCheckEventErrorsLimit = 50;
		}

		public void InitCommands(bool isNeedValidate)
		{
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			console.RegisterCommand((IConsoleCommand)(object)new CustomSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new ChangeModel());
			console.RegisterCommand((IConsoleCommand)(object)new EnemiesRemover());
			console.RegisterCommand((IConsoleCommand)(object)new GodMod());
			console.RegisterCommand((IConsoleCommand)(object)new StandardWeather());
			console.RegisterCommand((IConsoleCommand)(object)new StatusEffect());
			console.RegisterCommand((IConsoleCommand)(object)new PoisonStatusEffect());
			console.RegisterCommand((IConsoleCommand)(object)new BurningStatusEffect());
			console.RegisterCommand((IConsoleCommand)(object)new ProjectileSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new MeteorSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new ItemsRepairer());
			console.RegisterCommand((IConsoleCommand)(object)new GiveItem());
			console.RegisterCommand((IConsoleCommand)(object)new RoadSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new DropInventory());
			sharedAcidRain = new RainWeather("acid_rain", "bonemass_throw_projectile", "oozebomb_explosion", "Bonemass", null, 2f);
			console.RegisterCommand((IConsoleCommand)(object)sharedAcidRain);
			sharedMeteorRain = new RainWeather("meteor_rain", "projectile_meteor", "", "Ashrain", new MeteorSpawner.MeteorProjectileParameters
			{
				aoe = 5f,
				damage = new DamageRanges
				{
					MinPhysicalDamage = 10f,
					MaxPhysicalDamage = 12f,
					MinElementalDamage = 10f,
					MaxElementalDamage = 15f
				}
			}, 2f);
			console.RegisterCommand((IConsoleCommand)(object)sharedMeteorRain);
			console.RegisterCommand((IConsoleCommand)(object)new GiveRandomItem());
			console.RegisterCommand((IConsoleCommand)(object)new RootsWeather());
			console.RegisterCommand((IConsoleCommand)(object)new FxEffectSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new SingleFxEffectSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new TestDamageFxEffectSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new Restoring());
			console.RegisterCommand((IConsoleCommand)(object)new WaterEnemiesSpawner());
			console.RegisterCommand((IConsoleCommand)(object)new ClearStatus());
			console.RegisterCommand((IConsoleCommand)(object)new Recall());
			console.RegisterCommand((IConsoleCommand)(object)new RemoveDrops());
			console.RegisterCommand((IConsoleCommand)(object)new RaiseSkill());
			console.RegisterCommand((IConsoleCommand)(object)new ChangeSpeed());
			console.RegisterCommand((IConsoleCommand)(object)new GiveItemInv());
			console.RegisterCommand((IConsoleCommand)(object)new ItemsRain());
			console.RegisterCommand((IConsoleCommand)(object)new SkipTime());
			console.RegisterCommand((IConsoleCommand)(object)new CustomSpawnerAnimal());
			TierCommand tierCommand = new TierCommand();
			console.RegisterCommand((IConsoleCommand)(object)tierCommand);
			commandManager = (ICommandManager)new HelperCommandManagerFormatted(LoggerFactory.Logger);
			commandManager.InitFromFile(Path.Combine(UtilitySettings.BaseFolder, "commands.data"));
			if (!isNeedValidate)
			{
				return;
			}
			tierCommand.IsValidPostCheck((string command) => console.IsValidCommandLine(command));
			((ILogger)LoggerFactory.Logger).Log((object)"init HelperCommandManager");
			string[] commands = commandManager.GetCommands();
			foreach (string text in commands)
			{
				if (!console.IsValidCommandLine(text?.Trim()))
				{
					LoggerFactory.Logger.LogDebugInfo((object)("command line '" + text + "' invalid"));
				}
			}
		}

		public void Start()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			((ILogger)LoggerFactory.Logger).Log((object)"InteractiveMod Start");
			eventsParser = (IEventsDataParser)new EventsDataParser((Action<string>)((ILogger)LoggerFactory.Logger).Log);
			((ILogger)LoggerFactory.Logger).Log((object)"init EventsReaderOnFrame");
			if (eventsReader == null)
			{
				eventsReader = new WebSocketEventsReader<SettingsData>((Action<IEventsData>)ProcessEvent, eventsParser, (Action<string>)((ILogger)LoggerFactory.Logger).Log, (Action<string>)((ILogger)LoggerFactory.Logger).Log, 1f, 1f, 0.5f);
				eventsReader.InitDefaultSocket(UtilitySettings.BaseFolder, "chaostricks_valheim", 13715, "127.0.0.1");
				eventsReader.OnOpen = delegate
				{
					isNeedShowConnectMessage = true;
					isNeedShowDisconnectMessage = false;
					isAppConnected = true;
				};
				eventsReader.OnCloseOnlyAfterConnect = delegate
				{
					isNeedShowDisconnectMessage = true;
					isNeedShowConnectMessage = false;
					isAppConnected = false;
				};
				Action<string> defaultOnConfig = eventsReader.SocketHandler.OnConfigMessage;
				eventsReader.SocketHandler.OnConfigMessage = delegate(string s)
				{
					defaultOnConfig?.Invoke(s);
					WearNTearRPC_DamagePatcher.buildingDamageModifier = Settings.buildingDamageModifier;
					networkIsKillSpawnsAfterPlayerDeath = Settings.isKillSpawnsAfterPlayerDeath;
					networkIsEnableSpawnDeathTimer = Settings.isEnableSpawnDeathTimer;
					networkSpawnDeathTimerDuration = Settings.spawnDeathTimerDuration;
				};
				eventsReader.OpenSocket(true);
			}
			((ILogger)LoggerFactory.Logger).Log((object)"init EventsReaderOnKey");
			keyEventsPath = Path.Combine(UtilitySettings.BaseFolder, "events_key.txt");
			eventsReaderByKey = (IEventsReaderOnKey)new EventsReaderOnKey((Action<IEventsData>)ProcessEvent, eventsParser, (Action<string>)((ILogger)LoggerFactory.Logger).Log, (Action<string>)null);
			InitCommands(GameProxy.IsDebugMode());
			InitOthersManagers();
			((ILogger)LoggerFactory.Logger).Log((object)"InteractiveMod init ended (2.2.2)");
		}

		private void ProcessEvent(IEventsData data)
		{
			string eventID = data.EventID;
			if (!string.IsNullOrEmpty(eventID))
			{
				((ILogger)LoggerFactory.Logger).Log((object)("try to execute event: '" + eventID + "'"));
				string commandLine = commandManager.GetCommandData(eventID, true)?.Trim();
				ProcessCommands(commandLine, data);
			}
		}

		private void ProcessCommands(string commandLine, IEventsData data)
		{
			((ILogger)LoggerFactory.Logger).Log((object)("command: " + commandLine));
			if (console.RunCommand(commandLine, data, (Action<string>)ProcessStandardCommand))
			{
				((ILogger)LoggerFactory.Logger).Log((object)("event '" + data.EventID + "' executing is completed"));
				string trans = translationManager.GetTrans(data.EventID, data.Lang);
				trans = trans.Replace("%name%", data.Username);
				NotifyController.instance.AddNotifyToQueue(trans);
			}
			else
			{
				((ILogger)LoggerFactory.Logger).Log((object)("event '" + data.EventID + "' executing is failed"));
			}
		}

		public bool IsReadyForCheckEvent()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name != "main")
				{
					return false;
				}
				Player currentPlayer = GameProxy.CurrentPlayer;
				return !((Object)(object)currentPlayer == (Object)null) && !((Character)currentPlayer).IsDead() && !((Character)currentPlayer).IsTeleporting() && !((Character)currentPlayer).InCutscene() && !currentPlayer.IsSleeping() && !((Object)(object)ZNet.instance == (Object)null) && !((Object)(object)ObjectDB.instance == (Object)null) && !((Object)(object)ZNetScene.instance == (Object)null);
			}
			catch (Exception arg)
			{
				if (isReadyForCheckEventErrorsLimit > 0)
				{
					((ILogger)LoggerFactory.Logger).Log((object)$"IsReadyForCheckEvent error: {arg}");
					isReadyForCheckEventErrorsLimit--;
				}
				return false;
			}
		}

		public void Update()
		{
			try
			{
				if (IsReadyForCheckEvent())
				{
					if (isNeedTriggerOnFirstConnect)
					{
						GameProxy.RunGameConsoleCommand("s Waiting until an integration will be started in the PC application Chaos Tricks");
						isNeedTriggerOnFirstConnect = false;
					}
					if (isNeedShowConnectMessage)
					{
						isNeedShowConnectMessage = false;
						GameProxy.RunGameConsoleCommand("s Chaos Tricks connected!");
					}
					if (isNeedShowDisconnectMessage)
					{
						isNeedShowDisconnectMessage = false;
						GameProxy.RunGameConsoleCommand("s Chaos Tricks disconnected!");
						GameProxy.RunGameConsoleCommand("nonono");
					}
					((EventsReaderOnFrame)eventsReader).ReadAndProcessAllWithDelayOnFrame(Time.deltaTime);
					if (Input.GetKey((KeyCode)306) && Input.GetKeyDown((KeyCode)261))
					{
						eventsReaderByKey.ReadAndProcessAllOnKey(keyEventsPath, false);
					}
					DebugHotkeysOnUpdate();
				}
				StandardConsoleManager.instance.Update();
				NotifyController.instance.Update();
				SummonController.instance.OnUpdate(Time.deltaTime);
				GameProxy.ScheduleManager.OnUpdate(Time.deltaTime);
			}
			catch (Exception arg)
			{
				if (isReadyForCheckEventErrorsLimit > 0)
				{
					((ILogger)LoggerFactory.Logger).Log((object)$"onUpdate error: {arg}");
					isReadyForCheckEventErrorsLimit--;
				}
			}
		}

		public static void ReinitMod()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			((ILogger)LoggerFactory.Logger).Log((object)"ReinitMod");
			MeteorSpawner.RemoveMeteorOwner();
			SummonController.instance?.ClearEnemies();
			NotifyController.instance?.ClearQueue();
			console = new UtilityConsole(LoggerFactory.Logger, (List<string>)null);
			if (instance != null)
			{
				instance.InitCommands(isNeedValidate: false);
				instance.InitOthersManagers();
			}
			StandardConsoleManager.instance = new StandardConsoleManager();
		}

		public void DebugHotkeysOnUpdate()
		{
			if (!GameProxy.IsDebugMode())
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)278))
			{
				ReinitMod();
			}
			if (Input.GetKeyDown((KeyCode)265))
			{
				EnemiesRemover.KillAll();
			}
			if (Input.GetKey((KeyCode)306))
			{
				if (Input.GetKeyDown((KeyCode)260))
				{
					DebugInfo();
				}
				else if (Input.GetKeyDown((KeyCode)263))
				{
					DebugInfoItemPrefabs();
					DebugInfoObjectPrefabs();
					DebugInfoStatusEffects();
				}
				else if (Input.GetKeyDown((KeyCode)264))
				{
					DebugPosInfo();
				}
			}
		}

		public void DebugInfo()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (EnvSetup environment in EnvMan.instance.m_environments)
			{
				stringBuilder.Append(environment.m_name + "\n");
			}
			((ILogger)LoggerFactory.Logger).Log((object)$"env list:\n{stringBuilder}");
		}

		public void DebugPosInfo()
		{
			bool flag = GameProxy.IsPlayerCloseToOthers(GameProxy.CurrentPlayer, GameProxy.TargetPlayers, 30f);
			((ILogger)LoggerFactory.Logger).Log((object)$"Close to others: {flag}");
		}

		public void DebugInfoItemPrefabs()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				stringBuilder.Append(((Object)item).name + "\n");
			}
			((ILogger)LoggerFactory.Logger).Log((object)$"\n\nprefab names list:\n{stringBuilder}");
		}

		public void DebugInfoObjectPrefabs()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				stringBuilder.Append(((prefab != null) ? ((Object)prefab).name : null) + "\n");
			}
			((ILogger)LoggerFactory.Logger).Log((object)$"\n\nnet prefab names list:\n{stringBuilder}");
			if (ZNetScene.instance.m_nonNetViewPrefabs == null)
			{
				return;
			}
			stringBuilder = new StringBuilder();
			foreach (GameObject nonNetViewPrefab in ZNetScene.instance.m_nonNetViewPrefabs)
			{
				stringBuilder.Append(((nonNetViewPrefab != null) ? ((Object)nonNetViewPrefab).name : null) + "\n");
			}
			((ILogger)LoggerFactory.Logger).Log((object)$"\n\nnon net prefab names list:\n{stringBuilder}");
		}

		public void DebugInfoStatusEffects()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (StatusEffect statusEffect in ObjectDB.instance.m_StatusEffects)
			{
				stringBuilder.Append(((statusEffect != null) ? ((Object)statusEffect).name : null) + "\n");
			}
			((ILogger)LoggerFactory.Logger).Log((object)$"\n\nnet status effect names list:\n{stringBuilder}");
		}
	}
	public class SettingsData
	{
		public bool isAllPlayers = true;

		public int hitpointsModifier = 100;

		public int spawnDamageModifier = 100;

		public int buildingDamageModifier = 25;

		public bool isSpawnsHaveDrop;

		public bool isKillSpawnsAfterPlayerDeath = true;

		public bool isEnableSpawnDeathTimer = true;

		public int spawnDeathTimerDuration = 150;

		public string meteorSpawnerType = "Ghost";
	}
	public class NotifyController
	{
		public static NotifyController instance = new NotifyController();

		private readonly Queue<string> notifies = new Queue<string>();

		private readonly int baseDelay = 2;

		private float delay;

		public void AddNotifyToQueue(string msg)
		{
			notifies.Enqueue(msg);
		}

		public void ClearQueue()
		{
			notifies.Clear();
		}

		public void Update()
		{
			if (delay > 0f)
			{
				delay -= Time.deltaTime;
			}
			else if (notifies.Count > 0 && !((Object)(object)MessageHud.instance == (Object)null))
			{
				string text = notifies.Dequeue();
				((ILogger)LoggerFactory.Logger).Log((object)("Show notify " + text));
				MessageHud.instance.MessageAll((MessageType)2, text);
				delay = baseDelay;
			}
		}
	}
	public class StandardConsoleManager
	{
		public static StandardConsoleManager instance = new StandardConsoleManager();

		private readonly Queue<string> commands = new Queue<string>();

		private int logChatLimit = 10;

		public void AddCommandToQueue(string command)
		{
			commands.Enqueue(command);
		}

		public void InstantlyRunCommand(string command)
		{
			try
			{
				((ILogger)LoggerFactory.Logger).Log((object)"prepare chat");
				((TMP_InputField)((Terminal)Console.instance).m_input).text = command;
				((ILogger)LoggerFactory.Logger).Log((object)("trigger standard command " + command));
				GameProxy.TriggerConsoleInputText();
				((TMP_InputField)((Terminal)Console.instance).m_input).text = string.Empty;
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"InstantlyRunCommand error: {arg}");
			}
		}

		public void Update()
		{
			try
			{
				if (commands.Count <= 0)
				{
					return;
				}
				if ((Object)(object)Console.instance == (Object)null || (Object)(object)((Terminal)Console.instance).m_input == (Object)null)
				{
					if (logChatLimit > 0)
					{
						logChatLimit--;
						((ILogger)LoggerFactory.Logger).LogWarning((object)$"InstantlyRunCommand->Update error: ci or cim null ({(Object)(object)Console.instance == (Object)null})");
					}
				}
				else
				{
					InstantlyRunCommand(commands.Dequeue());
				}
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"StandardConsoleManager error: {arg}");
			}
		}
	}
}
namespace valheim_mod.Patchers
{
	[HarmonyPatch(typeof(Game))]
	[HarmonyPatch("OnDestroy")]
	public class LocalGameOnDestroyPatcher
	{
		public static void Prefix(Game __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				((ILogger)LoggerFactory.Logger).Log((object)"Game OnDestroy prefix");
				InteractiveMod.ReinitMod();
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)string.Format("{0} error: {1}", "Game OnDestroy prefix", arg));
			}
		}
	}
	[HarmonyPatch(typeof(Player))]
	[HarmonyPatch("OnDestroy")]
	public class LocalPlayerOnDestroyPatcher
	{
		public static void Prefix(Player __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)Player.m_localPlayer != (Object)(object)__instance))
			{
				((ILogger)LoggerFactory.Logger).Log((object)"Player OnDestroy prefix");
			}
		}
	}
	[HarmonyPatch(typeof(Character))]
	[HarmonyPatch("RPC_Damage")]
	public class CharacterRPC_DamagePatcher
	{
		private static readonly FieldRef<Character, ZNetView> m_nviewRef = AccessTools.FieldRefAccess<Character, ZNetView>("m_nview");

		private static bool isNeedTestPatchingLog = true;

		public static readonly string CustomMinDamageId = "min_attack_damage";

		public static readonly string CustomMaxDamageId = "max_attack_damage";

		public static readonly string CustomMinElemDamageId = "min_attack_elem_damage";

		public static readonly string CustomMaxElemDamageId = "max_attack_elem_damage";

		public static void SetupHitData(HitData hit, float damage, float elemDamage)
		{
			if (hit.m_damage.m_damage != 0f)
			{
				hit.m_damage.m_damage = damage;
			}
			if (hit.m_damage.m_blunt != 0f)
			{
				hit.m_damage.m_blunt = damage;
			}
			if (hit.m_damage.m_chop != 0f)
			{
				hit.m_damage.m_chop = damage;
			}
			if (hit.m_damage.m_fire != 0f)
			{
				hit.m_damage.m_fire = elemDamage;
			}
			if (hit.m_damage.m_frost != 0f)
			{
				hit.m_damage.m_frost = elemDamage;
			}
			if (hit.m_damage.m_lightning != 0f)
			{
				hit.m_damage.m_lightning = elemDamage;
			}
			if (hit.m_damage.m_pickaxe != 0f)
			{
				hit.m_damage.m_pickaxe = damage;
			}
			if (hit.m_damage.m_pierce != 0f)
			{
				hit.m_damage.m_pierce = damage;
			}
			if (hit.m_damage.m_poison != 0f)
			{
				hit.m_damage.m_poison = elemDamage;
			}
			if (hit.m_damage.m_spirit != 0f)
			{
				hit.m_damage.m_spirit = elemDamage;
			}
			if (hit.m_damage.m_slash != 0f)
			{
				hit.m_damage.m_slash = damage;
			}
		}

		private static float ApplyAC(float ac, float damage)
		{
			if (damage == 0f)
			{
				return 0f;
			}
			if (ac <= (ac + damage) * 0.5f)
			{
				return ac + damage;
			}
			float num = Mathf.Sqrt(damage * ac * 4f);
			if (damage <= num)
			{
				return num;
			}
			return damage;
		}

		private static void ProcessHit(Character player, ZDO zdo, HitData hit)
		{
			float @float = zdo.GetFloat(CustomMinDamageId, -1f);
			if (@float == -1f)
			{
				((ILogger)LoggerFactory.Logger).Log((object)"CharacterPatcher catch hit from default enemy");
				return;
			}
			float float2 = zdo.GetFloat(CustomMaxDamageId, @float + 2f);
			float baseDamage = Random.Range(@float, float2);
			float float3 = zdo.GetFloat(CustomMinElemDamageId, 0f);
			float float4 = zdo.GetFloat(CustomMaxElemDamageId, 0f);
			float baseElemDamage = Random.Range(float3, float4);
			if (((DamageTypes)(ref hit.m_damage)).GetTotalElementalDamage() == 0f)
			{
				baseElemDamage = 0f;
			}
			ApplyArmor(player.GetBodyArmor(), hit, baseDamage, baseElemDamage);
		}

		private static void ApplyArmor(float ac, HitData hit, float baseDamage, float baseElemDamage)
		{
			float num = 1f;
			if (hit.m_damage.m_poison == 0f && (baseDamage != 0f || baseElemDamage != 0f))
			{
				float num2 = baseElemDamage + baseDamage;
				num = ApplyAC(ac, num2) / num2;
			}
			else
			{
				((ILogger)LoggerFactory.Logger).Log((object)"poison damage fixed");
			}
			float num3 = baseDamage * num;
			float num4 = baseElemDamage * num;
			SetupHitData(hit, num3, num4);
			((ILogger)LoggerFactory.Logger).Log((object)($"CharacterPatcher catch hit {num3} with armor {ac} for base {baseDamage}. " + $"Elem damage {num4} for base {baseElemDamage}"));
		}

		public static void Prefix(Character __instance, long sender, HitData hit)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !__instance.IsPlayer() || hit == null || __instance.IsDebugFlying() || __instance.IsDead() || __instance.IsTeleporting() || __instance.InCutscene())
			{
				return;
			}
			try
			{
				if (isNeedTestPatchingLog)
				{
					isNeedTestPatchingLog = false;
					((ILogger)LoggerFactory.Logger).Log((object)"CharacterPatcher ApplyDamage Prefix debug");
				}
				ZNetView val = m_nviewRef.Invoke(__instance);
				if (!((Object)(object)val == (Object)null) && val.IsValid())
				{
					ZDO zDO = ZDOMan.instance.GetZDO(hit.m_attacker);
					if (zDO != null)
					{
						ProcessHit(__instance, zDO, hit);
					}
				}
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"CharacterPatcher FixedUpdate Prefix error: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear))]
	[HarmonyPatch("RPC_Damage")]
	public class WearNTearRPC_DamagePatcher
	{
		public static int buildingDamageModifier = 25;

		private static void Prefix(ref HitData hit, Piece ___m_piece)
		{
			if (hit == null)
			{
				return;
			}
			Character attacker = hit.GetAttacker();
			if ((Object)(object)attacker == (Object)null)
			{
				return;
			}
			ZDO zDO = GameProxy.GetZDO(attacker);
			if (zDO != null)
			{
				string @string = zDO.GetString(GameProxy.PlayerNameSpawnId, "");
				((ILogger)LoggerFactory.Logger).Log((object)("EnemiesRemover PlayerName " + @string));
				bool flag = (Object)(object)___m_piece != (Object)null && ___m_piece.GetCreator() == 0;
				if (!string.IsNullOrEmpty(@string) && !flag)
				{
					float coeff = (float)buildingDamageModifier / 100f;
					MultiplyDamage(hit, coeff);
				}
			}
		}

		private static void MultiplyDamage(HitData hit, float coeff)
		{
			float num = Math.Max(0f, coeff);
			hit.m_damage.m_damage *= num;
			hit.m_damage.m_blunt *= num;
			hit.m_damage.m_chop *= num;
			hit.m_damage.m_fire *= num;
			hit.m_damage.m_frost *= num;
			hit.m_damage.m_lightning *= num;
			hit.m_damage.m_pickaxe *= num;
			hit.m_damage.m_pierce *= num;
			hit.m_damage.m_slash *= num;
			hit.m_damage.m_poison *= num;
			hit.m_damage.m_spirit *= num;
		}
	}
	public class MainPatcher
	{
		public static void InitPatch()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				((ILogger)LoggerFactory.Logger).Log((object)"HelperPatcher init");
				new Harmony("com.Loki.patch").PatchAll();
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"HelperPatcher error: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(ZNet))]
	[HarmonyPatch("Awake")]
	public class ZPackagePatcher
	{
		private static void Postfix()
		{
			ZRoutedRpc.instance.Register<ZPackage>("bft_ChangeSpeed", (Action<long, ZPackage>)ChangePlayerSpeed);
			ZRoutedRpc.instance.Register("bft_ClearStatus", (Action<long>)ChangePlayerStatus);
			ZRoutedRpc.instance.Register("bft_DropInventory", (Action<long>)DropPlayerInventory);
			ZRoutedRpc.instance.Register<ZPackage>("bft_GodMod", (Action<long, ZPackage>)PlayerGodmod);
			ZRoutedRpc.instance.Register<ZPackage>("bft_RaiseSkill", (Action<long, ZPackage>)ChangePlayerSkill);
			ZRoutedRpc.instance.Register<ZPackage>("bft_StandardWeather", (Action<long, ZPackage>)ChangePlayerWeather);
			ZRoutedRpc.instance.Register<ZPackage>("bft_SingleFxEffectSpawner", (Action<long, ZPackage>)SpawnSingleFxFunc);
			ZRoutedRpc.instance.Register<ZPackage>("bft_GiveItemInInv", (Action<long, ZPackage>)GiveItemInPlayerInv);
			ZRoutedRpc.instance.Register("bft_ChangeModel", (Action<long>)ChangePlayerModel);
			ZRoutedRpc.instance.Register("bft_ItemsRepairer", (Action<long>)RepairAllPlayer);
			ZRoutedRpc.instance.Register<ZPackage>("bft_ChangeSpawnedMobNames", (Action<long, ZPackage>)ChangeSpawnedMobNames);
			ZRoutedRpc.instance.Register<ZPackage>("bft_ChangePlayerDebugEnv", (Action<long, ZPackage>)ChangePlayerDebugEnv);
			ZRoutedRpc.instance.Register("bft_RemoveDrops", (Action<long>)RemovePlayerDrops);
			ZRoutedRpc.instance.Register("bft_SkipTime", (Action<long>)HostSkipTime);
			ZRoutedRpc.instance.Register("bft_Recall", (Action<long>)HostRecall);
			ZRoutedRpc.instance.Register<ZPackage>("bft_CustomSpawner", (Action<long, ZPackage>)SpawnMobs);
			ZRoutedRpc.instance.Register<ZPackage>("bft_CustomSpawnerAnimal", (Action<long, ZPackage>)SpawnAnimalMobs);
			ZRoutedRpc.instance.Register<ZPackage>("bft_CustomSpawnerWater", (Action<long, ZPackage>)SpawnWaterMobs);
			ZRoutedRpc.instance.Register<ZPackage>("bft_FxEffectSpawner", (Action<long, ZPackage>)NetworkFxEffectSpawner);
			ZRoutedRpc.instance.Register<ZPackage>("bft_GiveItem", (Action<long, ZPackage>)NetworkGiveItem);
			ZRoutedRpc.instance.Register<ZPackage>("bft_GiveRandomItem", (Action<long, ZPackage>)NetworkGiveRandomItem);
			ZRoutedRpc.instance.Register<ZPackage>("bft_StatusEffect", (Action<long, ZPackage>)NetworkStatusEffect);
			ZRoutedRpc.instance.Register<ZPackage>("bft_RoadSpawner", (Action<long, ZPackage>)NetworkRoadSpawner);
			ZRoutedRpc.instance.Register("bft_BurningStatusEffect", (Action<long>)NetworkBurningStatusEffect);
			ZRoutedRpc.instance.Register("bft_PoisonStatusEffect", (Action<long>)NetworkPoisonStatusEffect);
			ZRoutedRpc.instance.Register("bft_Restoring", (Action<long>)NetworkRestoring);
			ZRoutedRpc.instance.Register("bft_EnemiesRemover", (Action<long>)NetworkEnemiesRemover);
		}

		private static void ChangePlayerSpeed(long id, ZPackage package)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"ChangePlayerSpeed CurrentPlayer {GameProxy.CurrentPlayer}");
			double num = package.ReadDouble();
			int num2 = package.ReadInt();
			LoggerFactory.Logger.LogDebugInfo((object)$"speedCoeff {num} timer {num2}");
			ChangeSpeed.sharedInstance?.ActivateChangeSpeedTimer((float)num, num2);
		}

		private static void ChangePlayerStatus(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"ClearPlayerStatus CurrentPlayer {GameProxy.CurrentPlayer}");
			ClearStatus.sharedInstance?.ClearPlayerStatus();
		}

		private static void DropPlayerInventory(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"DropPlayerInventory CurrentPlayer {GameProxy.CurrentPlayer}");
			DropInventory.sharedInstance?.DropLocalPlayerInventory();
		}

		private static void PlayerGodmod(long id, ZPackage package)
		{
			int num = package.ReadInt();
			LoggerFactory.Logger.LogDebugInfo((object)$"PlayerGodmod CurrentPlayer {GameProxy.CurrentPlayer} for {num}");
			GodMod.sharedInstance?.CreateGodModTimer(num);
		}

		private static void ChangePlayerSkill(long id, ZPackage package)
		{
			string text = package.ReadString();
			int lvl = package.ReadInt();
			LoggerFactory.Logger.LogDebugInfo((object)$"ChangePlayerSkill CurrentPlayer {GameProxy.CurrentPlayer} skill param {text} ");
			RaiseSkill.sharedInstance?.SwitchFunc(text, lvl);
		}

		private static void ChangePlayerWeather(long id, ZPackage package)
		{
			string text = package.ReadString();
			int num = package.ReadInt();
			LoggerFactory.Logger.LogDebugInfo((object)$"ChangePlayerWeather CurrentPlayer {GameProxy.CurrentPlayer} weather {text} for {num}");
			StandardWeather.ChangeWeather(text, num);
		}

		private static void SpawnSingleFxFunc(long id, ZPackage package)
		{
			string text = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"ChangePlayerWeather CurrentPlayer {GameProxy.CurrentPlayer} spawn fx {text}");
			SingleFxEffectSpawner.SpawnFX(GameProxy.CurrentPlayer, text);
		}

		private static void GiveItemInPlayerInv(long id, ZPackage package)
		{
			string text = package.ReadString();
			int num = package.ReadInt();
			bool flag = package.ReadBool();
			LoggerFactory.Logger.LogDebugInfo((object)$"GiveItemInPlayerInv CurrentPlayer {GameProxy.CurrentPlayer} items {text} count {num} in inv {flag}");
			GiveItemInv.GiveRandomItem(GameProxy.CurrentPlayer, text, num, flag);
		}

		private static void ChangePlayerModel(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"ChangePlayersModel CurrentPlayer {GameProxy.CurrentPlayer}");
			ChangeModel.SwitchPlayerModel(GameProxy.CurrentPlayer);
		}

		private static void RepairAllPlayer(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"RepairAllPlayer CurrentPlayer {GameProxy.CurrentPlayer}");
			ItemsRepairer.RepairAll();
		}

		private static void ChangeSpawnedMobNames(long id, ZPackage package)
		{
			uint num = package.ReadUInt();
			long num2 = package.ReadLong();
			string text = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"ChangeSpawnedMobNames CurrentPlayer {GameProxy.CurrentPlayer}, objectId {num}, userId {num2}, name {text}");
			SummonController.instance.AddPackageCharacter(new SummonController.PackageEnemiesData
			{
				id = num,
				userId = num2,
				name = text
			});
		}

		private static NetworkSpawnData ReadSpawnData(ZPackage package, bool isAnimal)
		{
			int num = package.ReadInt();
			int num2 = package.ReadInt();
			int buildingDamageModifier = package.ReadInt();
			bool flag = package.ReadBool();
			bool flag2 = package.ReadBool();
			bool flag3 = package.ReadBool();
			int num3 = package.ReadInt();
			string argName = package.ReadString();
			int argCount = package.ReadInt();
			int argLevel = package.ReadInt();
			float argHitsPercent = package.ReadSingle();
			float argMinPhysicalDamage = package.ReadSingle();
			float num4 = package.ReadSingle();
			float argMinElementalDamage = package.ReadSingle();
			float argMaxElementalDamage = package.ReadSingle();
			string text = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"ReadSpawnData hpm {num}, sdm {num2}, username {text}");
			SettingsData settings = InteractiveMod.Settings;
			if (InteractiveMod.IsAppConnected)
			{
				return new NetworkSpawnData
				{
					spawnDamageModifier = settings.spawnDamageModifier,
					hitpointsModifier = settings.hitpointsModifier,
					buildingDamageModifier = settings.buildingDamageModifier,
					isSpawnsHaveDrop = (isAnimal ? flag : settings.isSpawnsHaveDrop),
					isKillSpawnsAfterPlayerDeath = settings.isKillSpawnsAfterPlayerDeath,
					isEnableSpawnDeathTimer = settings.isEnableSpawnDeathTimer,
					spawnDeathTimerDuration = settings.spawnDeathTimerDuration,
					argName = argName,
					argCount = argCount,
					argLevel = argLevel,
					argHitsPercent = argHitsPercent,
					argMaxElementalDamage = argMaxElementalDamage,
					argMinElementalDamage = argMinElementalDamage,
					argMaxPhysicalDamage = num4,
					argMinPhysicalDamage = argMinPhysicalDamage,
					username = text
				};
			}
			WearNTearRPC_DamagePatcher.buildingDamageModifier = buildingDamageModifier;
			InteractiveMod.networkIsKillSpawnsAfterPlayerDeath = flag2;
			InteractiveMod.networkIsEnableSpawnDeathTimer = flag3;
			InteractiveMod.networkSpawnDeathTimerDuration = num3;
			return new NetworkSpawnData
			{
				spawnDamageModifier = num2,
				hitpointsModifier = num,
				buildingDamageModifier = buildingDamageModifier,
				isSpawnsHaveDrop = flag,
				isKillSpawnsAfterPlayerDeath = flag2,
				isEnableSpawnDeathTimer = flag3,
				spawnDeathTimerDuration = num3,
				argName = argName,
				argCount = argCount,
				argLevel = argLevel,
				argHitsPercent = argHitsPercent,
				argMaxElementalDamage = num4,
				argMinPhysicalDamage = argMinPhysicalDamage,
				argMaxPhysicalDamage = num4,
				argMinElementalDamage = argMinElementalDamage,
				username = text
			};
		}

		private static void SpawnMobs(long id, ZPackage package)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"SpawnMobs CurrentPlayer {GameProxy.CurrentPlayer}, package {id}");
			CustomSpawner.RPC_SpawnObjects(ReadSpawnData(package, isAnimal: false));
		}

		private static void SpawnAnimalMobs(long id, ZPackage package)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"SpawnAnimalMobs CurrentPlayer {GameProxy.CurrentPlayer}, package {id}");
			CustomSpawnerAnimal.RPC_SpawnObjects(ReadSpawnData(package, isAnimal: true));
		}

		private static void SpawnWaterMobs(long id, ZPackage package)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"SpawnWaterMobs CurrentPlayer {GameProxy.CurrentPlayer}, package {id}");
			WaterEnemiesSpawner.RPC_SpawnObjectsInWater(ReadSpawnData(package, isAnimal: false));
		}

		private static void ChangePlayerDebugEnv(long id, ZPackage package)
		{
			string text = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"ChangePlayerDebugEnv CurrentPlayer {GameProxy.CurrentPlayer} weather {text}");
			EnvMan.instance.m_debugEnv = text;
		}

		private static void RemovePlayerDrops(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"RemovePlayerDrops CurrentPlayer {GameProxy.CurrentPlayer}");
			RemoveDrops.sharedInstance?.RemoveAllDrops();
		}

		private static void HostSkipTime(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"HostSkipTime CurrentPlayer {GameProxy.CurrentPlayer}");
			if (ZNet.instance.IsServer())
			{
				SkipTime.sharedInstance?.SkipHalfDay();
			}
		}

		private static void HostRecall(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"HostRecall CurrentPlayer {GameProxy.CurrentPlayer}");
			if (ZNet.instance.IsServer())
			{
				Recall.sharedInstance?.SendRecall();
			}
		}

		private static void NetworkFxEffectSpawner(long id, ZPackage package)
		{
			string text = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkFxEffectSpawner CurrentPlayer {GameProxy.CurrentPlayer}, name {text}");
			FxEffectSpawner.SpawnFX(GameProxy.CurrentPlayer, text);
		}

		private static void NetworkGiveItem(long id, ZPackage package)
		{
			string text = package.ReadString();
			int count = package.ReadInt();
			int level = package.ReadInt();
			string username = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkGiveItem CurrentPlayer {GameProxy.CurrentPlayer}, item {text}");
			GiveItem.GiveItems(GameProxy.CurrentPlayer, text, count, level, username);
		}

		private static void NetworkGiveRandomItem(long id, ZPackage package)
		{
			string text = package.ReadString();
			int count = package.ReadInt();
			string username = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkGiveRandomItem CurrentPlayer {GameProxy.CurrentPlayer}, group {text}");
			GiveRandomItem.sharedInstance?.SpawnItem(GameProxy.CurrentPlayer, text, count, username);
		}

		private static void NetworkStatusEffect(long id, ZPackage package)
		{
			string text = package.ReadString();
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkStatusEffect CurrentPlayer {GameProxy.CurrentPlayer}, name {text}");
			StatusEffect.AddStatusEffect(GameProxy.CurrentPlayer, text);
		}

		private static void NetworkRoadSpawner(long id, ZPackage package)
		{
			int num = package.ReadInt();
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkRoadSpawner CurrentPlayer {GameProxy.CurrentPlayer}, timer {num}");
			RoadSpawner.SpawnRoad(GameProxy.CurrentPlayer, num);
		}

		private static void NetworkBurningStatusEffect(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkBurningStatusEffect CurrentPlayer {GameProxy.CurrentPlayer}");
			BurningStatusEffect.AddBurningEffect(GameProxy.CurrentPlayer);
		}

		private static void NetworkPoisonStatusEffect(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkPoisonStatusEffect CurrentPlayer {GameProxy.CurrentPlayer}");
			PoisonStatusEffect.AddPoisonEffect(GameProxy.CurrentPlayer);
		}

		private static void NetworkRestoring(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkRestoring CurrentPlayer {GameProxy.CurrentPlayer}");
			Restoring.SetFullHealAndStamina(GameProxy.CurrentPlayer);
		}

		private static void NetworkEnemiesRemover(long id)
		{
			LoggerFactory.Logger.LogDebugInfo((object)$"NetworkEnemiesRemover CurrentPlayer {GameProxy.CurrentPlayer}");
			EnemiesRemover.KillAll();
		}
	}
}
namespace valheim_mod.Commands
{
	public class ChangeSpeed : IConsoleCommand
	{
		public float basePlayerSpeed;

		public bool isActive;

		public static ChangeSpeed sharedInstance;

		public virtual string Id => "change_speed";

		public ChangeSpeed()
		{
			sharedInstance = this;
		}

		public virtual bool Execute(IEnumerable<string> args)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			IEnumerator<string> args2 = args?.GetEnumerator();
			float num = CommandsArgsReader.ReadFloat(args2, 1f);
			int num2 = CommandsArgsReader.ReadInt(args2, 0);
			if (!isActive)
			{
				if (InteractiveMod.Settings.isAllPlayers)
				{
					ZPackage val = new ZPackage();
					val.Write((double)num);
					val.Write(num2);
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_ChangeSpeed", new object[1] { val });
				}
				else
				{
					ActivateChangeSpeedTimer(num, num2);
				}
			}
			return true;
		}

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

		private void ChangePlayerSpeed(Character player, float speed)
		{
			player.m_runSpeed = speed;
		}

		public void ActivateChangeSpeedTimer(float speedCoeff, int timer)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00a5: Expected O, but got Unknown
			if (!isActive)
			{
				basePlayerSpeed = ((Character)GameProxy.CurrentPlayer).m_runSpeed;
				((ILogger)LoggerFactory.Logger).Log((object)$"Base player speed {basePlayerSpeed}");
				isActive = true;
			}
			Player currentPlayer = GameProxy.CurrentPlayer;
			float num = basePlayerSpeed * speedCoeff;
			ChangePlayerSpeed((Character)(object)currentPlayer, num);
			((ILogger)LoggerFactory.Logger).Log((object)$"Change speed for {num}");
			GameProxy.ScheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				duration = timer,
				finishAction = delegate
				{
					ChangePlayerSpeed((Character)(object)GameProxy.CurrentPlayer, basePlayerSpeed);
					((ILogger)LoggerFactory.Logger).Log((object)$"Changed speed ends, default speed is set to {basePlayerSpeed}");
					isActive = false;
				}
			}, false);
		}
	}
	public class ClearStatus : IConsoleCommand
	{
		public static ClearStatus sharedInstance;

		public virtual string Id => "player_clearstatus";

		public ClearStatus()
		{
			sharedInstance = this;
		}

		public virtual bool Execute(IEnumerable<string> args)
		{
			if (InteractiveMod.Settings.isAllPlayers)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_ClearStatus", Array.Empty<object>());
			}
			else
			{
				ClearPlayerStatus();
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CommandsValidator.IsZeroArgs(args);
		}

		public void ClearPlayerStatus()
		{
			GameProxy.CurrentPlayer.ClearHardDeath();
			((Character)GameProxy.CurrentPlayer).GetSEMan().RemoveAllStatusEffects(false);
		}
	}
	public class CustomSpawnerAnimal : IConsoleCommandWithData, IConsoleCommand
	{
		public virtual string Id => "custom_spawn_animal";

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

		public virtual bool Execute(IEnumerable<string> args, IEventsData data)
		{
			IEnumerator<string> enumerator = args?.GetEnumerator();
			string name = CommandsArgsReader.ReadString(enumerator);
			int count = CommandsArgsReader.ReadInt(enumerator, 1);
			int level = CommandsArgsReader.ReadInt(enumerator, 0);
			bool flag = CommandsArgsReader.ReadBool(enumerator, defaultValue: true);
			float hitsPercent = CommandsArgsReader.ReadFloat(enumerator, 1f);
			DamageRanges damageRanges = new DamageRanges();
			damageRanges.ReadFromArgs(enumerator);
			if (InteractiveMod.Settings.isAllPlayers)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_CustomSpawnerAnimal", new object[1] { CustomSpawner.GenerateSpawnPackage(name, count, level, hitsPercent, flag, damageRanges, data) });
			}
			else
			{
				SpawnObjects(name, count, level, hitsPercent, damageRanges, flag, data);
			}
			return true;
		}

		public static bool IsValidSpawnCommandArgs(IEnumerable<string> args)
		{
			IEnumerator<string> enumerator = args.GetEnumerator();
			if (CommandsValidator.IsValidString(enumerator, (string name) => (Object)(object)ZNetScene.instance != (Object)null && Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(name))) && CommandsValidator.IsValidInt(enumerator, 1, 20, isSkippable: true) && CommandsValidator.IsValidInt(enumerator, 0, 3, isSkippable: true) && CommandsValidator.IsValidBool(enumerator) && CommandsValidator.IsValidFloat(enumerator, 0f, 50f, isSkippable: true))
			{
				return DamageRanges.IsValidDamage(enumerator, isSkippable: true);
			}
			return false;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return IsValidSpawnCommandArgs(args);
		}

		public static void ProcessDropItems(GameObject obj, bool enableDrop)
		{
			CharacterDrop componentInChildren = obj.GetComponentInChildren<CharacterDrop>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				if (enableDrop)
				{
					LoggerFactory.Logger.LogDebugInfo((object)"drop items fixed");
					componentInChildren.SetDropsEnabled(true);
				}
				else
				{
					LoggerFactory.Logger.LogDebugInfo((object)"drop items fixed");
					componentInChildren.SetDropsEnabled(false);
					componentInChildren.m_drops = new List<Drop>();
				}
			}
		}

		public static GameObject SpawnSingleObject(GameObject prefab, Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(prefab, pos, Quaternion.identity);
			CustomSpawner.ProcessDurability(obj);
			CustomSpawner.ProcessQuality(obj, 1);
			return obj;
		}

		public static void SpawnObjects(string name, int count, int level, float hitsPercent, DamageRanges damage, bool enableDrop, IEventsData data, string fxSpawnName = "vfx_spawn_small", Func<Player, Vector3> customPos = null)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_007e: 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_00a0: 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)
			//IL_00a7: 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)
			GameObject prefab = ZNetScene.instance.GetPrefab(name);
			if ((Object)(object)prefab == (Object)null)
			{
				LoggerFactory.LogWithUI("Missing object " + name);
				return;
			}
			GameObject prefab2 = ZNetScene.instance.GetPrefab(fxSpawnName);
			if ((Object)(object)prefab2 == (Object)null)
			{
				((ILogger)LoggerFactory.Logger).Log((object)("Missing fx object " + fxSpawnName));
			}
			Player[] targetPlayers = GameProxy.TargetPlayers;
			foreach (Player val in targetPlayers)
			{
				Transform transform = ((Component)val).transform;
				for (int j = 0; j < count; j++)
				{
					try
					{
						Vector3 val2 = customPos?.Invoke(val) ?? CustomSpawner.GetPointAtHalfOfSphere(transform.position, transform.forward, 6.5f);
						GameObject val3 = SpawnSingleObject(prefab, val2 + Vector3.up);
						MathUtility.LookAt(val3.transform, ((Component)val).transform);
						CustomSpawner.ProcessLevel(val3, level);
						if ((Object)(object)prefab2 != (Object)null)
						{
							SpawnSingleObject(prefab2, val2);
						}
						ProcessDropItems(val3, enableDrop);
						CustomSpawner.ProcessHitPoints(val3, hitsPercent, InteractiveMod.Settings.hitpointsModifier);
						if (data != null && data.Username != null)
						{
							CustomSpawner.ProcessEnemyName(val3, data.Username, val);
						}
						CustomSpawner.ProcessEnemyDamage(val3, damage, InteractiveMod.Settings.spawnDamageModifier);
					}
					catch (Exception arg)
					{
						((ILogger)LoggerFactory.Logger).Log((object)$"SpawnObjects spawn {name} index {count} error: {arg}");
					}
				}
			}
		}

		public static void RPC_SpawnObjects(NetworkSpawnData data, string fxSpawnName = "vfx_spawn_small", Func<Player, Vector3> customPos = null)
		{
			//IL_0090: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00aa: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				((ILogger)LoggerFactory.Logger).Log((object)"RPC_SpawnObjects NetworkSpawnData is null");
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(data.argName);
			if ((Object)(object)prefab == (Object)null)
			{
				LoggerFactory.LogWithUI("Missing object " + data.argName);
				return;
			}
			GameObject prefab2 = ZNetScene.instance.GetPrefab(fxSpawnName);
			if ((Object)(object)prefab2 == (Object)null)
			{
				((ILogger)LoggerFactory.Logger).Log((object)("Missing fx object " + fxSpawnName));
			}
			Player currentPlayer = GameProxy.CurrentPlayer;
			Transform transform = ((Component)currentPlayer).transform;
			for (int i = 0; i < data.argCount; i++)
			{
				try
				{
					Vector3 val = customPos?.Invoke(currentPlayer) ?? CustomSpawner.GetPointAtHalfOfSphere(transform.position, transform.forward, 6.5f);
					GameObject val2 = SpawnSingleObject(prefab, val + Vector3.up);
					MathUtility.LookAt(val2.transform, ((Component)currentPlayer).transform);
					CustomSpawner.ProcessLevel(val2, data.argLevel);
					if ((Object)(object)prefab2 != (Object)null)
					{
						SpawnSingleObject(prefab2, val);
					}
					ProcessDropItems(val2, data.isSpawnsHaveDrop);
					CustomSpawner.ProcessHitPoints(val2, data.argHitsPercent, data.hitpointsModifier);
					if (data.username != null)
					{
						CustomSpawner.ProcessEnemyName(val2, data.username, currentPlayer);
					}
					CustomSpawner.ProcessEnemyDamage(val2, new DamageRanges
					{
						MaxElementalDamage = data.argMaxElementalDamage,
						MaxPhysicalDamage = data.argMaxPhysicalDamage,
						MinElementalDamage = data.argMinElementalDamage,
						MinPhysicalDamage = data.argMinPhysicalDamage
					}, data.spawnDamageModifier);
				}
				catch (Exception arg)
				{
					((ILogger)LoggerFactory.Logger).Log((object)$"SpawnObjects spawn {data.argName} index {data.argCount} error: {arg}");
				}
			}
		}
	}
	public class GiveItemInv : IConsoleCommand
	{
		public virtual string Id => "give_item_inv";

		public virtual bool Execute(IEnumerable<string> args)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			IEnumerator<string> args2 = args?.GetEnumerator();
			string text = CommandsArgsReader.ReadString(args2);
			int num = CommandsArgsReader.ReadInt(args2, 0);
			bool flag = CommandsArgsReader.ReadBool(args2, defaultValue: true);
			if (InteractiveMod.Settings.isAllPlayers)
			{
				ZPackage val = new ZPackage();
				val.Write(text);
				val.Write(num);
				val.Write(flag);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_GiveItemInInv", new object[1] { val });
			}
			else
			{
				GiveRandomItem(GameProxy.CurrentPlayer, text, num, flag);
			}
			return true;
		}

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

		public static void GiveRandomItem(Player player, string items, int count, bool inv)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00e7: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				LoggerFactory.LogWithUI("GiveRandomItem ObjectDB.instance is null");
			}
			string randomItemFromList = UtilityRandom.GetRandomItemFromList<string>((IList<string>)items.Split(new char[1] { '|' }));
			try
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(randomItemFromList);
				if ((Object)(object)itemPrefab == (Object)null)
				{
					LoggerFactory.LogWithUI("GiveRandomItem prefab " + randomItemFromList + " is null");
					return;
				}
				bool flag = inventory.CanAddItem(itemPrefab, count);
				if (!flag && inv)
				{
					ItemData randomItemFromList2 = UtilityRandom.GetRandomItemFromList<ItemData>((IList<ItemData>)inventory.GetAllItems().ToArray());
					((Humanoid)player).DropItem(inventory, randomItemFromList2, randomItemFromList2.m_stack);
					LoggerFactory.Logger.LogDebugInfo((object)$"drop {randomItemFromList2}");
					inventory.AddItem(itemPrefab, count);
				}
				else if (!flag && !inv)
				{
					Transform transform = ((Component)player).transform;
					Vector3 val = transform.position + transform.forward * 3f;
					CustomSpawner.SpawnSingleObject(itemPrefab, val + Vector3.up);
				}
				else
				{
					inventory.AddItem(itemPrefab, count);
				}
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"GiveItem {randomItemFromList} count {count} error: {arg}");
			}
		}
	}
	public class ItemsRain : IConsoleCommand
	{
		private int maxRange;

		private float rangePeriod;

		private int rangeSpawnHeight;

		private string[] itemsArr;

		public virtual string Id => "items_rain";

		public virtual bool Execute(IEnumerable<string> args)
		{
			IEnumerator<string> args2 = args?.GetEnumerator();
			int duration = CommandsArgsReader.ReadInt(args2, 60);
			maxRange = CommandsArgsReader.ReadInt(args2, 30);
			rangePeriod = CommandsArgsReader.ReadFloat(args2, 1f);
			string text = CommandsArgsReader.ReadString(args2);
			rangeSpawnHeight = 13;
			itemsArr = text.Split(new char[1] { '|' });
			StartRain(duration);
			return true;
		}

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

		protected void SpawnItem(string itemName, Vector3 pos)
		{
			//IL_000b: 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)
			Object.Instantiate<GameObject>(ZNetScene.instance.GetPrefab(itemName), pos, Quaternion.identity);
		}

		public static Vector3 GetPointOfSphere(Vector3 basePos, int height, float radius)
		{
			//IL_0000: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Random.onUnitSphere * radius;
			val.y = height;
			return basePos + val;
		}

		protected void SpawnRandomItem(int maxRange, int height)
		{
			//IL_0016: 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_0023: 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)
			try
			{
				string randomItemFromList = UtilityRandom.GetRandomItemFromList<string>((IList<string>)itemsArr);
				Vector3 pointOfSphere = GetPointOfSphere(((Component)GameProxy.CurrentPlayer).transform.position, height, maxRange);
				SpawnItem(randomItemFromList, pointOfSphere);
			}
			catch (Exception arg)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"Spawn items rain error: {arg}");
			}
		}

		protected void InitRangeTask(string id, int max, float period, int height)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0059: Expected O, but got Unknown
			if (!GameProxy.ScheduleManager.IsTaskExists(id))
			{
				GameProxy.ScheduleManager.NewPeriodicTask(new PeriodicTaskData
				{
					id = id,
					period = period,
					periodicAction = delegate
					{
						SpawnRandomItem(max, height);
					}
				}, false);
			}
		}

		public void StartRain(int duration)
		{
			//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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			((ILogger)LoggerFactory.Logger).Log((object)$"Start rain for {duration}");
			InitRangeTask(Id, maxRange, rangePeriod, rangeSpawnHeight);
			GameProxy.ScheduleManager.AppendTimerTask(new TimerTaskData
			{
				id = Id,
				duration = duration,
				finishAction = delegate
				{
					GameProxy.ScheduleManager.FinishImmediatlyPeriodicTask(Id);
					((ILogger)LoggerFactory.Logger).Log((object)"Rain is finished");
				}
			}, false);
		}
	}
	public class RaiseSkill : IConsoleCommand
	{
		private readonly string[] skillList = new string[20]
		{
			"Swords", "Knives", "Clubs", "Polearms", "Spears", "Blocking", "Axes", "Bows", "ElementalMagic", "BloodMagic",
			"Unarmed", "Pickaxes", "WoodCutting", "Crossbows", "Jump", "Sneak", "Run", "Swim", "Fishing", "Ride"
		};

		public static RaiseSkill sharedInstance;

		public virtual string Id => "player_addskill";

		public RaiseSkill()
		{
			sharedInstance = this;
		}

		public virtual bool Execute(IEnumerable<string> args)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			IEnumerator<string> args2 = args?.GetEnumerator();
			string text = CommandsArgsReader.ReadString(args2, "random");
			int num = CommandsArgsReader.ReadInt(args2, 1);
			if (InteractiveMod.Settings.isAllPlayers)
			{
				ZPackage val = new ZPackage();
				val.Write(text);
				val.Write(num);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_RaiseSkill", new object[1] { val });
			}
			else
			{
				SwitchFunc(text, num);
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CommandsValidator.IsValidString(args?.GetEnumerator(), (string name) => skillList.Contains(name));
		}

		public void SwitchFunc(string skillParam, int lvl)
		{
			if (!(skillParam == "random"))
			{
				if (skillParam == "all")
				{
					RaiseAllSkills(lvl);
				}
				else
				{
					RaiseCurrentSkill(skillParam, lvl);
				}
			}
			else
			{
				RaiseRandomSkill(lvl);
			}
		}

		public List<string> GetAvailableSkills()
		{
			List<Skill> list = ((Character)GameProxy.CurrentPlayer).GetSkills().GetSkillList();
			List<string> list2 = new List<string>();
			for (int i = 0; i < list.Count; i++)
			{
				string item = ((object)(SkillType)(ref list[i].m_info.m_skill)).ToString();
				list2.Add(item);
			}
			return list2;
		}

		public void RaiseAllSkills(int lvl)
		{
			List<string> availableSkills = GetAvailableSkills();
			if (availableSkills != null && availableSkills.Count > 0)
			{
				foreach (string item in availableSkills)
				{
					((ILogger)LoggerFactory.Logger).Log((object)("RaiseAllSkills skill " + item));
					((Character)GameProxy.CurrentPlayer).GetSkills().CheatRaiseSkill(item, (float)lvl, true);
				}
				return;
			}
			((ILogger)LoggerFactory.Logger).Log((object)"RaiseAllSkills skill list is empty raise Run");
			((Character)GameProxy.CurrentPlayer).GetSkills().CheatRaiseSkill("Run", (float)lvl, true);
		}

		public void RaiseRandomSkill(int lvl)
		{
			List<string> availableSkills = GetAvailableSkills();
			if (availableSkills != null && availableSkills.Count > 0)
			{
				string randomItemFromList = UtilityRandom.GetRandomItemFromList<string>((IList<string>)availableSkills);
				((ILogger)LoggerFactory.Logger).Log((object)("RaiseRandomSkill skill " + randomItemFromList));
				((Character)GameProxy.CurrentPlayer).GetSkills().CheatRaiseSkill(randomItemFromList, (float)lvl, true);
			}
			else
			{
				((ILogger)LoggerFactory.Logger).Log((object)"RaiseRandomSkill skill list is empty raise Run");
				((Character)GameProxy.CurrentPlayer).GetSkills().CheatRaiseSkill("Run", (float)lvl, true);
			}
		}

		public void RaiseCurrentSkill(string skill, int lvl)
		{
			((ILogger)LoggerFactory.Logger).Log((object)("Add 1 lvl to skill " + skill));
			((Character)GameProxy.CurrentPlayer).GetSkills().CheatRaiseSkill(skill, (float)lvl, true);
		}
	}
	public class Recall : IConsoleCommand
	{
		public static Recall sharedInstance;

		public virtual string Id => "player_recall";

		public Recall()
		{
			sharedInstance = this;
		}

		public virtual bool Execute(IEnumerable<string> args)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			if (!ZNet.instance.IsServer())
			{
				ZPackage val = new ZPackage();
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_Recall", new object[1] { val });
			}
			else
			{
				SendRecall();
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CommandsValidator.IsZeroArgs(args);
		}

		public void SendRecall()
		{
			GameProxy.RunGameConsoleCommand("recall");
		}
	}
	public class RemoveDrops : IConsoleCommand
	{
		public static RemoveDrops sharedInstance;

		public virtual string Id => "items_removedrops";

		public RemoveDrops()
		{
			sharedInstance = this;
		}

		public virtual bool Execute(IEnumerable<string> args)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			if (InteractiveMod.Settings.isAllPlayers)
			{
				ZPackage val = new ZPackage();
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_RemoveDrops", new object[1] { val });
			}
			else
			{
				RemoveAllDrops();
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CommandsValidator.IsZeroArgs(args);
		}

		public void RemoveAllDrops()
		{
			ItemDrop[] array = Object.FindObjectsOfType<ItemDrop>();
			foreach (ItemDrop val in array)
			{
				Fish component = ((Component)val).gameObject.GetComponent<Fish>();
				if ((Object)(object)component == (Object)null || component.IsOutOfWater())
				{
					ZNetView component2 = ((Component)val).GetComponent<ZNetView>();
					if ((Object)(object)component2 != (Object)null && component2.IsValid() && component2.IsOwner())
					{
						component2.Destroy();
					}
				}
			}
		}
	}
	public class SkipTime : IConsoleCommand
	{
		public static SkipTime sharedInstance;

		public virtual string Id => "player_skiptime";

		public SkipTime()
		{
			sharedInstance = this;
		}

		public virtual bool Execute(IEnumerable<string> args)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			if (!ZNet.instance.IsServer())
			{
				ZPackage val = new ZPackage();
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_SkipTime", new object[1] { val });
			}
			else
			{
				SkipHalfDay();
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CommandsValidator.IsZeroArgs(args);
		}

		public void SkipHalfDay()
		{
			double timeSeconds = ZNet.instance.GetTimeSeconds();
			float num = 1020f;
			timeSeconds += (double)num;
			ZNet.instance.SetNetTime(timeSeconds);
		}
	}
	public class TestDamageFxEffectSpawner : IConsoleCommand
	{
		public virtual string Id => "spawn_damage_fx";

		public virtual bool Execute(IEnumerable<string> args)
		{
			SpawnFX(CommandsArgsReader.ReadString(args?.GetEnumerator()));
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CommandsValidator.IsValidString(args?.GetEnumerator(), (string s) => (Object)(object)ZNetScene.instance != (Object)null && Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(s)));
		}

		public static void SpawnFX(string name)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			FxEffectSpawner.SpawnDamageFXAtCharacter((Character)(object)GameProxy.CurrentPlayer, name, new Vector3(0f, 1f, 0f));
		}
	}
	public class SingleFxEffectSpawner : IConsoleCommand
	{
		public virtual string Id => "spawn_single_fx";

		public virtual bool Execute(IEnumerable<string> args)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			string text = CommandsArgsReader.ReadString(args?.GetEnumerator());
			if (InteractiveMod.Settings.isAllPlayers)
			{
				ZPackage val = new ZPackage();
				val.Write(text);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_SingleFxEffectSpawner", new object[1] { val });
			}
			else
			{
				SpawnFX(GameProxy.CurrentPlayer, text);
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CommandsValidator.IsValidString(args?.GetEnumerator(), (string s) => (Object)(object)ZNetScene.instance != (Object)null && Object.op_Implicit((Object)(object)ZNetScene.instance.GetPrefab(s)));
		}

		public static void SpawnFX(Player p, string name)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			FxEffectSpawner.SpawnFXAtCharacter((Character)(object)p, name, new Vector3(0f, 1f, 0f));
		}
	}
	public class WaterEnemiesSpawner : IConsoleCommandWithData, IConsoleCommand
	{
		public virtual string Id => "spawn_in_water";

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

		public virtual bool Execute(IEnumerable<string> args, IEventsData data)
		{
			IEnumerator<string> enumerator = args?.GetEnumerator();
			string name = CommandsArgsReader.ReadString(enumerator);
			int count = CommandsArgsReader.ReadInt(enumerator, 1);
			int level = CommandsArgsReader.ReadInt(enumerator, 0);
			float hitsPercent = CommandsArgsReader.ReadFloat(enumerator, 1f);
			DamageRanges damageRanges = new DamageRanges();
			damageRanges.ReadFromArgs(enumerator);
			bool isSpawnsHaveDrop = InteractiveMod.Settings.isSpawnsHaveDrop;
			if (InteractiveMod.Settings.isAllPlayers)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "bft_CustomSpawnerWater", new object[1] { CustomSpawner.GenerateSpawnPackage(name, count, level, hitsPercent, isSpawnsHaveDrop, damageRanges, data) });
			}
			else
			{
				SpawnObjectsInWater(name, count, level, hitsPercent, damageRanges, isSpawnsHaveDrop, data);
			}
			return true;
		}

		public bool IsValidCommandArgs(IEnumerable<string> args)
		{
			return CustomSpawner.IsValidSpawnCommandArgs(args);
		}

		public static Vector3 GetPointAtWater(Vector3 basePos, Vector3 forward, int range)
		{
			//IL_0007: 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_00aa: 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_00b5: 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_001e: 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_0031: 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_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)
			List<Vector3> list = new List<Vector3>();
			for (int i = -range; i <= range; i += 2)
			{
				for (int j = -range; j <= range; j += 2)
				{
					Vector3 val = basePos + new Vector3((float)i, 0f, (float)j);
					if (ZoneSystem.instance.GetSolidHeight(val) < ZoneSystem.instance.m_waterLevel)
					{
						list.Add(val);
					}
				}
			}
			list.Sort((Vector3 x, Vector3 y) => (int)(Vector3.Distance(basePos, x) - Vector3.Distance(basePos, y)));
			if (list.Count > 0)
			{
				((ILogger)LoggerFactory.Logger).Log((object)$"found water {list.Count} cells");
				return UtilityRandom.GetRandomItemFromList<Vector3>((IList<Vector3>)list);
			}
			return CustomSpawner.GetPointAtHalfOfSphere(basePos, forward, 5f);
		}

		public static void SpawnObjectsInWater(string name, int count, int level, float hitsPercent, DamageRanges damage, bool enableDrop, IEventsData data, string fxSpawnName = "vfx_spawn_small")
		{
			//IL_0078: 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_0086: 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_008e: Unknown result type (might be due to