using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using HotReload;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using LeviathanAxe.Content;
using LeviathanAxe.Freeze;
using LeviathanAxe.Throwing;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("LeviathanAxe")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: AssemblyInformationalVersion("1.0.3")]
[assembly: AssemblyProduct("LeviathanAxe")]
[assembly: AssemblyTitle("LeviathanAxe")]
[assembly: AssemblyVersion("1.0.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HotReload
{
	public interface IModule
	{
		void Start(ModuleContext context);

		void Update();

		void Stop();
	}
	public sealed class ModuleContext
	{
		public ManualLogSource Log { get; }

		public ConfigFile Config { get; }

		public string PluginDirectory { get; }

		public int Generation { get; }

		public IDictionary<string, object> Carry { get; }

		internal ModuleContext(ManualLogSource log, ConfigFile config, string pluginDirectory, int generation, IDictionary<string, object> carry)
		{
			Log = log;
			Config = config;
			PluginDirectory = pluginDirectory;
			Generation = generation;
			Carry = carry;
		}
	}
	internal sealed class ModuleHost
	{
		private const float PollSeconds = 1f;

		private readonly string _harmonyPrefix;

		private readonly ManualLogSource _log;

		private readonly ConfigFile _config;

		private readonly string _pluginDirectory;

		private readonly Dictionary<string, object> _carry = new Dictionary<string, object>();

		private IModule _module;

		private Harmony _harmony;

		private string _name;

		private int _generation;

		private bool _updateFailed;

		internal static ModuleHost Current { get; private set; }

		internal Action Stopped { get; set; }

		internal int Generation => _generation;

		internal ModuleHost(string pluginGuid, string moduleFile, ManualLogSource log, ConfigFile config, string pluginDirectory)
		{
			_harmonyPrefix = pluginGuid + ".module.";
			_log = log;
			_config = config;
			_pluginDirectory = pluginDirectory;
			Current = this;
		}

		internal static void PatchClasses(Harmony harmony, Assembly assembly, ManualLogSource log)
		{
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(assembly);
			foreach (Type type in typesFromAssembly)
			{
				try
				{
					if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0)
					{
						harmony.CreateClassProcessor(type).Patch();
					}
				}
				catch (Exception arg)
				{
					log.LogError((object)$"patch {type.FullName}: {arg}");
				}
			}
		}

		internal bool Attach(IModule module, out string message)
		{
			Stopwatch stopwatch = Stopwatch.StartNew();
			Assembly assembly = module.GetType().Assembly;
			if (!TryStart(module, assembly, ++_generation, assembly.GetName().Name, out message))
			{
				_log.LogWarning((object)message);
				return false;
			}
			message = $"module {_name} started in {stopwatch.ElapsedMilliseconds} ms";
			_log.LogInfo((object)message);
			return true;
		}

		internal string Stop()
		{
			if (_module == null)
			{
				return "module: nothing to stop";
			}
			string name = _name;
			StopCurrent();
			return "module " + name + " stopped";
		}

		internal void Update()
		{
			if (_module == null)
			{
				return;
			}
			try
			{
				_module.Update();
			}
			catch (Exception arg)
			{
				if (!_updateFailed)
				{
					_updateFailed = true;
					_log.LogError((object)$"module {_name}: Update: {arg}");
				}
			}
		}

		private bool TryStart(IModule module, Assembly assembly, int generation, string name, out string message)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			Harmony val = new Harmony(_harmonyPrefix + generation);
			try
			{
				PatchClasses(val, assembly, _log);
				module.Start(new ModuleContext(_log, _config, _pluginDirectory, generation, _carry));
			}
			catch (Exception ex)
			{
				_log.LogError((object)$"module {name}: cannot start: {ex}");
				try
				{
					module.Stop();
				}
				catch (Exception arg)
				{
					_log.LogError((object)$"module {name}: stop after failure: {arg}");
				}
				val.UnpatchSelf();
				message = "module " + name + " failed to load: " + ex.GetType().Name + ": " + ex.Message;
				return false;
			}
			_module = module;
			_harmony = val;
			_name = name;
			_updateFailed = false;
			message = "module " + name + " loaded";
			return true;
		}

		private void StopCurrent()
		{
			if (_module == null)
			{
				return;
			}
			try
			{
				_module.Stop();
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"module {_name}: stop: {arg}");
			}
			_harmony.UnpatchSelf();
			_module = null;
			_harmony = null;
			try
			{
				Stopped?.Invoke();
			}
			catch (Exception arg2)
			{
				_log.LogError((object)$"module {_name}: after stop: {arg2}");
			}
		}

		private int GhostPatches()
		{
			int num = 0;
			foreach (MethodBase allPatchedMethod in Harmony.GetAllPatchedMethods())
			{
				foreach (string owner in Harmony.GetPatchInfo(allPatchedMethod).Owners)
				{
					if (owner.StartsWith(_harmonyPrefix, StringComparison.Ordinal) && (_harmony == null || owner != _harmony.Id))
					{
						num++;
					}
				}
			}
			return num;
		}
	}
	public static class ModuleBridge
	{
		public static void Attach(IModule module)
		{
			if (ModuleHost.Current == null)
			{
				throw new InvalidOperationException("the base plugin of this module is not loaded");
			}
			ModuleHost.Current.Attach(module, out var _);
		}
	}
	public static class ModuleWorld
	{
		private static readonly FieldRef<ZNetScene, Dictionary<int, GameObject>> NamedPrefabs = AccessTools.FieldRefAccess<ZNetScene, Dictionary<int, GameObject>>("m_namedPrefabs");

		private static readonly FieldRef<ZNetScene, Dictionary<ZDO, ZNetView>> Instances = AccessTools.FieldRefAccess<ZNetScene, Dictionary<ZDO, ZNetView>>("m_instances");

		private static readonly FieldInfo Commands = AccessTools.Field(typeof(Terminal), "commands");

		public static void RegisterPrefab(ZNetScene scene, GameObject template)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)template).name);
			Dictionary<int, GameObject> obj = NamedPrefabs.Invoke(scene);
			if (obj.TryGetValue(stableHashCode, out var value) && (Object)(object)value != (Object)null && (Object)(object)value != (Object)(object)template)
			{
				scene.m_prefabs.Remove(value);
				DestroyTemplate(value);
			}
			if (!scene.m_prefabs.Contains(template))
			{
				scene.m_prefabs.Add(template);
			}
			obj[stableHashCode] = template;
		}

		public static void Release(ZNetView view)
		{
			if ((Object)(object)view == (Object)null)
			{
				return;
			}
			ZDO zDO = view.GetZDO();
			if (zDO != null)
			{
				view.ResetZDO();
				if (Object.op_Implicit((Object)(object)ZNetScene.instance))
				{
					Instances.Invoke(ZNetScene.instance).Remove(zDO);
				}
			}
			Object.Destroy((Object)(object)((Component)view).gameObject);
		}

		public static int ReleaseOthers(int prefabHash, Type component)
		{
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return 0;
			}
			List<ZNetView> list = new List<ZNetView>();
			foreach (ZNetView value in Instances.Invoke(ZNetScene.instance).Values)
			{
				if ((Object)(object)value != (Object)null && value.GetZDO() != null && value.GetZDO().GetPrefab() == prefabHash && (Object)(object)((Component)value).GetComponent(component) == (Object)null)
				{
					list.Add(value);
				}
			}
			foreach (ZNetView item in list)
			{
				Release(item);
			}
			return list.Count;
		}

		public static void RemoveCommand(string name)
		{
			(Commands.GetValue(null) as Dictionary<string, ConsoleCommand>)?.Remove(name.ToLowerInvariant());
		}

		private static void DestroyTemplate(GameObject template)
		{
			Transform parent = template.transform.parent;
			Object.Destroy((Object)(object)template);
			if ((Object)(object)parent != (Object)null && parent.childCount == 1)
			{
				Object.Destroy((Object)(object)((Component)parent).gameObject);
			}
		}
	}
}
namespace LeviathanAxe
{
	[BepInPlugin("grogui.LeviathanAxe", "LeviathanAxe", "1.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal sealed class LeviathanAxePlugin : BaseUnityPlugin
	{
		internal const string PluginGuid = "grogui.LeviathanAxe";

		internal const string PluginName = "LeviathanAxe";

		internal const string PluginVersion = "1.0.3";

		private const string ModuleFile = "LeviathanAxe.Module.dll";

		private ModuleHost _module;

		private void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			Settings.Bind(((BaseUnityPlugin)this).Config);
			PrefabManager.OnVanillaPrefabsAvailable += OnVanillaPrefabsAvailable;
			Log.Info("LeviathanAxe 1.0.3 loaded.");
			_module = new ModuleHost("grogui.LeviathanAxe", "LeviathanAxe.Module.dll", ((BaseUnityPlugin)this).Logger, ((BaseUnityPlugin)this).Config, Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location));
		}

		private void OnVanillaPrefabsAvailable()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= OnVanillaPrefabsAvailable;
			ContentFactory.Create();
		}

		private void Update()
		{
			_module?.Update();
		}

		private void OnDestroy()
		{
			_module?.Stop();
			PrefabManager.OnVanillaPrefabsAvailable -= OnVanillaPrefabsAvailable;
			ContentFactory.Unbind();
		}
	}
	internal static class Log
	{
		private static ManualLogSource _source;

		private static readonly HashSet<string> Reported = new HashSet<string>();

		internal static void Init(ManualLogSource source)
		{
			_source = source;
		}

		internal static void Info(string message)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogInfo((object)message);
			}
		}

		internal static void Warning(string message)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogWarning((object)message);
			}
		}

		internal static void WarnOnce(string key, string message)
		{
			if (Reported.Add("w:" + key))
			{
				ManualLogSource source = _source;
				if (source != null)
				{
					source.LogWarning((object)message);
				}
			}
		}

		internal static void Error(string message)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogError((object)message);
			}
		}

		internal static void ErrorOnce(string key, Exception error)
		{
			if (Reported.Add("e:" + key))
			{
				ManualLogSource source = _source;
				if (source != null)
				{
					source.LogError((object)$"[{key}] {error}");
				}
			}
		}
	}
	public static class Settings
	{
		public static ConfigEntry<float> ThrowSpeed;

		public static ConfigEntry<float> ThrowDamageMultiplier;

		public static ConfigEntry<float> MaxFlightDistance;

		public static ConfigEntry<float> ChargedThrowDamageMultiplier;

		public static ConfigEntry<float> ReturnSpeed;

		public static ConfigEntry<float> CurveAmount;

		public static ConfigEntry<float> ReturnDamageMultiplier;

		public static ConfigEntry<float> FreezeDuration;

		public static ConfigEntry<int> FreezeThreshold;

		public static ConfigEntry<bool> FreezeBosses;

		public static ConfigEntry<bool> RecallWithHideKey;

		public static ConfigEntry<bool> RecallWithSecondaryAttack;

		public static ConfigEntry<KeyboardShortcut> RecallKey;

		public static ConfigEntry<bool> AutoEquipOnCatch;

		public static ConfigEntry<bool> GlowPulse;

		internal static void Bind(ConfigFile config)
		{
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			ThrowSpeed = config.Bind<float>("1. Throw", "ThrowSpeed", 40f, ServerRule("Speed of the thrown axe, in meters per second.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 100f)));
			ThrowDamageMultiplier = config.Bind<float>("1. Throw", "ThrowDamageMultiplier", 1f, ServerRule("Damage of a horizontal throw, relative to the axe's damage.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f)));
			ChargedThrowDamageMultiplier = config.Bind<float>("1. Throw", "ChargedThrowDamageMultiplier", 2f, ServerRule("Damage of a vertical throw, relative to a horizontal one. The secondary attack still held when the arm has pulled back throws the axe vertically: it sticks in creatures. Released sooner, it throws it horizontally: it bounces off creatures.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5f)));
			MaxFlightDistance = config.Bind<float>("1. Throw", "MaxFlightDistance", 45f, ServerRule("Beyond this distance without hitting anything, the axe drops to the ground.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 200f)));
			ReturnSpeed = config.Bind<float>("2. Recall", "ReturnSpeed", 35f, ServerRule("Speed of the axe coming back, in meters per second: from d meters away, the trip lasts (2.5 + d) / speed seconds, 1.5 seconds at most.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 100f)));
			CurveAmount = config.Bind<float>("2. Recall", "CurveAmount", 1f, ServerRule("How far the returning axe swings out to the right: 1 is the usual curve, wider the farther it comes from; 0 brings it back almost straight.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f)));
			ReturnDamageMultiplier = config.Bind<float>("2. Recall", "ReturnDamageMultiplier", 0.5f, ServerRule("Damage dealt to enemies crossed by the returning axe, relative to a throw. 0 disables it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f)));
			FreezeDuration = config.Bind<float>("3. Freeze", "FreezeDuration", 4f, ServerRule("Seconds a creature stays frozen. 0 disables freezing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f)));
			FreezeThreshold = config.Bind<int>("3. Freeze", "FreezeThreshold", 3, ServerRule("Frost that freezes a creature: a horizontal throw adds 1, a vertical one 2, and the hit that reaches this value freezes it. The frost fades when the creature has not been hit for 6 seconds. 1 freezes on every hit.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10)));
			FreezeBosses = config.Bind<bool>("3. Freeze", "FreezeBosses", false, ServerRule("Also freeze bosses."));
			RecallWithHideKey = config.Bind<bool>("4. Controls", "RecallWithHideKey", true, "The game's Hide key (R by default), which normally draws or sheathes weapons, recalls the thrown axe instead.");
			RecallWithSecondaryAttack = config.Bind<bool>("4. Controls", "RecallWithSecondaryAttack", true, "The secondary attack, with an empty right hand, recalls the thrown axe.");
			RecallKey = config.Bind<KeyboardShortcut>("4. Controls", "RecallKey", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "An extra key that recalls the thrown axe. Empty by default.");
			AutoEquipOnCatch = config.Bind<bool>("4. Controls", "AutoEquipOnCatch", true, "The caught axe goes back in hand when the right hand is free. Recalling with the Hide key or the axe's hotbar slot always does.");
			GlowPulse = config.Bind<bool>("5. Look", "GlowPulse", true, "The runes on the blade glow, slowly breathing, and cast a blue light on the one holding the axe. Only changes what you see.");
		}

		private static ConfigDescription ServerRule(string description, AcceptableValueBase range = null)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			return new ConfigDescription(description, range, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} });
		}
	}
}
namespace LeviathanAxe.Throwing
{
	public interface IThrowHandler
	{
		void Launch(ThrownAxeRelay relay, Character owner, Vector3 velocity, float hitNoise, HitData hitData, ItemData item);
	}
	public sealed class ThrownAxeRelay : MonoBehaviour, IProjectile
	{
		public Transform m_pivot;

		public Vector3 m_center;

		public Vector3 m_edge;

		public Transform m_model;

		public MeleeWeaponTrail m_trail;

		public ParticleSystem m_sparks;

		public Light m_light;

		public static IThrowHandler Handler { get; set; }

		public string GetTooltipString(int itemQuality)
		{
			return "";
		}

		public void Setup(Character owner, Vector3 velocity, float hitNoise, HitData hitData, ItemData item, ItemData ammo)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (Handler == null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			try
			{
				Handler.Launch(this, owner, velocity, hitNoise, hitData, item);
			}
			catch (Exception error)
			{
				Log.ErrorOnce("ThrownAxeRelay.Setup", error);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
}
namespace LeviathanAxe.Freeze
{
	public interface IFreeze
	{
		bool CanFreeze(Character character);

		void Begin(Character character, float duration);

		void Hold(Character character);

		void End(Character character);

		void Forget(Character character);
	}
	public sealed class FrozenEffect : StatusEffect
	{
		public const string EffectName = "LeviathanAxe_Frozen";

		public static readonly int Hash = StringExtensionMethods.GetStableHashCode("LeviathanAxe_Frozen");

		private static FrozenEffect _prototype;

		public static IFreeze Logic { get; set; }

		internal static void Register()
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_008e: 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)
			FrozenEffect frozenEffect = ScriptableObject.CreateInstance<FrozenEffect>();
			((Object)frozenEffect).name = "LeviathanAxe_Frozen";
			((StatusEffect)frozenEffect).m_name = "$leviathanaxe_frozen";
			((StatusEffect)frozenEffect).m_category = "";
			((StatusEffect)frozenEffect).m_tooltip = "";
			((StatusEffect)frozenEffect).m_startMessage = "";
			((StatusEffect)frozenEffect).m_stopMessage = "";
			((StatusEffect)frozenEffect).m_repeatMessage = "";
			((StatusEffect)frozenEffect).m_ttl = Settings.FreezeDuration.Value;
			StatusEffect prefab = Cache.GetPrefab<StatusEffect>("Frost");
			if ((Object)(object)prefab != (Object)null)
			{
				((StatusEffect)frozenEffect).m_icon = prefab.m_icon;
				((StatusEffect)frozenEffect).m_startEffects = (EffectList)(((object)prefab.m_startEffects) ?? ((object)new EffectList()));
				((StatusEffect)frozenEffect).m_stopEffects = (EffectList)(((object)prefab.m_stopEffects) ?? ((object)new EffectList()));
			}
			else
			{
				Log.Warning("Status effect \"Frost\" not found: frozen creatures get no frost particles.");
			}
			_prototype = frozenEffect;
			ItemManager.Instance.AddStatusEffect(new CustomStatusEffect((StatusEffect)(object)frozenEffect, false));
		}

		internal static void ApplyDuration()
		{
			if ((Object)(object)_prototype != (Object)null)
			{
				((StatusEffect)_prototype).m_ttl = Settings.FreezeDuration.Value;
			}
		}

		public override bool CanAdd(Character character)
		{
			if (Logic != null)
			{
				return Logic.CanFreeze(character);
			}
			return false;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			Logic?.Begin(character, base.m_ttl);
		}

		public override void ResetTime()
		{
			((StatusEffect)this).ResetTime();
			if ((Object)(object)base.m_character != (Object)null)
			{
				Logic?.Begin(base.m_character, base.m_ttl);
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			Logic?.Hold(base.m_character);
		}

		public override void Stop()
		{
			((StatusEffect)this).Stop();
			Logic?.End(base.m_character);
		}

		public override void OnDestroy()
		{
			((StatusEffect)this).OnDestroy();
			Logic?.Forget(base.m_character);
		}

		public override void ModifySpeed(float baseSpeed, ref float speed, Character character, Vector3 dir)
		{
			speed = 0f;
		}
	}
}
namespace LeviathanAxe.Content
{
	public static class ContentFactory
	{
		private static bool _bound;

		public static bool Ready { get; private set; }

		public static event Action Created;

		internal static void Create()
		{
			try
			{
				FrozenEffect.Register();
				GameObject val = LeviathanItem.Create();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				GameObject thrownPrefab = ThrownAxePrefab.Create(val);
				LeviathanItem.Register(val, thrownPrefab);
				LeviathanItem.CreateRecipe(val);
				Settings.FreezeDuration.SettingChanged += OnFreezeDurationChanged;
				_bound = true;
				Log.Info("Leviathan created.");
			}
			catch (Exception arg)
			{
				Log.Error($"The Leviathan could not be created: {arg}");
				return;
			}
			Ready = true;
			try
			{
				ContentFactory.Created?.Invoke();
			}
			catch (Exception arg2)
			{
				Log.Error($"The module could not settle on the Leviathan: {arg2}");
			}
		}

		internal static void Unbind()
		{
			if (_bound)
			{
				Settings.FreezeDuration.SettingChanged -= OnFreezeDurationChanged;
				_bound = false;
			}
		}

		private static void OnFreezeDurationChanged(object sender, EventArgs args)
		{
			FrozenEffect.ApplyDuration();
		}
	}
	internal static class IconRenderer
	{
		private const int Size = 128;

		private static readonly Quaternion Rotation;

		internal static Sprite Render(GameObject itemPrefab, int size = 128)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0046: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			Transform val = itemPrefab.transform.Find("attach");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val2 = new GameObject("LeviathanAxeIcon");
			bool fog = RenderSettings.fog;
			try
			{
				GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, val2.transform, false);
				val3.transform.localPosition = Vector3.zero;
				val3.transform.localRotation = Quaternion.identity;
				val3.SetActive(true);
				ParticleSystem[] componentsInChildren = val3.GetComponentsInChildren<ParticleSystem>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.SetActive(false);
				}
				Light[] componentsInChildren2 = val3.GetComponentsInChildren<Light>(true);
				for (int i = 0; i < componentsInChildren2.Length; i++)
				{
					((Behaviour)componentsInChildren2[i]).enabled = false;
				}
				RenderSettings.fog = false;
				return RenderManager.Instance.Render(new RenderRequest(val2)
				{
					Rotation = Rotation,
					Width = size,
					Height = size,
					UseCache = false
				});
			}
			catch (Exception arg)
			{
				Log.Warning(string.Format("Icon of \"{0}\" could not be rendered: {1}", "LeviathanAxe", arg));
				return null;
			}
			finally
			{
				RenderSettings.fog = fog;
				Object.DestroyImmediate((Object)(object)val2);
			}
		}

		static IconRenderer()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = new Vector3(-1f, 1f, 0f);
			Rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.forward);
		}
	}
	public static class LeviathanItem
	{
		internal const string PrefabName = "LeviathanAxe";

		internal const string AttachChild = "attach";

		internal const string TrailPath = "equiped/trail";

		internal const string EdgeChild = "edge";

		public const string ModelChild = "Model";

		private const string UpgradeGlowChild = "UpgraderGlow";

		public const string HeadChild = "head";

		private static readonly Color RuneEmission = Color.black;

		private const string EmissionKeyword = "_EMISSION";

		private static readonly int MainTex = Shader.PropertyToID("_MainTex");

		private static readonly int EmissionMap = Shader.PropertyToID("_EmissionMap");

		private static readonly int EmissionColor = Shader.PropertyToID("_EmissionColor");

		private static readonly int MetallicGlossMap = Shader.PropertyToID("_MetallicGlossMap");

		private static readonly int BumpMap = Shader.PropertyToID("_BumpMap");

		public static GameObject Prefab { get; private set; }

		public static bool Is(ItemData item)
		{
			if (item?.m_shared != null)
			{
				return item.m_shared.m_name == "$leviathanaxe_name";
			}
			return false;
		}

		internal static GameObject Create()
		{
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("LeviathanAxe", "AxeGold");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Vanilla prefab \"AxeGold\" not found: the Leviathan was not created.");
				return null;
			}
			ApplyStats(val.GetComponent<ItemDrop>().m_itemData);
			ApplyLook(val);
			Prefab = val;
			return val;
		}

		internal static void Register(GameObject prefab, GameObject thrownPrefab)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			SharedData shared = prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
			Attack val = ThrowAttack(thrownPrefab);
			if (val != null)
			{
				shared.m_secondaryAttack = val;
			}
			if (!GUIManager.IsHeadless())
			{
				Sprite val2 = IconRenderer.Render(prefab);
				if ((Object)(object)val2 != (Object)null)
				{
					shared.m_icons = (Sprite[])(object)new Sprite[1] { val2 };
				}
				else
				{
					Log.Warning("Icon of \"LeviathanAxe\" not rendered: it keeps the one of \"AxeGold\".");
				}
			}
			ItemManager.Instance.AddItem(new CustomItem(prefab, false));
		}

		private static void ApplyStats(ItemData item)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			SharedData shared = item.m_shared;
			shared.m_name = "$leviathanaxe_name";
			shared.m_description = "$leviathanaxe_desc";
			shared.m_damages = new DamageTypes
			{
				m_slash = 70f,
				m_chop = 55f,
				m_frost = 35f
			};
			shared.m_damagesPerLevel = new DamageTypes
			{
				m_slash = 6f,
				m_chop = 3f,
				m_frost = 4f
			};
			shared.m_toolTier = 3;
			shared.m_maxQuality = 4;
			shared.m_maxDurability = 200f;
			shared.m_durabilityPerLevel = 50f;
			item.m_durability = shared.m_maxDurability;
			shared.m_blockPower = 30f;
			shared.m_attackForce = 50f;
			shared.m_value = 0;
			shared.m_attack.m_attackStamina = 12f;
		}

		private static void ApplyLook(GameObject prefab)
		{
			//IL_00d9: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			Transform val = prefab.transform.Find("attach");
			Transform val2 = (((Object)(object)val == (Object)null) ? null : val.Find("Model"));
			MeshFilter val3 = (((Object)(object)val2 == (Object)null) ? null : ((Component)val2).GetComponent<MeshFilter>());
			Renderer val4 = (((Object)(object)val2 == (Object)null) ? null : ((Component)val2).GetComponent<Renderer>());
			GameObject prefab2 = PrefabManager.Instance.GetPrefab("AxeGold_FrostFire");
			Transform val5 = (((Object)(object)prefab2 == (Object)null) ? null : prefab2.transform.Find("attach/Model"));
			Renderer val6 = (((Object)(object)val5 == (Object)null) ? null : ((Component)val5).GetComponent<Renderer>());
			if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null || (Object)(object)val6 == (Object)null || (Object)(object)val6.sharedMaterial == (Object)null)
			{
				Log.Warning("Model of \"AxeGold\" or \"AxeGold_FrostFire\" not found: the Leviathan keeps the gold axe's look.");
				return;
			}
			LeviathanModel leviathanModel = LeviathanModel.Load();
			if (leviathanModel != null)
			{
				val2.localPosition = Vector3.zero;
				val2.localRotation = Quaternion.identity;
				val2.localScale = Vector3.one;
				val3.sharedMesh = leviathanModel.Mesh;
				MeshCollider component = ((Component)val2).GetComponent<MeshCollider>();
				if ((Object)(object)component != (Object)null)
				{
					component.convex = true;
					component.sharedMesh = leviathanModel.Mesh;
				}
				Material val7 = new Material(val6.sharedMaterial)
				{
					name = "leviathanaxe_mat"
				};
				val7.SetTexture(MainTex, (Texture)(object)leviathanModel.Albedo);
				val7.SetTexture(EmissionMap, (Texture)(object)leviathanModel.Emission);
				val7.SetColor(EmissionColor, RuneEmission);
				val7.EnableKeyword("_EMISSION");
				val7.SetTexture(MetallicGlossMap, (Texture)(object)leviathanModel.MetalGloss);
				val7.SetTexture(BumpMap, (Texture)(object)leviathanModel.FlatNormal);
				val4.sharedMaterial = val7;
				Transform val8 = val.Find("equiped/trail");
				Transform val9 = (((Object)(object)val8 == (Object)null) ? null : val8.Find("base"));
				Transform val10 = (((Object)(object)val8 == (Object)null) ? null : val8.Find("tip"));
				if ((Object)(object)val9 != (Object)null && (Object)(object)val10 != (Object)null)
				{
					val9.localPosition = leviathanModel.EdgeBase;
					val10.localPosition = leviathanModel.EdgeTip;
				}
				else
				{
					Log.Warning("Trail of \"AxeGold\" not found: the Leviathan swings without one.");
				}
				FitUpgradeGlow(val, leviathanModel);
				Transform transform = new GameObject("edge").transform;
				transform.SetParent(val, false);
				transform.localPosition = leviathanModel.EdgeFront;
				Transform transform2 = new GameObject("head").transform;
				transform2.SetParent(val, false);
				transform2.localPosition = leviathanModel.HeadCenter;
			}
		}

		private static void FitUpgradeGlow(Transform attach, LeviathanModel look)
		{
			//IL_0027: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			Transform val = attach.Find("UpgraderGlow");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			ParticleSystem[] componentsInChildren = ((Component)val).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val2 in componentsInChildren)
			{
				ShapeModule shape = val2.shape;
				if ((int)((ShapeModule)(ref shape)).shapeType == 6)
				{
					((ShapeModule)(ref shape)).mesh = look.Mesh;
					((Component)val2).transform.localPosition = Vector3.zero;
					((Component)val2).transform.localRotation = Quaternion.identity;
					((Component)val2).transform.localScale = Vector3.one;
				}
			}
			Light[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<Light>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				((Component)componentsInChildren2[i]).transform.localPosition = new Vector3(look.EdgeFront.x * 0.5f, 0f, look.EdgeFront.z);
			}
		}

		private static Attack ThrowAttack(GameObject thrownPrefab)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			GameObject prefab = PrefabManager.Instance.GetPrefab("SpearBronze");
			Attack val = (((Object)(object)prefab == (Object)null) ? null : prefab.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_secondaryAttack);
			if (val == null || (int)val.m_attackType != 2 || (Object)(object)thrownPrefab == (Object)null)
			{
				Log.Error("Throw of \"SpearBronze\" not found: the Leviathan cannot be thrown.");
				return null;
			}
			Attack obj = val.Clone();
			obj.m_attackProjectile = thrownPrefab;
			obj.m_consumeItem = false;
			obj.m_attackStamina = 14f;
			obj.m_damageMultiplier = 1f;
			obj.m_projectileVel = 40f;
			obj.m_projectileVelMin = 40f;
			obj.m_randomVelocity = false;
			obj.m_projectileAccuracy = 0f;
			obj.m_projectileAccuracyMin = 0f;
			obj.m_skillAccuracy = false;
			obj.m_requiresReload = false;
			obj.m_bowDraw = false;
			obj.m_destroyPreviousProjectile = false;
			obj.m_projectiles = 1;
			obj.m_projectileBursts = 1;
			return obj;
		}

		internal static void CreateRecipe(GameObject prefab)
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			GameObject prefab2 = PrefabManager.Instance.GetPrefab("forge");
			CraftingStation val = ((prefab2 != null) ? prefab2.GetComponent<CraftingStation>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Crafting station \"forge\" not found: the Leviathan cannot be crafted.");
				return;
			}
			List<Requirement> list = new List<Requirement>();
			if (!(AddRequirement(list, "Silver", 20, 10, recover: true, upgrader: false) & AddRequirement(list, "Iron", 10, 5, recover: true, upgrader: false) & AddRequirement(list, "FreezeGland", 8, 2, recover: true, upgrader: false) & AddRequirement(list, "ElderBark", 5, 0, recover: true, upgrader: false)))
			{
				Log.Error("An ingredient of the Leviathan was not found: it cannot be crafted.");
				return;
			}
			if (!AddRequirement(list, "Upgrader3Weapon", 1, 0, recover: false, upgrader: true))
			{
				Log.Warning("\"Upgrader3Weapon\" not found: the Leviathan cannot be upgraded at an upgrade station.");
			}
			Recipe val2 = ScriptableObject.CreateInstance<Recipe>();
			((Object)val2).name = "Recipe_LeviathanAxe";
			val2.m_item = prefab.GetComponent<ItemDrop>();
			val2.m_amount = 1;
			val2.m_enabled = true;
			val2.m_qualityResultAmountMultiplier = 1f;
			val2.m_listSortWeight = 100;
			val2.m_noCraftOnlyUpgrade = false;
			val2.m_craftingStation = val;
			val2.m_repairStation = null;
			val2.m_minStationLevel = 3;
			val2.m_requireOnlyOneIngredient = false;
			val2.m_resources = list.ToArray();
			if (!ItemManager.Instance.AddRecipe(new CustomRecipe(val2, false, false)))
			{
				Log.Error("Recipe of the Leviathan refused by Jotunn: it cannot be crafted.");
			}
		}

		private static bool AddRequirement(List<Requirement> requirements, string itemName, int amount, int perLevel, bool recover, bool upgrader)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0053: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			GameObject prefab = PrefabManager.Instance.GetPrefab(itemName);
			ItemDrop val = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Log.Warning("Ingredient \"" + itemName + "\" not found.");
				return false;
			}
			requirements.Add(new Requirement
			{
				m_resItem = val,
				m_amount = amount,
				m_extraAmountOnlyOneIngredient = 0,
				m_amountPerLevel = perLevel,
				m_upgraderResource = upgrader,
				m_recover = recover
			});
			return true;
		}
	}
	internal sealed class LeviathanModel
	{
		[Serializable]
		private sealed class MeshData
		{
			[SerializeField]
			internal float[] positions;

			[SerializeField]
			internal float[] normals;

			[SerializeField]
			internal float[] uvs;

			[SerializeField]
			internal int[] triangles;

			[SerializeField]
			internal float[] edgeBase;

			[SerializeField]
			internal float[] edgeTip;

			[SerializeField]
			internal float[] edgeFront;
		}

		private const string MeshResource = "leviathan_mesh.json";

		private const string AlbedoResource = "leviathan_albedo.png";

		private const string EmissionResource = "leviathan_emission.png";

		private const string MetalGlossResource = "leviathan_metalgloss.png";

		private static readonly MethodInfo LoadImage = typeof(ImageConversion).GetMethod("LoadImage", new Type[3]
		{
			typeof(Texture2D),
			typeof(byte[]),
			typeof(bool)
		});

		internal Mesh Mesh { get; private set; }

		internal Texture2D Albedo { get; private set; }

		internal Texture2D Emission { get; private set; }

		internal Texture2D MetalGloss { get; private set; }

		internal Texture2D FlatNormal { get; private set; }

		internal Vector3 EdgeBase { get; private set; }

		internal Vector3 EdgeTip { get; private set; }

		internal Vector3 EdgeFront { get; private set; }

		internal Vector3 HeadCenter { get; private set; }

		internal static LeviathanModel Load()
		{
			//IL_0091: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MeshData data;
				Mesh val = LoadMesh(out data);
				Texture2D val2 = LoadTexture("leviathan_albedo.png", linear: false, (FilterMode)0);
				Texture2D val3 = LoadTexture("leviathan_emission.png", linear: false, (FilterMode)0);
				Texture2D val4 = LoadTexture("leviathan_metalgloss.png", linear: false, (FilterMode)1);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					return null;
				}
				return new LeviathanModel
				{
					Mesh = val,
					Albedo = val2,
					Emission = val3,
					MetalGloss = val4,
					FlatNormal = FlatNormalMap(),
					EdgeBase = ToVector(data.edgeBase),
					EdgeTip = ToVector(data.edgeTip),
					EdgeFront = ToVector(data.edgeFront),
					HeadCenter = HeadCenterOf(val.vertices, data.edgeBase[2])
				};
			}
			catch (Exception arg)
			{
				Log.Error($"The Leviathan model could not be loaded: {arg}");
				return null;
			}
		}

		private static Mesh LoadMesh(out MeshData data)
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			data = null;
			byte[] array = ReadResource("leviathan_mesh.json");
			if (array == null)
			{
				return null;
			}
			data = JsonUtility.FromJson<MeshData>(Encoding.UTF8.GetString(array));
			int num = data.positions.Length / 3;
			if (data.positions.Length != num * 3 || data.normals.Length != num * 3 || data.uvs.Length != num * 2 || data.triangles.Length % 3 != 0 || data.edgeBase.Length != 3 || data.edgeTip.Length != 3 || data.edgeFront.Length != 3)
			{
				Log.Error("\"leviathan_mesh.json\" is malformed: the Leviathan keeps the gold axe's model.");
				return null;
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[num];
			Vector3[] array3 = (Vector3[])(object)new Vector3[num];
			Vector2[] array4 = (Vector2[])(object)new Vector2[num];
			for (int i = 0; i < num; i++)
			{
				array2[i] = new Vector3(data.positions[3 * i], data.positions[3 * i + 1], data.positions[3 * i + 2]);
				array3[i] = new Vector3(data.normals[3 * i], data.normals[3 * i + 1], data.normals[3 * i + 2]);
				array4[i] = new Vector2(data.uvs[2 * i], data.uvs[2 * i + 1]);
			}
			int[] triangles = data.triangles;
			foreach (int num2 in triangles)
			{
				if (num2 < 0 || num2 >= num)
				{
					Log.Error("\"leviathan_mesh.json\" has a triangle out of its vertices: the Leviathan keeps the gold axe's model.");
					return null;
				}
			}
			Mesh val = new Mesh
			{
				name = "leviathanaxe",
				vertices = array2,
				normals = array3,
				uv = array4,
				triangles = data.triangles
			};
			val.RecalculateBounds();
			val.RecalculateTangents();
			return val;
		}

		private static Texture2D LoadTexture(string resource, bool linear, FilterMode filter)
		{
			//IL_0011: 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_0023: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = ReadResource(resource);
			if (array == null)
			{
				return null;
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true, linear)
			{
				name = Path.GetFileNameWithoutExtension(resource)
			};
			if (LoadImage == null || !(bool)LoadImage.Invoke(null, new object[3] { val, array, true }))
			{
				Log.Error("\"" + resource + "\" could not be decoded: the Leviathan keeps the gold axe's model.");
				Object.Destroy((Object)(object)val);
				return null;
			}
			((Texture)val).filterMode = filter;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			return val;
		}

		private static Texture2D FlatNormalMap()
		{
			//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_0016: Expected O, but got Unknown
			//IL_0038: 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)
			Texture2D val = new Texture2D(4, 4, (TextureFormat)4, false, true)
			{
				name = "leviathan_normal"
			};
			Color32[] array = (Color32[])(object)new Color32[16];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Color32((byte)128, (byte)128, byte.MaxValue, byte.MaxValue);
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			return val;
		}

		private static byte[] ReadResource(string name)
		{
			using Stream stream = typeof(LeviathanModel).Assembly.GetManifestResourceStream(name);
			if (stream == null)
			{
				Log.Error("\"" + name + "\" is missing from the mod: the Leviathan keeps the gold axe's model.");
				return null;
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private static Vector3 HeadCenterOf(Vector3[] vertices, float bottom)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Bounds val = default(Bounds);
			foreach (Vector3 val2 in vertices)
			{
				if (!(val2.z < bottom))
				{
					if (!flag)
					{
						((Bounds)(ref val))..ctor(val2, Vector3.zero);
						flag = true;
					}
					else
					{
						((Bounds)(ref val)).Encapsulate(val2);
					}
				}
			}
			return ((Bounds)(ref val)).center;
		}

		private static Vector3 ToVector(float[] values)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(values[0], values[1], values[2]);
		}
	}
	public static class ThrownAxePrefab
	{
		internal const string PrefabName = "LeviathanAxe_thrown";

		private const string SparksChild = "sparcs_world";

		private const string LightChild = "Point light";

		private static GameObject _container;

		public static GameObject Prefab { get; private set; }

		internal static GameObject Create(GameObject itemPrefab)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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)
			Transform val = itemPrefab.transform.Find("attach");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("\"LeviathanAxe\" has no \"attach\" model: the axe cannot be thrown.");
				return null;
			}
			GameObject val2 = new GameObject("LeviathanAxe_thrown");
			val2.transform.SetParent(Container(), false);
			GameObject val3 = new GameObject("pivot");
			val3.transform.SetParent(val2.transform, false);
			GameObject val4 = Object.Instantiate<GameObject>(((Component)val).gameObject, val3.transform, false);
			((Object)val4).name = "model";
			val4.SetActive(true);
			Collider[] componentsInChildren = val4.GetComponentsInChildren<Collider>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
			}
			Transform val5 = val4.transform.Find("equiped");
			if ((Object)(object)val5 != (Object)null)
			{
				((Component)val5).gameObject.SetActive(true);
			}
			Vector3 val6 = ModelCenter(val4.transform);
			Vector3 val7 = BladeEdge(val4.transform, val6);
			val4.transform.localPosition = -val6;
			val4.transform.localRotation = Quaternion.identity;
			BorrowFrostSparks(val2.transform);
			ThrownAxeRelay thrownAxeRelay = val2.AddComponent<ThrownAxeRelay>();
			thrownAxeRelay.m_pivot = val3.transform;
			thrownAxeRelay.m_center = val6;
			thrownAxeRelay.m_edge = val7 - val6;
			thrownAxeRelay.m_model = val4.transform.Find("Model");
			Transform obj = val4.transform.Find("equiped/trail");
			thrownAxeRelay.m_trail = ((obj != null) ? ((Component)obj).GetComponent<MeleeWeaponTrail>() : null);
			Transform obj2 = val2.transform.Find("sparcs_world");
			thrownAxeRelay.m_sparks = ((obj2 != null) ? ((Component)obj2).GetComponent<ParticleSystem>() : null);
			Transform obj3 = val2.transform.Find("Point light");
			thrownAxeRelay.m_light = ((obj3 != null) ? ((Component)obj3).GetComponent<Light>() : null);
			Prefab = val2;
			return val2;
		}

		private static Transform Container()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if ((Object)(object)_container == (Object)null)
			{
				_container = new GameObject("LeviathanAxe_Prefabs");
				_container.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_container);
			}
			return _container.transform;
		}

		private static Vector3 ModelCenter(Transform model)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0069: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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)
			bool flag = false;
			Bounds val = default(Bounds);
			MeshFilter[] componentsInChildren = ((Component)model).GetComponentsInChildren<MeshFilter>(true);
			Vector3 val4 = default(Vector3);
			foreach (MeshFilter val2 in componentsInChildren)
			{
				if ((Object)(object)val2.sharedMesh == (Object)null)
				{
					continue;
				}
				Bounds bounds = val2.sharedMesh.bounds;
				Matrix4x4 val3 = model.worldToLocalMatrix * ((Component)val2).transform.localToWorldMatrix;
				for (int j = 0; j < 8; j++)
				{
					((Vector3)(ref val4))..ctor(((j & 1) == 0) ? ((Bounds)(ref bounds)).min.x : ((Bounds)(ref bounds)).max.x, ((j & 2) == 0) ? ((Bounds)(ref bounds)).min.y : ((Bounds)(ref bounds)).max.y, ((j & 4) == 0) ? ((Bounds)(ref bounds)).min.z : ((Bounds)(ref bounds)).max.z);
					Vector3 val5 = ((Matrix4x4)(ref val3)).MultiplyPoint3x4(val4);
					if (!flag)
					{
						((Bounds)(ref val))..ctor(val5, Vector3.zero);
						flag = true;
					}
					else
					{
						((Bounds)(ref val)).Encapsulate(val5);
					}
				}
			}
			if (!flag)
			{
				return Vector3.zero;
			}
			return ((Bounds)(ref val)).center;
		}

		private static Vector3 BladeEdge(Transform model, Vector3 center)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			Transform val = model.Find("edge");
			if ((Object)(object)val != (Object)null)
			{
				return model.InverseTransformPoint(val.position);
			}
			Transform val2 = model.Find("equiped/trail");
			Transform val3 = (((Object)(object)val2 != (Object)null) ? val2.Find("base") : null);
			Transform val4 = (((Object)(object)val2 != (Object)null) ? val2.Find("tip") : null);
			if ((Object)(object)val3 != (Object)null && (Object)(object)val4 != (Object)null)
			{
				return model.InverseTransformPoint((val3.position + val4.position) * 0.5f);
			}
			Log.Warning("Blade of the Leviathan not found: the axe will stick by its center.");
			return center;
		}

		private static void BorrowFrostSparks(Transform root)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = PrefabManager.Instance.GetPrefab("bow_projectile_frost");
			if ((Object)(object)prefab == (Object)null)
			{
				Log.Warning("\"bow_projectile_frost\" not found: the thrown axe has no frost sparks.");
				return;
			}
			string[] array = new string[2] { "sparcs_world", "Point light" };
			foreach (string text in array)
			{
				Transform val = prefab.transform.Find(text);
				if ((Object)(object)val == (Object)null)
				{
					Log.Warning("\"" + text + "\" not found in \"bow_projectile_frost\".");
					continue;
				}
				GameObject obj = Object.Instantiate<GameObject>(((Component)val).gameObject, root, false);
				((Object)obj).name = text;
				obj.transform.localPosition = Vector3.zero;
			}
		}
	}
	public static class Translations
	{
		public const string Name = "$leviathanaxe_name";

		public const string Description = "$leviathanaxe_desc";

		public const string Frozen = "$leviathanaxe_frozen";
	}
	internal static class VanillaPrefabs
	{
		internal const string ModelTemplate = "AxeGold";

		internal const string FrostTemplate = "AxeGold_FrostFire";

		internal const string ThrowTemplate = "SpearBronze";

		internal const string FrostProjectile = "bow_projectile_frost";

		internal const string FrostStatusEffect = "Frost";

		internal const string Forge = "forge";

		internal const string Silver = "Silver";

		internal const string Iron = "Iron";

		internal const string FreezeGland = "FreezeGland";

		internal const string ElderBark = "ElderBark";

		internal const string Upgrader = "Upgrader3Weapon";
	}
}