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);
		}
	}
}