using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AichoGuardian")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AichoGuardian")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("D28110A9-E229-4700-AD4D-DCD37486A82B")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace NazhiMods.AichoGuardian;

[BepInPlugin("nazhi.aicho.guardian", "Aicho Guardian", "1.3.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class AichoGuardianPlugin : BaseUnityPlugin
{
	public const string PluginGuid = "nazhi.aicho.guardian";

	public const string PluginName = "Aicho Guardian";

	public const string PluginVersion = "1.3.0";

	internal const string GuardianPrefabName = "Aicho_Guardian";

	internal const string WallSourcePrefabName = "piece_dvergr_metal_wall_2x2";

	internal const string WallClonePrefabName = "AichoDverg_Wall";

	public static ConfigEntry<float> CFG_SearchRadius;

	public static ConfigEntry<float> CFG_ResetSeconds;

	private Harmony _harmony;

	private void Awake()
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Expected O, but got Unknown
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Expected O, but got Unknown
		CFG_SearchRadius = ((BaseUnityPlugin)this).Config.Bind<float>("AichoGuardian", "SearchRadius", 5f, new ConfigDescription("Radio máximo para buscar muros AichoDverg_Wall.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 100f), Array.Empty<object>()));
		CFG_ResetSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("AichoGuardian", "ResetSeconds", 5f, new ConfigDescription("Segundos para que el tótem vuelva a su estado visual activo tras usarse.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 600f), Array.Empty<object>()));
		PrefabManager.OnVanillaPrefabsAvailable += RegisterAichoGuardianAndWall;
		_harmony = new Harmony("nazhi.aicho.guardian");
		_harmony.PatchAll(typeof(AichoGuardianPlugin).Assembly);
		((BaseUnityPlugin)this).Logger.LogInfo((object)$"Aicho Guardian cargado con SearchRadius={CFG_SearchRadius.Value}, ResetSeconds={CFG_ResetSeconds.Value}");
	}

	private void OnDestroy()
	{
		PrefabManager.OnVanillaPrefabsAvailable -= RegisterAichoGuardianAndWall;
		try
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
		catch
		{
		}
	}

	private void RegisterAichoGuardianAndWall()
	{
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Expected O, but got Unknown
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Expected O, but got Unknown
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Expected O, but got Unknown
		//IL_0249: Unknown result type (might be due to invalid IL or missing references)
		//IL_0250: Expected O, but got Unknown
		//IL_0272: Unknown result type (might be due to invalid IL or missing references)
		//IL_0277: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: Unknown result type (might be due to invalid IL or missing references)
		//IL_028b: Expected O, but got Unknown
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a8: Expected O, but got Unknown
		try
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab("piece_dvergr_metal_wall_2x2");
			if ((Object)(object)prefab == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"No se encontró el prefab 'piece_dvergr_metal_wall_2x2'.");
				return;
			}
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("AichoDverg_Wall", prefab);
			if ((Object)(object)val == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"No se pudo clonar 'piece_dvergr_metal_wall_2x2' a 'AichoDverg_Wall'.");
				return;
			}
			EnsureAdminOnlyPlacement(val, "AichoDverg_Wall");
			Piece component = val.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = "$piece_aicho_dverg_wall";
				component.m_description = "$piece_aicho_dverg_wall_desc";
			}
			PieceConfig val2 = new PieceConfig();
			val2.PieceTable = "_HammerPieceTable";
			val2.Category = "Misc";
			val2.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
			{
				new RequirementConfig
				{
					Item = "Stone",
					Amount = 10
				}
			};
			PieceConfig val3 = val2;
			PieceManager.Instance.AddPiece(new CustomPiece(val, true, val3));
			LocalizationManager.Instance.AddToken("piece_aicho_dverg_wall", "Aicho Dvergr Wall", false);
			LocalizationManager.Instance.AddToken("piece_aicho_dverg_wall_desc", "Muro especial (solo admins).", false);
			GameObject prefab2 = PrefabManager.Instance.GetPrefab("guard_stone");
			if ((Object)(object)prefab2 == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"No se encontró el prefab base del tótem (guard_stone / dverger_guardstone).");
				return;
			}
			GameObject val4 = PrefabManager.Instance.CreateClonedPrefab("Aicho_Guardian", prefab2);
			if ((Object)(object)val4 == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"No se pudo clonar el prefab base del tótem.");
				return;
			}
			PrivateArea component2 = val4.GetComponent<PrivateArea>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
			Transform val5 = val4.transform.Find("AreaMarker");
			if ((Object)(object)val5 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val5).gameObject);
			}
			CircleProjector[] componentsInChildren = val4.GetComponentsInChildren<CircleProjector>(true);
			foreach (CircleProjector val6 in componentsInChildren)
			{
				Object.Destroy((Object)(object)((Component)val6).gameObject);
			}
			EnsureAdminOnlyPlacement(val4, "Aicho_Guardian");
			Piece component3 = val4.GetComponent<Piece>();
			if ((Object)(object)component3 != (Object)null)
			{
				component3.m_name = "$piece_aicho_guardian";
				component3.m_description = "$piece_aicho_guardian_desc";
			}
			AichoGuardianBehaviour aichoGuardianBehaviour = val4.GetComponent<AichoGuardianBehaviour>();
			if ((Object)(object)aichoGuardianBehaviour == (Object)null)
			{
				aichoGuardianBehaviour = val4.AddComponent<AichoGuardianBehaviour>();
			}
			aichoGuardianBehaviour.TargetPrefabName = "AichoDverg_Wall";
			val2 = new PieceConfig();
			val2.PieceTable = "_HammerPieceTable";
			val2.Category = "Misc";
			val2.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
			{
				new RequirementConfig
				{
					Item = "Stone",
					Amount = 10
				}
			};
			PieceConfig val7 = val2;
			PieceManager.Instance.AddPiece(new CustomPiece(val4, true, val7));
			LocalizationManager.Instance.AddToken("piece_aicho_guardian", "Aicho Guardian", false);
			LocalizationManager.Instance.AddToken("piece_aicho_guardian_desc", "Una piedra guardiana que destruye muros Aicho cercanos al activarse.", false);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Registrado OK: Aicho_Guardian + AichoDverg_Wall (admin-only wall + admin-only guardian).");
		}
		catch (Exception arg)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)$"Error registrando Aicho Guardian/Wall: {arg}");
		}
	}

	private static void EnsureAdminOnlyPlacement(GameObject go, string targetPrefabName)
	{
		AichoAdminOnlyPlacement aichoAdminOnlyPlacement = go.GetComponent<AichoAdminOnlyPlacement>();
		if ((Object)(object)aichoAdminOnlyPlacement == (Object)null)
		{
			aichoAdminOnlyPlacement = go.AddComponent<AichoAdminOnlyPlacement>();
		}
		aichoAdminOnlyPlacement.TargetPrefabName = targetPrefabName;
	}

	internal static bool IsSinglePlayerHost()
	{
		try
		{
			return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && ZNet.instance.GetConnectedPeers().Count == 0;
		}
		catch
		{
			return false;
		}
	}

	internal static long GetPlayerIdSafe(Player p)
	{
		try
		{
			return ((Object)(object)p != (Object)null) ? p.GetPlayerID() : 0;
		}
		catch
		{
			return 0L;
		}
	}

	internal static bool IsAdminLocal()
	{
		try
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (IsSinglePlayerHost())
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			long playerIdSafe = GetPlayerIdSafe(localPlayer);
			return playerIdSafe != 0L && ZNetExtension.IsAdmin(ZNet.instance, playerIdSafe);
		}
		catch
		{
			return false;
		}
	}

	internal static bool IsAdminId(long playerId)
	{
		try
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (IsSinglePlayerHost())
			{
				return true;
			}
			return playerId != 0L && ZNetExtension.IsAdmin(ZNet.instance, playerId);
		}
		catch
		{
			return false;
		}
	}
}
public class AichoGuardianBehaviour : MonoBehaviour, Interactable
{
	[CompilerGenerated]
	private sealed class <ResetVisualAfterDelay>d__10 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public float seconds;

		public AichoGuardianBehaviour <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			int num = <>1__state;
			AichoGuardianBehaviour aichoGuardianBehaviour = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(seconds);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				aichoGuardianBehaviour.SetActiveVisual(active: true);
				return false;
			}
		}

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

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

	public float SearchRadius = 5f;

	public string TargetPrefabName = "AichoDverg_Wall";

	private Coroutine _resetCoroutine;

	private void Start()
	{
		SetActiveVisual(active: true);
	}

	public string GetHoverText()
	{
		string text = Localization.instance.Localize("$piece_aicho_guardian");
		return Localization.instance.Localize(text + "\n[<color=yellow><b>$KEY_Use</b></color>] Romper muros Aicho cercanos");
	}

	public string GetHoverName()
	{
		return Localization.instance.Localize("$piece_aicho_guardian");
	}

	public bool Interact(Humanoid user, bool hold, bool alt)
	{
		if (hold)
		{
			return false;
		}
		if (!Object.op_Implicit((Object)(object)ZNet.instance) || !ZNet.instance.IsServer())
		{
			return false;
		}
		if (!IsAdminUser(user))
		{
			return false;
		}
		float radius = ((AichoGuardianPlugin.CFG_SearchRadius != null) ? AichoGuardianPlugin.CFG_SearchRadius.Value : SearchRadius);
		float seconds = ((AichoGuardianPlugin.CFG_ResetSeconds != null) ? Mathf.Max(0.01f, AichoGuardianPlugin.CFG_ResetSeconds.Value) : 5f);
		int num = DestroyNearbyWalls(radius);
		Logger.LogInfo((object)$"[AichoGuardian] Muros destruidos: {num}");
		SetActiveVisual(active: false);
		if (_resetCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(_resetCoroutine);
		}
		_resetCoroutine = ((MonoBehaviour)this).StartCoroutine(ResetVisualAfterDelay(seconds));
		return true;
	}

	private static bool IsAdminUser(Humanoid user)
	{
		if (AichoGuardianPlugin.IsSinglePlayerHost())
		{
			return true;
		}
		Player val = (Player)(object)((user is Player) ? user : null);
		if ((Object)(object)val == (Object)null)
		{
			return false;
		}
		long playerIdSafe = AichoGuardianPlugin.GetPlayerIdSafe(val);
		return AichoGuardianPlugin.IsAdminId(playerIdSafe);
	}

	public bool UseItem(Humanoid user, ItemData item)
	{
		return false;
	}

	private int DestroyNearbyWalls(float radius)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		int num = 0;
		Vector3 position = ((Component)this).transform.position;
		List<Piece> list = new List<Piece>();
		Piece.GetAllPiecesInRadius(position, radius, list);
		foreach (Piece item in list)
		{
			if ((Object)(object)item == (Object)null)
			{
				continue;
			}
			string prefabName = Utils.GetPrefabName(((Component)item).gameObject);
			if (string.Equals(prefabName, TargetPrefabName, StringComparison.Ordinal))
			{
				WearNTear component = ((Component)item).GetComponent<WearNTear>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)component.m_nview == (Object)null) && component.m_nview.IsValid())
				{
					component.m_nview.ClaimOwnership();
					ZNetScene.instance.Destroy(((Component)component).gameObject);
					num++;
				}
			}
		}
		return num;
	}

	[IteratorStateMachine(typeof(<ResetVisualAfterDelay>d__10))]
	private IEnumerator ResetVisualAfterDelay(float seconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ResetVisualAfterDelay>d__10(0)
		{
			<>4__this = this,
			seconds = seconds
		};
	}

	private void SetActiveVisual(bool active)
	{
		//IL_0051: 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_0075: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!((Object)(object)MaterialMan.instance == (Object)null))
			{
				if (active)
				{
					MaterialMan.instance.ResetValue(((Component)this).gameObject, ShaderProps._Color);
					MaterialMan.instance.ResetValue(((Component)this).gameObject, ShaderProps._EmissionColor);
				}
				else
				{
					MaterialMan.instance.SetValue<Color>(((Component)this).gameObject, ShaderProps._Color, Color.grey);
					MaterialMan.instance.SetValue<Color>(((Component)this).gameObject, ShaderProps._EmissionColor, Color.grey * 0.1f);
				}
			}
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)("[AichoGuardian] Error en SetActiveVisual: " + ex.Message));
		}
	}
}
public class AichoAdminOnlyPlacement : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <Start>d__2 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public AichoAdminOnlyPlacement <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			int num = <>1__state;
			AichoAdminOnlyPlacement aichoAdminOnlyPlacement = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
				{
					return false;
				}
				<>2__current = (object)new WaitForSeconds(0.15f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					if (string.IsNullOrEmpty(aichoAdminOnlyPlacement.TargetPrefabName))
					{
						return false;
					}
					string prefabName = Utils.GetPrefabName(((Component)aichoAdminOnlyPlacement).gameObject);
					if (!string.Equals(prefabName, aichoAdminOnlyPlacement.TargetPrefabName, StringComparison.Ordinal))
					{
						return false;
					}
					if (AichoGuardianPlugin.IsSinglePlayerHost())
					{
						return false;
					}
					Piece component = ((Component)aichoAdminOnlyPlacement).GetComponent<Piece>();
					if ((Object)(object)component == (Object)null)
					{
						return false;
					}
					long creatorIdBestEffort = GetCreatorIdBestEffort(component);
					Player localPlayer = Player.m_localPlayer;
					long num2 = (((Object)(object)localPlayer != (Object)null) ? AichoGuardianPlugin.GetPlayerIdSafe(localPlayer) : 0);
					if (creatorIdBestEffort != 0L && creatorIdBestEffort == num2)
					{
						return false;
					}
					if (creatorIdBestEffort != 0L && !AichoGuardianPlugin.IsAdminId(creatorIdBestEffort))
					{
						Logger.LogWarning((object)$"[AichoGuardian] Bloqueada colocación de {prefabName} por no-admin (creator={creatorIdBestEffort}).");
						WearNTear component2 = ((Component)aichoAdminOnlyPlacement).GetComponent<WearNTear>();
						if ((Object)(object)component2 != (Object)null && (Object)(object)component2.m_nview != (Object)null && component2.m_nview.IsValid())
						{
							component2.m_nview.ClaimOwnership();
						}
						if ((Object)(object)ZNetScene.instance != (Object)null)
						{
							ZNetScene.instance.Destroy(((Component)aichoAdminOnlyPlacement).gameObject);
						}
						else
						{
							Object.Destroy((Object)(object)((Component)aichoAdminOnlyPlacement).gameObject);
						}
					}
				}
				catch (Exception ex)
				{
					Logger.LogWarning((object)("[AichoGuardian] Error en AichoAdminOnlyPlacement: " + ex.Message));
				}
				return false;
			}
		}

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

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

	public string TargetPrefabName = "";

	private const float CheckDelay = 0.15f;

	[IteratorStateMachine(typeof(<Start>d__2))]
	private IEnumerator Start()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <Start>d__2(0)
		{
			<>4__this = this
		};
	}

	private static long GetCreatorIdBestEffort(Piece piece)
	{
		try
		{
			MethodInfo method = typeof(Piece).GetMethod("GetCreator", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method != null && method.ReturnType == typeof(long))
			{
				return (long)method.Invoke(piece, null);
			}
			FieldInfo field = typeof(Piece).GetField("m_creator", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && field.FieldType == typeof(long))
			{
				return (long)field.GetValue(piece);
			}
		}
		catch
		{
		}
		return 0L;
	}
}
[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
public static class AichoHammerVisibilityPatches
{
	[HarmonyPostfix]
	private static void PieceTable_UpdateAvailable_Postfix(PieceTable __instance, HashSet<string> knownRecipies, Player player, bool hideUnavailable, bool noPlacementCost)
	{
		try
		{
			if ((Object)(object)__instance == (Object)null || AichoGuardianPlugin.IsAdminLocal() || __instance.m_availablePieces == null || __instance.m_availablePieces.Count == 0)
			{
				return;
			}
			for (int i = 0; i < __instance.m_availablePieces.Count; i++)
			{
				List<Piece> list = __instance.m_availablePieces[i];
				if (list == null || list.Count == 0)
				{
					continue;
				}
				list.RemoveAll(delegate(Piece piece)
				{
					if ((Object)(object)piece == (Object)null)
					{
						return false;
					}
					string prefabName = Utils.GetPrefabName(((Component)piece).gameObject);
					return string.Equals(prefabName, "AichoDverg_Wall", StringComparison.Ordinal) || string.Equals(prefabName, "Aicho_Guardian", StringComparison.Ordinal);
				});
			}
		}
		catch
		{
		}
	}
}

using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BalrondBiomes_Meadows;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ProjectAshlands")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ProjectAshlands")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f405ea1c-ac25-47a3-9aa2-a8f56c14bfd6")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace BalrondBiomes_Meadows
{
	public class ShaderReplacment
	{
		public string[] shaderlist = new string[49]
		{
			"Custom/AlphaParticle", "Custom/Blob", "Custom/Bonemass", "Custom/Clouds", "Custom/Creature", "Custom/Decal", "Custom/Distortion", "Custom/Flow", "Custom/FlowOpaque", "Custom/Grass",
			"Custom/GuiScroll", "Custom/Heightmap", "Custom/icon", "Custom/InteriorSide", "Custom/LitGui", "Custom/LitParticles", "Custom/mapshader", "Custom/ParticleDecal", "Custom/Piece", "Custom/Player",
			"Custom/Rug", "Custom/ShadowBlob", "Custom/SkyboxProcedural", "Custom/SkyObject", "Custom/StaticRock", "Custom/Tar", "Custom/Trilinearmap", "Custom/UI/BGBlur", "Custom/Vegetation", "Custom/Water",
			"Custom/WaterBottom", "Custom/WaterMask", "Custom/Yggdrasil", "Custom/Yggdrasil/root", "Hidden/BlitCopyHDRTonemap", "Hidden/Dof/DepthOfFieldHdr", "Hidden/Dof/DX11Dof", "Hidden/Internal-Loading", "Hidden/Internal-UIRDefaultWorld", "Hidden/SimpleClear",
			"Hidden/SunShaftsComposite", "Lux Lit Particles/ Bumped", "Lux Lit Particles/ Tess Bumped", "Particles/Standard Surface2", "Particles/Standard Unlit2", "Standard TwoSided", "ToonDeferredShading2017", "Unlit/DepthWrite", "Unlit/Lighting"
		};

		public List<Shader> shaders = new List<Shader>();

		public void findShadersByName()
		{
			string[] array = shaderlist;
			foreach (string text in array)
			{
				Shader val = Shader.Find(text);
				if ((Object)(object)val != (Object)null)
				{
					shaders.Add(val);
				}
			}
		}

		public void ReplaceShadersInObject(GameObject gameObject)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (new ZNet().IsDedicated() || (Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = gameObject.GetComponentsInChildren<Renderer>();
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return;
			}
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials != null && sharedMaterials.Length != 0)
				{
					fixMaterial(sharedMaterials);
				}
			}
		}

		private void fixMaterial(Material[] shared)
		{
			foreach (Material val in shared)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Shader shader = val.shader;
				if (!((Object)(object)shader == (Object)null))
				{
					string name = ((Object)shader).name;
					if (!(name == "Standard") && name.Contains("Balrond"))
					{
						setProperValue(val, name);
					}
				}
			}
		}

		public Material setProperValue(Material material, string shaderName)
		{
			string name = shaderName.Replace("Balrond", "Custom");
			name = checkNaming(name);
			Shader val = Shader.Find(name);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("Shader not found " + name));
				return material;
			}
			material.shader = val;
			return material;
		}

		private string checkNaming(string name)
		{
			string result = name;
			if (name.Contains("Bumped"))
			{
				result = name.Replace("Custom", "Lux Lit Particles");
			}
			if (name.Contains("Tess Bumped"))
			{
				result = name.Replace("Custom", "Lux Lit Particles");
			}
			if (name.Contains("Standard Surface"))
			{
				result = name.Replace("Custom", "Particles");
				result = result.Replace("Standard Surface2", "Standard Surface");
			}
			if (name.Contains("Standard Unlit"))
			{
				result = name.Replace("Custom", "Particles");
				result = result.Replace("Standard Unlit", "Standard Unlit2");
				result = result.Replace("Standard Unlit22", "Standard Unlit2");
			}
			return result;
		}
	}
}
namespace BalrondTitanTroll
{
	public class FxReplacment
	{
		private List<GameObject> allPrefabs;

		private string projectName = "[BalrondTitanTroll]";

		public void setInstance(List<GameObject> gameObjects)
		{
			allPrefabs = gameObjects;
		}

		public void ReplaceOnObject(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			SpawnArea component = gameObject.GetComponent<SpawnArea>();
			if ((Object)(object)component != (Object)null)
			{
				EffectList spawnEffects = component.m_spawnEffects;
				if (spawnEffects != null)
				{
					findEffectsAndChange(spawnEffects.m_effectPrefabs);
				}
			}
			Destructible component2 = gameObject.GetComponent<Destructible>();
			if ((Object)(object)component2 != (Object)null)
			{
				EffectList hitEffect = component2.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs);
				}
				EffectList destroyedEffect = component2.m_destroyedEffect;
				if (destroyedEffect != null)
				{
					findEffectsAndChange(destroyedEffect.m_effectPrefabs);
				}
			}
			Projectile component3 = gameObject.GetComponent<Projectile>();
			if ((Object)(object)component3 != (Object)null)
			{
				EffectList hitEffects = component3.m_hitEffects;
				if (hitEffects != null)
				{
					findEffectsAndChange(hitEffects.m_effectPrefabs);
				}
				EffectList hitWaterEffects = component3.m_hitWaterEffects;
				if (hitWaterEffects != null)
				{
					findEffectsAndChange(hitWaterEffects.m_effectPrefabs);
				}
				EffectList spawnOnHitEffects = component3.m_spawnOnHitEffects;
				if (spawnOnHitEffects != null)
				{
					findEffectsAndChange(spawnOnHitEffects.m_effectPrefabs);
				}
			}
		}

		public void ReplaceOnVegetation(GameObject gameObject)
		{
			Pickable component = gameObject.GetComponent<Pickable>();
			if ((Object)(object)component != (Object)null)
			{
				fixPlant(component);
			}
			Destructible component2 = gameObject.GetComponent<Destructible>();
			if ((Object)(object)component2 != (Object)null)
			{
				fixPDestructable(component2);
			}
			MineRock5 component3 = gameObject.GetComponent<MineRock5>();
			if ((Object)(object)component3 != (Object)null)
			{
				fixMineRock5(component3);
			}
			MineRock component4 = gameObject.GetComponent<MineRock>();
			if ((Object)(object)component4 != (Object)null)
			{
				fixMineRock(component4);
			}
		}

		private void fixPlant(Pickable pickable)
		{
			EffectList pickEffector = pickable.m_pickEffector;
			if (pickEffector != null)
			{
				findEffectsAndChange(pickEffector.m_effectPrefabs);
			}
		}

		private void fixPDestructable(Destructible minerock5)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs);
			}
		}

		private void fixMineRock5(MineRock5 minerock5)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs);
			}
		}

		private void fixMineRock(MineRock minerock5)
		{
			EffectList hitEffect = minerock5.m_hitEffect;
			if (hitEffect != null)
			{
				findEffectsAndChange(hitEffect.m_effectPrefabs);
			}
			EffectList destroyedEffect = minerock5.m_destroyedEffect;
			if (destroyedEffect != null)
			{
				findEffectsAndChange(destroyedEffect.m_effectPrefabs);
			}
		}

		public void ReplaceOnMonster(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Debug.LogWarning((object)(projectName + ":: GameObject not found"));
				return;
			}
			Humanoid component = gameObject.GetComponent<Humanoid>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)(projectName + ":: GameObject not found"));
				return;
			}
			EffectList dropEffects = component.m_dropEffects;
			if (dropEffects != null)
			{
				findEffectsAndChange(dropEffects.m_effectPrefabs);
			}
			EffectList backstabHitEffects = ((Character)component).m_backstabHitEffects;
			if (backstabHitEffects != null)
			{
				findEffectsAndChange(backstabHitEffects.m_effectPrefabs);
			}
			EffectList consumeItemEffects = component.m_consumeItemEffects;
			if (consumeItemEffects != null)
			{
				findEffectsAndChange(consumeItemEffects.m_effectPrefabs);
			}
			EffectList critHitEffects = ((Character)component).m_critHitEffects;
			if (critHitEffects != null)
			{
				findEffectsAndChange(critHitEffects.m_effectPrefabs);
			}
			EffectList deathEffects = ((Character)component).m_deathEffects;
			if (deathEffects != null)
			{
				findEffectsAndChange(deathEffects.m_effectPrefabs);
			}
			EffectList hitEffects = ((Character)component).m_hitEffects;
			if (hitEffects != null)
			{
				findEffectsAndChange(hitEffects.m_effectPrefabs);
			}
			EffectList jumpEffects = ((Character)component).m_jumpEffects;
			if (jumpEffects != null)
			{
				findEffectsAndChange(jumpEffects.m_effectPrefabs);
			}
			EffectList perfectBlockEffect = component.m_perfectBlockEffect;
			if (perfectBlockEffect != null)
			{
				findEffectsAndChange(perfectBlockEffect.m_effectPrefabs);
			}
			EffectList pickupEffects = component.m_pickupEffects;
			if (pickupEffects != null)
			{
				findEffectsAndChange(pickupEffects.m_effectPrefabs);
			}
			EffectList slideEffects = ((Character)component).m_slideEffects;
			if (slideEffects != null)
			{
				findEffectsAndChange(slideEffects.m_effectPrefabs);
			}
			EffectList tarEffects = ((Character)component).m_tarEffects;
			if (tarEffects != null)
			{
				findEffectsAndChange(tarEffects.m_effectPrefabs);
			}
			EffectList waterEffects = ((Character)component).m_waterEffects;
			if (waterEffects != null)
			{
				findEffectsAndChange(waterEffects.m_effectPrefabs);
			}
			FootStep component2 = gameObject.GetComponent<FootStep>();
			if (!((Object)(object)component2 != (Object)null))
			{
				return;
			}
			List<StepEffect> effects = component2.m_effects;
			foreach (StepEffect item in effects)
			{
				GameObject[] effectPrefabs = item.m_effectPrefabs;
				List<GameObject> list = new List<GameObject>();
				list.AddRange(effectPrefabs);
				for (int i = 0; i < list.Count; i++)
				{
					if ((Object)(object)list[i] != (Object)null)
					{
						string name = ((Object)list[i]).name;
						GameObject val = allPrefabs.Find((GameObject x) => ((Object)x).name == name);
						if (!((Object)(object)val == (Object)null))
						{
							list[i] = val;
						}
					}
				}
			}
		}

		public void ReplaceOnItem(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			if (!((Object)(object)component == (Object)null))
			{
				EffectList hitEffect = component.m_itemData.m_shared.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs);
				}
				EffectList hitTerrainEffect = component.m_itemData.m_shared.m_hitTerrainEffect;
				if (hitTerrainEffect != null)
				{
					findEffectsAndChange(hitTerrainEffect.m_effectPrefabs);
				}
				EffectList holdStartEffect = component.m_itemData.m_shared.m_holdStartEffect;
				if (holdStartEffect != null)
				{
					findEffectsAndChange(holdStartEffect.m_effectPrefabs);
				}
				EffectList trailStartEffect = component.m_itemData.m_shared.m_trailStartEffect;
				if (trailStartEffect != null)
				{
					findEffectsAndChange(trailStartEffect.m_effectPrefabs);
				}
				EffectList blockEffect = component.m_itemData.m_shared.m_blockEffect;
				if (blockEffect != null)
				{
					findEffectsAndChange(blockEffect.m_effectPrefabs);
				}
			}
		}

		public void ReplaceFxOnPiece(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Piece component = gameObject.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null)
			{
				EffectList placeEffect = component.m_placeEffect;
				if (placeEffect != null)
				{
					findEffectsAndChange(placeEffect.m_effectPrefabs);
				}
			}
			WearNTear component2 = gameObject.GetComponent<WearNTear>();
			if ((Object)(object)component2 != (Object)null)
			{
				EffectList hitEffect = component2.m_hitEffect;
				if (hitEffect != null)
				{
					findEffectsAndChange(hitEffect.m_effectPrefabs);
				}
			}
		}

		private void findEffectsAndChange(EffectData[] effects)
		{
			if (effects == null || effects.Length == 0)
			{
				return;
			}
			foreach (EffectData val in effects)
			{
				if ((Object)(object)val.m_prefab != (Object)null)
				{
					string name = ((Object)val.m_prefab).name;
					GameObject val2 = allPrefabs.Find((GameObject x) => ((Object)x).name == name);
					if (!((Object)(object)val2 == (Object)null))
					{
						val.m_prefab = val2;
					}
				}
			}
		}
	}
	public class BuildPieceTargeting
	{
		private static string[] names = new string[0];

		public void changePieceTargeting(List<GameObject> gameObjects)
		{
			List<GameObject> list = gameObjects.FindAll((GameObject x) => (Object)(object)x.GetComponent<WearNTear>() != (Object)null);
			foreach (GameObject item in list)
			{
				Piece component = item.GetComponent<Piece>();
				if ((Object)(object)component != (Object)null && names.Contains(((Object)item).name))
				{
					((StaticTarget)component).m_primaryTarget = true;
				}
				if ((Object)(object)component != (Object)null && shouldBePrimaryTarget(item))
				{
					((StaticTarget)component).m_primaryTarget = true;
				}
				setResistances(item);
			}
		}

		private bool shouldBePrimaryTarget(GameObject gameObject)
		{
			if ((Object)(object)gameObject.GetComponent<Door>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)gameObject.GetComponent<CraftingStation>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)gameObject.GetComponent<StationExtension>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)gameObject.GetComponent<Container>() != (Object)null)
			{
				return false;
			}
			return false;
		}

		private void setResistances(GameObject gameObject)
		{
			//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_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_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)
			WearNTear component = gameObject.GetComponent<WearNTear>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_damages.m_chop = setChopDamageResistance(component);
				component.m_damages.m_pickaxe = setPickaxeDamageResistance(component);
				component.m_damages.m_fire = setFireDamageResistance(component);
			}
		}

		private DamageModifier setChopDamageResistance(WearNTear wearNTear)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0023: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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)
			MaterialType materialType = wearNTear.m_materialType;
			MaterialType val = materialType;
			return (DamageModifier)((int)val switch
			{
				0 => 6, 
				3 => 2, 
				2 => 5, 
				1 => 1, 
				_ => 0, 
			});
		}

		private DamageModifier setPickaxeDamageResistance(WearNTear wearNTear)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0023: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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)
			MaterialType materialType = wearNTear.m_materialType;
			MaterialType val = materialType;
			return (DamageModifier)((int)val switch
			{
				0 => 0, 
				3 => 1, 
				2 => 2, 
				1 => 6, 
				_ => 0, 
			});
		}

		private DamageModifier setFireDamageResistance(WearNTear wearNTear)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0023: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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)
			MaterialType materialType = wearNTear.m_materialType;
			MaterialType val = materialType;
			return (DamageModifier)((int)val switch
			{
				0 => 6, 
				3 => 2, 
				2 => 0, 
				1 => 5, 
				_ => 0, 
			});
		}
	}
	public class DatabaseAddMethods
	{
		public void AddItems(List<GameObject> items)
		{
			foreach (GameObject item in items)
			{
				AddItem(item);
			}
		}

		public void AddRecipes(List<Recipe> recipes)
		{
			foreach (Recipe recipe in recipes)
			{
				AddRecipe(recipe);
			}
		}

		public void AddStatuseffects(List<StatusEffect> statusEffects)
		{
			foreach (StatusEffect statusEffect in statusEffects)
			{
				AddStatus(statusEffect);
			}
		}

		private bool IsObjectDBValid()
		{
			return (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
		}

		private void AddStatus(StatusEffect status)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			if ((Object)(object)status != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.GetStatusEffect(((object)status).GetHashCode()) == (Object)null)
				{
					ObjectDB.instance.m_StatusEffects.Add(status);
				}
			}
			else
			{
				Debug.LogError((object)("BalrondTitanTroll:  " + ((Object)status).name + " - Status not found"));
			}
		}

		private void AddRecipe(Recipe recipe)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			if ((Object)(object)recipe != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.GetRecipe(recipe.m_item.m_itemData) == (Object)null)
				{
					ObjectDB.instance.m_recipes.Add(recipe);
				}
			}
			else
			{
				Debug.LogError((object)("BalrondTitanTroll:  " + ((Object)recipe).name + " - Recipe not found"));
			}
		}

		private void AddItem(GameObject newPrefab)
		{
			if (!IsObjectDBValid())
			{
				return;
			}
			ItemDrop component = newPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component != (Object)null)
			{
				if ((Object)(object)ObjectDB.instance.GetItemPrefab(((Object)newPrefab).name) == (Object)null)
				{
					ObjectDB.instance.m_items.Add(newPrefab);
					Dictionary<int, GameObject> dictionary = (Dictionary<int, GameObject>)typeof(ObjectDB).GetField("m_itemByHash", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(ObjectDB.instance);
					dictionary[((Object)newPrefab).name.GetHashCode()] = newPrefab;
				}
			}
			else
			{
				Debug.LogError((object)("BalrondTitanTroll:  " + ((Object)newPrefab).name + " - ItemDrop not found on prefab"));
			}
		}
	}
	[BepInPlugin("balrond.astafaraios.BalrondTitanTroll", "BalrondTitanTroll", "1.0.0")]
	public class Launch : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Game), "Awake")]
		public static class Game_Awake_Path
		{
			public static void Prefix()
			{
				ZNetScene_Awake_Path.hasSpawned = false;
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		public static class Object_CopyOtherDB_Path
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		public static class ObjectDB_Awake_Path
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
					databaseAddMethods.AddItems(modResourceLoader.items);
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public static class ZNetScene_Awake_Path
		{
			public static bool hasSpawned;

			public static void Prefix(ZNetScene __instance)
			{
				if ((Object)(object)__instance == (Object)null)
				{
					Debug.LogWarning((object)"BalrondTitanTroll: No ZnetScene found");
				}
				else if (!hasSpawned)
				{
					__instance.m_prefabs.Add(modResourceLoader.TitanTroll4);
					__instance.m_prefabs.Add(modResourceLoader.TitanTroll3);
					__instance.m_prefabs.Add(modResourceLoader.TitanTroll2);
					__instance.m_prefabs.Add(modResourceLoader.TitanTroll);
					__instance.m_prefabs.Add(modResourceLoader.groundslamAoE);
					__instance.m_prefabs.Add(modResourceLoader.tauntAoE);
					__instance.m_prefabs.Add(modResourceLoader.screamvfx);
					__instance.m_prefabs.Add(modResourceLoader.soundvfx);
					__instance.m_prefabs.AddRange(modResourceLoader.items);
					hasSpawned = true;
				}
			}
		}

		private readonly Harmony harmony = new Harmony("balrond.astafaraios.BalrondTitanTroll");

		public const string PluginGUID = "balrond.astafaraios.BalrondTitanTroll";

		public const string PluginName = "BalrondTitanTroll";

		public const string PluginVersion = "1.0.0";

		public static ModResourceLoader modResourceLoader = new ModResourceLoader();

		public static ItemEdits itemEdits = new ItemEdits();

		public static DatabaseAddMethods databaseAddMethods = new DatabaseAddMethods();

		public static BuildPieceTargeting pieceTargeting = new BuildPieceTargeting();

		public static GameObject RootObject;

		public static GameObject PrefabContainer;

		private void Awake()
		{
			createPrefabContainer();
			modResourceLoader.loadAssets();
			harmony.PatchAll();
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
		}

		public void createPrefabContainer()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			RootObject = new GameObject("_ValheimReforgedRoot");
			Object.DontDestroyOnLoad((Object)(object)RootObject);
			PrefabContainer = new GameObject("Prefabs");
			PrefabContainer.transform.parent = RootObject.transform;
			PrefabContainer.SetActive(false);
		}

		public static GameObject cloneMe(GameObject source, string name)
		{
			GameObject val = Object.Instantiate<GameObject>(source, PrefabContainer.transform);
			((Object)val).name = name;
			return val;
		}

		private static bool IsObjectDBValid()
		{
			return (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
		}

		public static void addStatusToAttackField(GameObject gameObject, StatusEffect statusEffect)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_attackStatusEffect = statusEffect;
		}
	}
	public class ModResourceLoader
	{
		public AssetBundle assetBundle;

		public ShaderReplacment shaderReplacment = new ShaderReplacment();

		public GameObject TitanTroll;

		public GameObject TitanTroll2;

		public GameObject TitanTroll3;

		public GameObject TitanTroll4;

		public GameObject swingV;

		public GameObject swingH;

		public GameObject swingH2;

		public GameObject swingV_2hand;

		public GameObject swingH_2hand;

		public GameObject swingH_2hand2;

		public GameObject shield;

		public GameObject charge;

		public GameObject charge2;

		public GameObject charge3;

		public GameObject shieldslam;

		public GameObject groundslam;

		public GameObject punch;

		public GameObject punch2;

		public GameObject throwRock;

		public GameObject slam2h;

		public GameObject taunt;

		public GameObject tauntAoE;

		public GameObject tauntB;

		public GameObject screamvfx;

		public GameObject soundvfx;

		public GameObject groundslamAoE;

		public List<GameObject> items = new List<GameObject>();

		public void loadAssets()
		{
			assetBundle = GetAssetBundleFromResources("titantroll");
			string text = "Assets/Custom/Comission/DarkTroll/";
			TitanTroll = assetBundle.LoadAsset<GameObject>(text + "TitanTroll.prefab");
			shaderReplacment.ReplaceShadersInObject(TitanTroll);
			TitanTroll3 = assetBundle.LoadAsset<GameObject>(text + "TitanTroll1h.prefab");
			shaderReplacment.ReplaceShadersInObject(TitanTroll3);
			TitanTroll2 = assetBundle.LoadAsset<GameObject>(text + "TitanTroll2h.prefab");
			shaderReplacment.ReplaceShadersInObject(TitanTroll2);
			TitanTroll4 = assetBundle.LoadAsset<GameObject>(text + "TitanTrollR.prefab");
			shaderReplacment.ReplaceShadersInObject(TitanTroll4);
			swingV = assetBundle.LoadAsset<GameObject>(text + "Titantroll_log_swing_v.prefab");
			shaderReplacment.ReplaceShadersInObject(swingV);
			swingH = assetBundle.LoadAsset<GameObject>(text + "Titantroll_log_swing_h.prefab");
			shaderReplacment.ReplaceShadersInObject(swingH);
			swingH2 = assetBundle.LoadAsset<GameObject>(text + "Titantroll_log_swing_mace.prefab");
			shaderReplacment.ReplaceShadersInObject(swingH2);
			swingV_2hand = assetBundle.LoadAsset<GameObject>(text + "Titantroll_log_swing_v_2hand.prefab");
			shaderReplacment.ReplaceShadersInObject(swingV_2hand);
			swingH_2hand = assetBundle.LoadAsset<GameObject>(text + "Titantroll_log_swing_h_2hand.prefab");
			shaderReplacment.ReplaceShadersInObject(swingH_2hand);
			swingH_2hand2 = assetBundle.LoadAsset<GameObject>(text + "Titantroll_log_swing_h_2hand1.prefab");
			shaderReplacment.ReplaceShadersInObject(swingH_2hand2);
			shield = assetBundle.LoadAsset<GameObject>(text + "ShieldTroll.prefab");
			shaderReplacment.ReplaceShadersInObject(shield);
			charge = assetBundle.LoadAsset<GameObject>(text + "TitanTroll_dash.prefab");
			shaderReplacment.ReplaceShadersInObject(charge);
			charge2 = assetBundle.LoadAsset<GameObject>(text + "TitanTroll_dash_1hand.prefab");
			shaderReplacment.ReplaceShadersInObject(charge2);
			charge3 = assetBundle.LoadAsset<GameObject>(text + "TitanTroll_dash_2hand.prefab");
			shaderReplacment.ReplaceShadersInObject(charge3);
			shieldslam = assetBundle.LoadAsset<GameObject>(text + "Titantroll_shieldslam.prefab");
			shaderReplacment.ReplaceShadersInObject(shieldslam);
			punch = assetBundle.LoadAsset<GameObject>(text + "Titantroll_punch.prefab");
			shaderReplacment.ReplaceShadersInObject(punch);
			punch2 = assetBundle.LoadAsset<GameObject>(text + "Titantroll_doublepunch.prefab");
			shaderReplacment.ReplaceShadersInObject(punch2);
			throwRock = assetBundle.LoadAsset<GameObject>(text + "Titantroll_throw.prefab");
			shaderReplacment.ReplaceShadersInObject(throwRock);
			groundslam = assetBundle.LoadAsset<GameObject>(text + "Titantroll_groundslam.prefab");
			shaderReplacment.ReplaceShadersInObject(groundslam);
			slam2h = assetBundle.LoadAsset<GameObject>(text + "Titantroll_log_swing_h_2hand_slam.prefab");
			shaderReplacment.ReplaceShadersInObject(groundslam);
			taunt = assetBundle.LoadAsset<GameObject>(text + "Titantroll_taunt.prefab");
			shaderReplacment.ReplaceShadersInObject(taunt);
			tauntAoE = assetBundle.LoadAsset<GameObject>(text + "Titantroll_scream_aoe.prefab");
			shaderReplacment.ReplaceShadersInObject(tauntAoE);
			groundslamAoE = assetBundle.LoadAsset<GameObject>(text + "Titantroll_groundslam_aoe.prefab");
			shaderReplacment.ReplaceShadersInObject(groundslamAoE);
			screamvfx = assetBundle.LoadAsset<GameObject>(text + "sfx_titantroll_scream.prefab");
			shaderReplacment.ReplaceShadersInObject(screamvfx);
			soundvfx = assetBundle.LoadAsset<GameObject>(text + "sfx_titantroll_sound.prefab");
			shaderReplacment.ReplaceShadersInObject(soundvfx);
			items.Add(swingH);
			items.Add(swingH2);
			items.Add(swingV);
			items.Add(swingH_2hand);
			items.Add(swingH_2hand2);
			items.Add(swingV_2hand);
			items.Add(shield);
			items.Add(charge);
			items.Add(charge2);
			items.Add(charge3);
			items.Add(shieldslam);
			items.Add(taunt);
			items.Add(punch);
			items.Add(punch2);
			items.Add(slam2h);
			items.Add(groundslam);
			items.Add(throwRock);
		}

		private AssetBundle GetAssetBundleFromResources(string filename)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}
	}
	public class ItemEdits
	{
		private string[] itemEditNames = new string[14]
		{
			"draugr_sword", "draugr_bow", "draugr_axe", "skeleton_bow", "skeleton_mace", "skeleton_sword2", "skeleton_bow2", "skeleton_sword2", "imp_fireball_attack", "Ghost_attack",
			"gd_king_shoot", "Greydwarf_shaman_attack", "GoblinKing_Beam", "GoblinShaman_attack_fireball"
		};

		private GameObject FindItem(List<GameObject> list, string name)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Debug.LogWarning((object)("BalrondTitanTroll: Item Not Found: " + name));
			return null;
		}

		public void editItems(List<GameObject> list)
		{
			string[] array = itemEditNames;
			foreach (string text in array)
			{
				GameObject val = FindItem(list, text);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogWarning((object)("Could not find: " + text));
				}
				else
				{
					CheckStats(val);
				}
			}
		}

		private void CheckStats(GameObject gameObject)
		{
			switch (((Object)gameObject).name)
			{
			case "draugr_sword":
				editSpiritDamageStat(gameObject, 25);
				break;
			case "draugr_bow":
				editSpiritDamageStat(gameObject, 15);
				break;
			case "draugr_axe":
				editSpiritDamageStat(gameObject, 15);
				break;
			case "skeleton_bow":
			case "skeleton_sword":
			case "Ghost_attack":
				editSpiritDamageStat(gameObject, 10);
				break;
			case "skeleton_bow2":
			case "skeleton_mace":
			case "skeleton_sword2":
			case "gd_king_shoot":
			case "Greydwarf_shaman_attack":
			case "GoblinKing_Beam":
			case "GoblinShaman_attack_fireball":
				editSpiritDamageStat(gameObject, 20);
				break;
			case "imp_fireball_attack":
				editSpiritDamageStat(gameObject, 10);
				break;
			}
		}

		private void editSpiritDamageStat(GameObject gameObject, int spiritDamage)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_damages.m_spirit = spiritDamage;
			if (((Object)gameObject).name == "skeleton_mace" || ((Object)gameObject).name == "imp_fireball_attack")
			{
				component.m_itemData.m_shared.m_damages.m_blunt += spiritDamage;
			}
		}

		private void editFoodStat(GameObject gameObject, int hp = -99, int stam = -99, int eitr = -99, int time = -99, int regen = -99)
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			component.m_itemData.m_shared.m_food = ((hp == -99) ? component.m_itemData.m_shared.m_food : ((float)hp));
			component.m_itemData.m_shared.m_foodStamina = ((stam == -99) ? component.m_itemData.m_shared.m_foodStamina : ((float)stam));
			component.m_itemData.m_shared.m_foodEitr = ((eitr == -99) ? component.m_itemData.m_shared.m_foodEitr : ((float)eitr));
			component.m_itemData.m_shared.m_foodRegen = ((regen == -99) ? component.m_itemData.m_shared.m_foodRegen : ((float)regen));
			component.m_itemData.m_shared.m_foodBurnTime = ((time == -99) ? component.m_itemData.m_shared.m_foodBurnTime : ((float)time));
		}
	}
	public class StatusEffectBuilder
	{
		public List<StatusEffect> statusEffects = new List<StatusEffect>();

		public void setShieldStatus(SE_LevelShield statusEffect, Sprite icon)
		{
			((StatusEffect)statusEffect).m_icon = icon;
			((StatusEffect)statusEffect).m_ttl = 40f;
			((Object)statusEffect).name = "SE_LevelShield";
			((StatusEffect)statusEffect).m_name = "Shield_MonsterRandomizer";
			((StatusEffect)statusEffect).m_tooltip = "You been shielded";
			((StatusEffect)statusEffect).m_activationAnimation = "";
			statusEffects.Add((StatusEffect)(object)statusEffect);
		}

		public void setBleedingStatus(SE_bleed statusEffect, Sprite icon)
		{
			((StatusEffect)statusEffect).m_icon = icon;
			((StatusEffect)statusEffect).m_ttl = 60f;
			((StatusEffect)statusEffect).m_tooltip = "You been slashed open. Any more cuts will hurt more";
			((StatusEffect)statusEffect).m_activationAnimation = "encumbered";
			statusEffects.Add((StatusEffect)(object)statusEffect);
		}

		public void setPiercedStatus(SE_pierced statusEffect, Sprite icon)
		{
			((StatusEffect)statusEffect).m_icon = icon;
			((StatusEffect)statusEffect).m_ttl = 60f;
			((StatusEffect)statusEffect).m_tooltip = "You been pierced. Another stab like that will be more fatal";
			((StatusEffect)statusEffect).m_activationAnimation = "encumbered";
			statusEffects.Add((StatusEffect)(object)statusEffect);
		}

		public void setCrushedStatus(SE_crushed statusEffect, Sprite icon)
		{
			((StatusEffect)statusEffect).m_icon = icon;
			((StatusEffect)statusEffect).m_ttl = 60f;
			((StatusEffect)statusEffect).m_tooltip = "Your bone was crushed. Another blunt hit will be fatal";
			((StatusEffect)statusEffect).m_activationAnimation = "encumbered";
			statusEffects.Add((StatusEffect)(object)statusEffect);
		}

		public void setBadgaesStatus(StatusEffect statusEffect, Sprite icon)
		{
			SE_Bandages sE_Bandages = (SE_Bandages)(object)statusEffect;
			((StatusEffect)sE_Bandages).m_icon = icon;
			((StatusEffect)sE_Bandages).m_name = "First Aid";
			((StatusEffect)sE_Bandages).m_category = "bandages";
			((Object)sE_Bandages).name = "Bandages";
			((StatusEffect)sE_Bandages).m_ttl = 120f;
			((StatusEffect)sE_Bandages).m_tooltip = "Applied first aid. This will help mend the pain";
			((SE_Stats)sE_Bandages).m_healthOverTimeInterval = 5f;
			((SE_Stats)sE_Bandages).m_healthOverTimeDuration = ((StatusEffect)sE_Bandages).m_ttl;
			((SE_Stats)sE_Bandages).m_healthOverTimeTickHP = 3f;
			((StatusEffect)sE_Bandages).m_activationAnimation = "equipping";
			statusEffects.Add((StatusEffect)(object)sE_Bandages);
		}

		public StatusEffect cloneShield(StatusEffect shield, int absorb, string name)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			SE_Shield val = (SE_Shield)shield.Clone();
			val.m_absorbDamage = absorb;
			((StatusEffect)val).m_name = name;
			((Object)val).name = name;
			return (StatusEffect)(object)val;
		}

		public static void setupVisualsForStatus(StatusEffect statusEffect, List<GameObject> list)
		{
			if ((Object)(object)statusEffect == (Object)null)
			{
				Debug.LogWarning((object)"Status Effect is null!");
				return;
			}
			switch (statusEffect.m_name)
			{
			case "Bleeding":
			{
				SE_bleed sE_bleed = (SE_bleed)(object)statusEffect;
				break;
			}
			case "Crushed":
			{
				SE_crushed sE_crushed = (SE_crushed)(object)statusEffect;
				break;
			}
			case "Pierced":
			{
				SE_pierced sE_pierced = (SE_pierced)(object)statusEffect;
				break;
			}
			case "Shield_MonsterRandomizer":
			{
				List<EffectData> list2 = new List<EffectData>();
				SE_LevelShield sE_LevelShield = (SE_LevelShield)(object)statusEffect;
				list2.Add(createEffectData(list, "fx_GoblinShieldBreak", attach: true, "", scale: true));
				list2.RemoveAll((EffectData x) => (Object)(object)x.m_prefab == (Object)null);
				sE_LevelShield.m_breakEffects.m_effectPrefabs = list2.ToArray();
				List<EffectData> list3 = new List<EffectData>();
				list3.Add(createEffectData(list, "fx_GoblinShieldHit", attach: true, "", scale: true));
				list3.RemoveAll((EffectData x) => (Object)(object)x.m_prefab == (Object)null);
				sE_LevelShield.m_hitEffects.m_effectPrefabs = list3.ToArray();
				List<EffectData> list4 = new List<EffectData>();
				list4.Add(createEffectData(list, "vfx_GoblinShield", attach: true, "", scale: true));
				list4.RemoveAll((EffectData x) => (Object)(object)x.m_prefab == (Object)null);
				((StatusEffect)sE_LevelShield).m_startEffects.m_effectPrefabs = list4.ToArray();
				break;
			}
			}
		}

		private static EffectData createEffectData(List<GameObject> list, string name, bool attach = false, string attachName = "", bool scale = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			EffectData val = new EffectData();
			val.m_variant = -1;
			val.m_prefab = FindEffect(list, name);
			val.m_enabled = true;
			val.m_attach = attach;
			val.m_scale = scale;
			val.m_childTransform = attachName;
			return val;
		}

		private static GameObject FindEffect(List<GameObject> list, string name)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return null;
		}
	}
	public class SE_Bandages : SE_Stats
	{
		[Header("SE_Bandages")]
		public float m_waterDamage;

		public float m_damageInterval = 0.5f;

		private float m_timer;

		public override void Setup(Character character)
		{
			((SE_Stats)this).Setup(character);
		}

		public override void UpdateStatusEffect(float dt)
		{
			//IL_00a5: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00d2: Expected O, but got Unknown
			((SE_Stats)this).UpdateStatusEffect(dt);
			if ((double)base.m_tickInterval > 0.0)
			{
				base.m_tickTimer += dt;
				if ((double)base.m_tickTimer >= (double)base.m_tickInterval)
				{
					base.m_tickTimer = 0f;
					if ((double)((StatusEffect)this).m_character.GetHealthPercentage() >= (double)base.m_healthPerTickMinHealthPercentage)
					{
						if ((double)base.m_healthPerTick > 0.0)
						{
							((StatusEffect)this).m_character.Heal(base.m_healthPerTick, true);
						}
						else
						{
							((StatusEffect)this).m_character.Damage(new HitData
							{
								m_damage = 
								{
									m_damage = 0f - base.m_healthPerTick
								},
								m_point = ((StatusEffect)this).m_character.GetTopPoint()
							});
						}
					}
				}
			}
			if ((double)base.m_healthOverTimeTicks > 0.0)
			{
				base.m_healthOverTimeTimer += dt;
				if ((double)base.m_healthOverTimeTimer > (double)base.m_healthOverTimeInterval)
				{
					base.m_healthOverTimeTimer = 0f;
					base.m_healthOverTimeTicks -= 1f;
					((StatusEffect)this).m_character.Heal(base.m_healthOverTimeTickHP, true);
				}
			}
			if (((StatusEffect)this).m_character.GetSEMan().HaveStatusEffect("Pierced") || ((StatusEffect)this).m_character.GetSEMan().HaveStatusEffect("Bleeding") || ((StatusEffect)this).m_character.GetSEMan().HaveStatusEffect("Crushed"))
			{
				((StatusEffect)this).m_time = ((StatusEffect)this).m_time + dt * 10f;
			}
			((StatusEffect)this).m_time = ((StatusEffect)this).m_time + dt * 50f;
		}
	}
	public class SE_LevelShield : StatusEffect
	{
		[Header("SE_LevelShield")]
		public float m_baseAbsorbDamage = 10f;

		private int level = 1;

		private int bonusShield = 10;

		public float m_absorbDamage = 20f;

		public SkillType m_levelUpSkillOnBreak;

		public float m_levelUpSkillFactor = 1f;

		public int m_ttlPerItemLevel;

		public float m_absorbDamagePerSkillLevel;

		public EffectList m_breakEffects = new EffectList();

		public EffectList m_hitEffects = new EffectList();

		private float m_totalAbsorbDamage;

		private float m_damage;

		public override void Setup(Character character)
		{
			((Object)this).name = "SE_LevelShield";
			base.m_name = "Shield_MonsterRandomizer";
			((StatusEffect)this).Setup(character);
			level = base.m_character.m_level;
			CharacterType();
		}

		private void CharacterType()
		{
			switch (((Object)((Component)base.m_character).gameObject).name)
			{
			case "Skeleton_NoArcher":
			case "Skeleton":
				bonusShield = 15;
				break;
			case "Skeleton_Poison":
				bonusShield = 20;
				break;
			case "Draugr":
			case "Draugr_Ranged":
				bonusShield = 25;
				break;
			case "Draugr_Elite":
				bonusShield = 30;
				break;
			case "Goblin":
			case "GoblinArcher":
			case "GoblinShaman":
				bonusShield = 35;
				break;
			case "Surtling":
				bonusShield = 20;
				break;
			}
			m_absorbDamage = (float)level * ((float)bonusShield + m_baseAbsorbDamage);
		}

		public override bool IsDone()
		{
			//IL_0030: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between Unknown and I4
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if ((double)m_damage <= (double)m_totalAbsorbDamage)
			{
				return ((StatusEffect)this).IsDone();
			}
			m_breakEffects.Create(base.m_character.GetCenterPoint(), ((Component)base.m_character).transform.rotation, ((Component)base.m_character).transform, base.m_character.GetRadius() * 2f, -1);
			if ((int)m_levelUpSkillOnBreak > 0)
			{
				Skills skills = base.m_character.GetSkills();
				if ((Object)(object)skills != (Object)null && Object.op_Implicit((Object)(object)skills))
				{
					skills.RaiseSkill(m_levelUpSkillOnBreak, m_levelUpSkillFactor);
					Terminal.Log((object)$"{base.m_name} is leveling up {m_levelUpSkillOnBreak} at factor {m_levelUpSkillFactor}");
				}
			}
			return true;
		}

		public override void OnDamaged(HitData hit, Character attacker)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			m_damage += hit.GetTotalDamage();
			hit.ApplyModifier(0f);
			m_hitEffects.Create(hit.m_point, Quaternion.LookRotation(-hit.m_dir), ((Component)base.m_character).transform, 1f, -1);
		}

		public override void SetLevel(int itemLevel, float skillLevel)
		{
			if (m_ttlPerItemLevel > 0)
			{
				base.m_ttl = m_ttlPerItemLevel * itemLevel;
			}
			m_totalAbsorbDamage = m_absorbDamage + m_absorbDamagePerSkillLevel * skillLevel;
			Terminal.Log((object)$"Shield setting itemlevel: {itemLevel} = ttl: {base.m_ttl}, skilllevel: {skillLevel} = absorb: {m_totalAbsorbDamage}");
			((StatusEffect)this).SetLevel(itemLevel, skillLevel);
		}

		public override string GetTooltipString()
		{
			return ((StatusEffect)this).GetTooltipString() + "\n$se_shield_ttl <color=orange>" + base.m_ttl.ToString("0") + "</color>\n$se_shield_damage <color=orange>" + m_totalAbsorbDamage.ToString("0") + "</color>";
		}
	}
	public class SE_bleed : StatusEffect
	{
		[Header("SE_bleed")]
		private float m_timer;

		public List<DamageModPair> m_mods = new List<DamageModPair>();

		public void Awake()
		{
			//IL_001a: 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_002b: 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)
			base.m_name = "Bleeding";
			((Object)this).name = "Bleeding";
			DamageModPair item = default(DamageModPair);
			item.m_type = (DamageType)2;
			item.m_modifier = (DamageModifier)2;
			m_mods.Add(item);
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			if (base.m_character.GetSEMan().HaveStatusEffect("Bandages"))
			{
				base.m_time += dt * 5f;
			}
			base.m_ttl -= dt;
			if (!((double)base.m_ttl > 0.0))
			{
			}
		}

		public override void ModifyDamageMods(ref DamageModifiers modifiers)
		{
			((DamageModifiers)(ref modifiers)).Apply(m_mods);
		}
	}
	public class SE_BlockStamUse : StatusEffect
	{
		public float m_bonus = 0f;

		public float m_baseConsumption = 0f;

		public void Awake()
		{
			base.m_name = "BlockStaminaUse";
			((Object)this).name = "BlockStaminaUse";
			base.m_tooltip = "Block Stamina Use decreased by " + m_bonus + "x";
		}

		public void setBlockStaminaUse(float bonus)
		{
			m_bonus = bonus;
			base.m_tooltip = "Block Stamina Use decreased by " + bonus + "x";
		}

		public float getBlockStaminaUse()
		{
			return m_bonus;
		}
	}
	public class SE_BonusHealth : StatusEffect
	{
		public float m_bonus = 0f;

		public void Awake()
		{
			base.m_name = "BonusHealth";
			((Object)this).name = "BonusHealth";
			base.m_tooltip = "Health is increased by " + (m_bonus + 1f) + " points.";
		}

		public void SetHealthBonus(float bonus)
		{
			m_bonus = bonus;
			base.m_tooltip = "Health is increased by " + (m_bonus + 1f) + " points.";
		}

		public float getHealthBonus()
		{
			return m_bonus;
		}
	}
	public class SE_BonusHealthRegen : StatusEffect
	{
		public float m_bonus = 0f;

		public void Awake()
		{
			base.m_name = "HpRegen";
			((Object)this).name = "HpRegen";
			base.m_tooltip = "Health Regen is increased by " + (m_bonus + 1f) + "x.";
		}

		public void setHealPercent(float bonus)
		{
			m_bonus = bonus;
			base.m_tooltip = "Health Regen is increased by " + (m_bonus + 1f) + "x.";
		}

		public float getHealPercent()
		{
			return m_bonus;
		}
	}
	public class SE_BonusStamina : StatusEffect
	{
		public float m_bonus = 0f;

		public void Awake()
		{
			base.m_name = "BonusStamina";
			((Object)this).name = "BonusStamina";
			base.m_tooltip = "Stamina is increased by " + (m_bonus + 1f) + " points.";
		}

		public void SetStaminaBonus(float bonus)
		{
			m_bonus = bonus;
			base.m_tooltip = "Stamina is increased by " + (m_bonus + 1f) + " points.";
		}

		public float GetStaminaBonus()
		{
			return m_bonus;
		}
	}
	public class SE_BonusStaminaRegen : StatusEffect
	{
		public float m_bonus = 0f;

		public void Awake()
		{
			base.m_name = "StaminaRegen";
			((Object)this).name = "StaminaRegen";
			base.m_tooltip = "Stamina Regen is increased by " + m_bonus + "%.";
		}

		public void SetRegenPercent(float bonus)
		{
			m_bonus = bonus;
			base.m_tooltip = "Stamina Regen is increased by " + m_bonus + "%.";
		}

		public float GetRegenPercent()
		{
			return m_bonus;
		}
	}
	public class SE_crushed : StatusEffect
	{
		[Header("SE_crushed")]
		public List<DamageModPair> m_mods = new List<DamageModPair>();

		private float m_timer;

		public float m_speedModifier;

		public void Awake()
		{
			//IL_001a: 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_002b: 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)
			base.m_name = "Crushed";
			((Object)this).name = "Crushed";
			DamageModPair item = default(DamageModPair);
			item.m_type = (DamageType)1;
			item.m_modifier = (DamageModifier)2;
			m_mods.Add(item);
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			if (base.m_character.GetSEMan().HaveStatusEffect("Bandages"))
			{
				base.m_time += dt * 5f;
			}
			base.m_ttl -= dt;
			if (!((double)base.m_ttl > 0.0))
			{
			}
		}

		public override void ModifyDamageMods(ref DamageModifiers modifiers)
		{
			((DamageModifiers)(ref modifiers)).Apply(m_mods);
		}

		public override void ModifySpeed(float baseSpeed, ref float speed)
		{
			if (base.m_character.IsSwimming())
			{
				speed += (float)((double)baseSpeed * (double)m_speedModifier * 0.5);
			}
			else
			{
				speed += baseSpeed * m_speedModifier;
			}
			if (!((double)speed >= 0.0))
			{
				speed = 0f;
			}
		}
	}
	public class SE_pierced : StatusEffect
	{
		[Header("SE_pierced")]
		private float m_timer;

		public List<DamageModPair> m_mods = new List<DamageModPair>();

		public void Awake()
		{
			//IL_001a: 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_002b: 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)
			base.m_name = "Pierced";
			((Object)this).name = "Pierced";
			DamageModPair item = default(DamageModPair);
			item.m_type = (DamageType)4;
			item.m_modifier = (DamageModifier)2;
			m_mods.Add(item);
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			if (base.m_character.GetSEMan().HaveStatusEffect("Bandages"))
			{
				base.m_time += dt * 5f;
			}
			base.m_ttl -= dt;
			if (!((double)base.m_ttl > 0.0))
			{
			}
		}

		public override void ModifyDamageMods(ref DamageModifiers modifiers)
		{
			((DamageModifiers)(ref modifiers)).Apply(m_mods);
		}
	}
}