using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Configuration;
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 BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: Guid("f405ea1c-ac25-47a3-9aa2-a8f56c14bfd6")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyProduct("BalrondEotenasClanRebuild")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("BalrondEotenasClanRebuild")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[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 EotenasClans
{
	public class ClanObject
	{
		public string clanName;

		public string msg;

		public StatusEffect status;

		public GameObject item;

		public GameObject sfx;

		public EffectList clanEffects = new EffectList();
	}
	public class ClanTotem : MonoBehaviour, Interactable, Hoverable
	{
		private ZNetView _znv;

		private string chosenClan = "";

		private void Awake()
		{
			_znv = ((Component)this).GetComponent<ZNetView>();
			if (_znv.IsValid())
			{
				_znv.Register<string>("UseClanTotem", (Action<long, string>)UseClanTotem);
				chosenClan = _znv.m_zdo.GetString("Clan", "");
				SetVisuals(chosenClan);
			}
		}

		private void UseClanTotem(long sender, string name)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (_znv.IsOwner())
			{
				Debug.Log((object)("And the name is: " + name));
				chosenClan = name;
				_znv.m_zdo.Set("Clan", name);
				EffectList vfxForClan = ClanManager.getVfxForClan(chosenClan);
				if (vfxForClan != null)
				{
					vfxForClan.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				}
			}
			SetVisuals(name);
		}

		private void SetVisuals(string clan)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if (clan == "" || clan == null)
			{
				return;
			}
			Transform val = ((Component)this).transform.Find("Items");
			foreach (Transform item in val)
			{
				Transform val2 = item;
				((Component)val2).gameObject.SetActive(false);
			}
			((Component)val.Find(clan)).gameObject.SetActive(true);
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (chosenClan == "" || chosenClan == null)
			{
				chosenClan = _znv.m_zdo.GetString("Clan", "");
			}
			if (chosenClan != "" && chosenClan != null)
			{
				string msgForClan = ClanManager.getMsgForClan(chosenClan);
				MessageHud.instance.ShowMessage((MessageType)2, msgForClan, 0, (Sprite)null);
				ClanManager.SetFaction(chosenClan);
				EffectList vfxForClan = ClanManager.getVfxForClan(chosenClan);
				if (vfxForClan != null)
				{
					vfxForClan.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				}
				return true;
			}
			MessageHud.instance.ShowMessage((MessageType)2, "This totem does not belong to any clan", 0, (Sprite)null);
			return false;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			if (chosenClan == "" || chosenClan == null)
			{
				chosenClan = _znv.m_zdo.GetString("Clan", "");
			}
			if (Player.m_debugMode || Terminal.m_cheat)
			{
				Debug.Log((object)("Clan amount:" + ClanManager.clans.Count));
				foreach (ClanObject clan in ClanManager.clans)
				{
					if (clan == null || !(((Object)clan.item).name == ((Object)item.m_dropPrefab).name))
					{
						continue;
					}
					Debug.Log((object)("Found clan: " + clan.clanName));
					_znv.InvokeRPC(ZNetView.Everybody, "UseClanTotem", new object[1] { clan.clanName });
					user.m_inventory.RemoveOneItem(item);
					return true;
				}
			}
			if (chosenClan != "" && chosenClan != null)
			{
				return false;
			}
			return false;
		}

		public string GetHoverText()
		{
			string text = ((_znv.m_zdo.GetString("Clan", "") != "") ? Localization.instance.Localize("\n[<color=yellow><b>$KEY_Use</b></color>] Set Clan") : "");
			return Localization.instance.Localize("[<color=yellow><b>1-8</b></color>] Use clan item") + text;
		}

		public string GetHoverName()
		{
			return "Clan Totem";
		}
	}
	public class DatabaseAddMethods
	{
		public static string projectName = "EotenasClans";

		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);
					Debug.Log((object)(projectName + ":  " + ((Object)status).name + " - Status Added to the Game"));
				}
			}
			else
			{
				Debug.LogError((object)(projectName + ":  " + ((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);
					Debug.Log((object)(projectName + ":  " + ((Object)recipe).name + " - Recipe Added to the Game"));
				}
			}
			else
			{
				Debug.LogError((object)(projectName + ":  " + ((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;
					Debug.Log((object)(projectName + ":  " + ((Object)newPrefab).name + " - Item Added to the Game"));
				}
			}
			else
			{
				Debug.LogError((object)(projectName + ":  " + ((Object)newPrefab).name + " - ItemDrop not found on prefab"));
			}
		}
	}
	public static class ClanManager
	{
		public static List<ClanObject> clans = new List<ClanObject>();

		public static void setup()
		{
			createClans();
		}

		public static StatusEffect getStatusForClan(string clanName)
		{
			return clans.Find((ClanObject x) => x.clanName == clanName)?.status;
		}

		public static string getMsgForClan(string clanName)
		{
			ClanObject clanObject = clans.Find((ClanObject x) => x.clanName == clanName);
			if (clanObject != null)
			{
				return clanObject.msg;
			}
			return "Behold the Clan";
		}

		public static EffectList getVfxForClan(string clanName)
		{
			return clans.Find((ClanObject x) => x.clanName == clanName)?.clanEffects;
		}

		public static GameObject getClanItem(string clanName)
		{
			return clans.Find((ClanObject x) => x.clanName == clanName)?.item;
		}

		public static void SetFaction(string clanName)
		{
			if (Player.m_localPlayer.m_customData.ContainsKey("Balrond_EotenasClan") && !Player.m_debugMode && !Terminal.m_cheat)
			{
				Debug.Log((object)"Player already have asigned clan");
				return;
			}
			Player.m_localPlayer.m_customData["Balrond_EotenasClan"] = clanName;
			LoadClanStatus();
		}

		public static void LoadClanStatus()
		{
			if (!Player.m_localPlayer.m_customData.ContainsKey("Balrond_EotenasClan"))
			{
				Debug.Log((object)"Player has no clan asigned");
				return;
			}
			string clanName = Player.m_localPlayer.m_customData["Balrond_EotenasClan"];
			StatusEffect statusForClan = getStatusForClan(clanName);
			if ((Object)(object)statusForClan != (Object)null && (Object)(object)((Character)Player.m_localPlayer).GetSEMan().GetStatusEffect(((object)statusForClan).GetHashCode()) == (Object)null)
			{
				((Character)Player.m_localPlayer).GetSEMan().AddStatusEffect(statusForClan, false, 0, 0f);
			}
		}

		private static void createClans()
		{
			serpentClan();
			drakeClan();
			ravenClan();
			wolfClan();
		}

		private static void serpentClan()
		{
			ClanObject clanObject = new ClanObject();
			clanObject.clanName = "Serpent";
			clanObject.item = Launch.Serpents;
			clanObject.status = Launch.SerpentStatus;
			clanObject.clanEffects = createEffectListFromObject(Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanSerpent"));
			clanObject.sfx = Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanSerpent");
			clanObject.msg = "Scream of the Serpent!";
			clans.Add(clanObject);
		}

		private static void drakeClan()
		{
			ClanObject clanObject = new ClanObject();
			clanObject.clanName = "Drake";
			clanObject.item = Launch.Drakes;
			clanObject.status = Launch.DrakeStatus;
			clanObject.clanEffects = createEffectListFromObject(Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanDrake"));
			clanObject.sfx = Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanDrake");
			clanObject.msg = "Roar of the Drake!";
			clans.Add(clanObject);
		}

		private static void ravenClan()
		{
			ClanObject clanObject = new ClanObject();
			clanObject.clanName = "Raven";
			clanObject.item = Launch.Ravens;
			clanObject.status = Launch.RavenStatus;
			clanObject.clanEffects = createEffectListFromObject(Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanRaven"));
			clanObject.sfx = Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanRaven");
			clanObject.msg = "Screech of the Raven!";
			clans.Add(clanObject);
		}

		private static void wolfClan()
		{
			ClanObject clanObject = new ClanObject();
			clanObject.clanName = "Wolf";
			clanObject.item = Launch.Wolfs;
			clanObject.status = Launch.WolfStatus;
			clanObject.clanEffects = createEffectListFromObject(Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanWolf"));
			clanObject.sfx = Launch.vfxPrefabs.Find((GameObject x) => ((Object)x).name == "sfx_clanWolf");
			clanObject.msg = "Howl of the wolf!";
			clans.Add(clanObject);
		}

		private static EffectList createEffectListFromObject(GameObject gameObject)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			EffectList val = new EffectList();
			List<EffectData> list = new List<EffectData>();
			EffectData val2 = new EffectData();
			val2.m_prefab = gameObject;
			list.Add(val2);
			val.m_effectPrefabs = list.ToArray();
			return val;
		}
	}
	public class FxReplacment
	{
		private List<GameObject> allPrefabs;

		private string projectName = "BalrondAstafaraios.EotenasClans";

		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;
					}
				}
			}
		}
	}
	[BepInPlugin("BalrondAstafaraios.EotenasClans", "BalrondAstafaraios.EotenasClans", "1.0.6")]
	public class Launch : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Player), "Load")]
		private class InitClasn
		{
			private static void Postfix()
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					ClanManager.LoadClanStatus();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnRespawn")]
		private class InitClanOnRespawn
		{
			private static void Postfix()
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					ClanManager.LoadClanStatus();
				}
			}
		}

		[HarmonyPatch(typeof(AudioMan), "Awake")]
		private static class AudioMan_Awake_Patch
		{
			private static void Postfix(AudioMan __instance)
			{
				GameObject[] array = asset.LoadAllAssets<GameObject>();
				foreach (GameObject val in array)
				{
					AudioSource[] componentsInChildren = val.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val2 in componentsInChildren)
					{
						val2.outputAudioMixerGroup = __instance.m_masterMixer.outputAudioMixerGroup;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		public static class Object_CopyOtherDB_Path
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
					List<GameObject> list = new List<GameObject>();
					list.Add(Ravens);
					list.Add(Serpents);
					list.Add(Drakes);
					list.Add(Wolfs);
					list.AddRange(itemList);
					List<StatusEffect> list2 = new List<StatusEffect>();
					list2.Add(RavenStatus);
					list2.Add(SerpentStatus);
					list2.Add(DrakeStatus);
					list2.Add(WolfStatus);
					list2.AddRange(statusList);
					databaseAddMethods.AddItems(list);
					databaseAddMethods.AddStatuseffects(list2);
					recipes = recipeBuilder.setupRecipes(list, ObjectDB.instance.m_items);
					databaseAddMethods.AddRecipes(recipes);
				}
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		public static class ObjectDB_Awake_Path
		{
			public static void Postfix()
			{
				if (IsObjectDBValid())
				{
					List<GameObject> list = new List<GameObject>();
					list.Add(Ravens);
					list.Add(Serpents);
					list.Add(Drakes);
					list.Add(Wolfs);
					list.AddRange(itemList);
					List<StatusEffect> list2 = new List<StatusEffect>();
					list2.Add(RavenStatus);
					list2.Add(SerpentStatus);
					list2.Add(DrakeStatus);
					list2.Add(WolfStatus);
					list2.AddRange(statusList);
					databaseAddMethods.AddItems(list);
					databaseAddMethods.AddStatuseffects(list2);
					recipes = recipeBuilder.setupRecipes(list, ObjectDB.instance.m_items);
					databaseAddMethods.AddRecipes(recipes);
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public static class ZNetScene_Awake_Patch
		{
			private static void Prefix(ZNetScene __instance)
			{
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null)
				{
					Debug.LogWarning((object)"BalrondAstafaraios.EotenasClans: No ZnetScene found");
					return;
				}
				List<GameObject> list = new List<GameObject>();
				list.Add(Ravens);
				list.Add(Serpents);
				list.Add(Drakes);
				list.Add(Wolfs);
				list.AddRange(itemList);
				__instance.m_prefabs.Add(draconis);
				__instance.m_prefabs.Add(ClanAltar);
				__instance.m_prefabs.AddRange(list);
				recipeBuilder.setupPieces(pieceList, __instance.m_prefabs);
				__instance.m_prefabs.AddRange(pieceList);
				if (hasSpawned)
				{
					return;
				}
				GameObject val = __instance.m_prefabs.Find((GameObject x) => ((Object)x).name == "Hammer");
				PieceTable buildPieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
				GameObject val2 = buildPieces.m_pieces.Find((GameObject x) => ((Object)x).name == ((Object)ClanAltar).name);
				if ((Object)(object)val2 == (Object)null && !hasSpawned)
				{
					buildPieces.m_pieces.Add(ClanAltar);
				}
				createTotemRecipe(__instance);
				foreach (GameObject piece in pieceList)
				{
					GameObject val3 = buildPieces.m_pieces.Find((GameObject x) => ((Object)x).name == ((Object)piece).name);
					if ((Object)(object)val3 == (Object)null && !hasSpawned)
					{
						buildPieces.m_pieces.Add(piece);
					}
				}
				hasSpawned = true;
				if (!new ZNet().IsDedicated())
				{
					ShaderReplacment.runMaterialFix();
				}
			}
		}

		private const string GUID = "BalrondAstafaraios.EotenasClans";

		public const string PluginName = "BalrondAstafaraios.EotenasClans";

		private const string PluginVersion = "1.0.6";

		private static AssetBundle asset;

		public static List<Recipe> recipes = new List<Recipe>();

		public static RecipeBuilder recipeBuilder = new RecipeBuilder();

		public static DatabaseAddMethods databaseAddMethods = new DatabaseAddMethods();

		public static GameObject Ravens;

		public static GameObject Serpents;

		public static GameObject Drakes;

		public static GameObject Wolfs;

		public static StatusEffect RavenStatus;

		public static StatusEffect SerpentStatus;

		public static StatusEffect DrakeStatus;

		public static StatusEffect WolfStatus;

		public static List<GameObject> itemList = new List<GameObject>();

		public static bool hasSpawned = false;

		public static string[] prefabNames = new string[62]
		{
			"ShieldClanSerpent", "ShieldClanDrake", "ShieldClanRaven", "ShieldClanWolf", "ArmorSerpentT1Legs", "ArmorSerpentT2Legs", "ArmorSerpentT3Legs", "ArmorSerpentT1Chest", "ArmorSerpentT2Chest", "ArmorSerpentT3Chest",
			"HelmetSerpentT1", "HelmetSerpentT2", "HelmetSerpentT3", "ArmorDrakeT1Legs", "ArmorDrakeT2Legs", "ArmorDrakeT3Legs", "ArmorDrakeT1Chest", "ArmorDrakeT2Chest", "ArmorDrakeT3Chest", "HelmetDrakeT1",
			"HelmetDrakeT2", "HelmetDrakeT3", "ArmorRavenT1Legs", "ArmorRavenT2Legs", "ArmorRavenT3Legs", "ArmorRavenT1Chest", "ArmorRavenT2Chest", "ArmorRavenT3Chest", "HelmetRavenT1", "HelmetRavenT2",
			"HelmetRavenT3", "ArmorWolfT1Legs", "ArmorWolfT2Legs", "ArmorWolfT3Legs", "ArmorWolfT1Chest", "ArmorWolfT2Chest", "ArmorWolfT3Chest", "HelmetWolfT1", "HelmetWolfT2", "HelmetWolfT3",
			"CapeClanDrake", "CapeClanRaven", "CapeClanSerpent", "CapeClanWolf", "ClanDrakeAxe", "ClanSerpentSpear", "ClanRavenStaff", "ClanWolfSword", "ArmorClanDrakeChest", "ArmorClanRavenChest",
			"ArmorClanSerpentChest", "ArmorClanWolfChest", "ArmorClanLegs", "HelmetClanDrake", "HelmetClanRaven", "HelmetClanSerpent", "HelmetClanWolf", "CapeFeatherDrake", "CapeFeatherSerpent", "CapeFeatherReaven",
			"CapeFeatherWolf", "Dragonetta_NPC_Strike"
		};

		public static List<GameObject> pieceList = new List<GameObject>();

		public static string[] pieceNames = new string[8] { "piece_banner_drakes", "piece_banner_serpents", "piece_banner_ravens", "piece_banner_wolfs", "carpetClanDrake", "carpetClanSerpent", "carpetClanRaven", "carpetClanWolf" };

		public static List<StatusEffect> statusList = new List<StatusEffect>();

		public static string[] statusNames = new string[13]
		{
			"DrakeT1", "DrakeT2", "DrakeT3", "RavenT1", "RavenT2", "RavenT3", "SerpentT1", "SerpentT2", "SerpentT3", "WolfT1",
			"WolfT2", "WolfT3", "BaseClanSet"
		};

		public static GameObject ClanAltar;

		public static List<GameObject> vfxPrefabs = new List<GameObject>();

		public static string[] vfxNames = new string[18]
		{
			"sfx_Dragonetta_alerted", "sfx_Dragonetta_death", "sfx_Dragonetta_Hit", "sfx_Dragonetta_hurt", "sfx_Dragonetta_idle", "fx_eikthyr_forwardshockwave_raven", "projectile_tridentharpoon", "sfx_clanDrake", "sfx_clanRaven", "sfx_clanSerpent",
			"sfx_clanWolf", "thunderbolt_projectile_raven", "vfx_clanDrake", "vfx_clanRaven", "vfx_clanSerpent", "vfx_clanWolf", "vfx_thunderbolt_explosion_raven", "Wave_Ground_drake"
		};

		public static GameObject draconis;

		private void Awake()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			asset = GetAssetBundle("balrondclans");
			LoadAssets();
			ClanManager.setup();
			new Harmony("BalrondAstafaraios.EotenasClans").PatchAll();
		}

		private void LoadAssets()
		{
			Ravens = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/SymbolRaven.prefab");
			Serpents = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/SymbolSerpent.prefab");
			Drakes = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/SymbolDrake.prefab");
			Wolfs = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/SymbolWolf.prefab");
			ShaderReplacment.Replace(Ravens);
			ShaderReplacment.Replace(Serpents);
			ShaderReplacment.Replace(Drakes);
			ShaderReplacment.Replace(Wolfs);
			draconis = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/DragonettaNPC.prefab");
			ShaderReplacment.Replace(draconis);
			RavenStatus = asset.LoadAsset<StatusEffect>("Assets/Custom/Comission/EotenasClans/StatusClanRaven.asset");
			SerpentStatus = asset.LoadAsset<StatusEffect>("Assets/Custom/Comission/EotenasClans/StatusClanSerpent.asset");
			DrakeStatus = asset.LoadAsset<StatusEffect>("Assets/Custom/Comission/EotenasClans/StatusClanDrake.asset");
			WolfStatus = asset.LoadAsset<StatusEffect>("Assets/Custom/Comission/EotenasClans/StatusClanWolf.asset");
			ClanAltar = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/ClanTotem.prefab");
			ClanAltar.AddComponent<ClanTotem>();
			ShaderReplacment.Replace(ClanAltar);
			string[] array = vfxNames;
			foreach (string text in array)
			{
				GameObject val = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/vfx/" + text + ".prefab");
				if ((Object)(object)val != (Object)null)
				{
					ShaderReplacment.Replace(val);
					vfxPrefabs.Add(val);
				}
				else
				{
					Debug.LogWarning((object)("Item not found: " + text));
				}
			}
			string[] array2 = prefabNames;
			foreach (string text2 in array2)
			{
				GameObject val2 = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/items/" + text2 + ".prefab");
				if ((Object)(object)val2 != (Object)null)
				{
					ShaderReplacment.Replace(val2);
					itemList.Add(val2);
				}
				else
				{
					Debug.LogWarning((object)("Item not found: " + text2));
				}
			}
			string[] array3 = pieceNames;
			foreach (string text3 in array3)
			{
				GameObject val3 = asset.LoadAsset<GameObject>("Assets/Custom/Comission/EotenasClans/pieces/" + text3 + ".prefab");
				if ((Object)(object)val3 != (Object)null)
				{
					ShaderReplacment.Replace(val3);
					pieceList.Add(val3);
				}
				else
				{
					Debug.LogWarning((object)("Piece not found: " + text3));
				}
			}
			string[] array4 = statusNames;
			foreach (string text4 in array4)
			{
				StatusEffect val4 = asset.LoadAsset<StatusEffect>("Assets/Custom/Comission/EotenasClans/Status/" + text4 + ".asset");
				if ((Object)(object)val4 != (Object)null)
				{
					statusList.Add(val4);
				}
				else
				{
					Debug.LogWarning((object)("Status not found: " + text4));
				}
			}
		}

		private static AssetBundle GetAssetBundle(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);
		}

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

		private static Requirement createReq(string name, int amount, int amountPerLevel, ZNetScene zNetScene)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			Requirement val = new Requirement();
			val.m_recover = true;
			ItemDrop component = zNetScene.m_prefabs.Find((GameObject x) => ((Object)x).name == name).GetComponent<ItemDrop>();
			val.m_resItem = component;
			val.m_amount = amount;
			val.m_amountPerLevel = amountPerLevel;
			return val;
		}

		public static void createTotemRecipe(ZNetScene zNetScene)
		{
			List<Requirement> list = new List<Requirement>();
			list.Add(createReq("SwordCheat", 1, 0, zNetScene));
			ClanAltar.GetComponent<Piece>().m_resources = list.ToArray();
			Debug.Log((object)"i set Req on altar");
		}
	}
	public class RecipeRebalance
	{
		public string name = "";

		public string item = "Wood";

		public int amount = 1;

		public string craftingStation = "";

		public string minStationLevel = "1";

		public bool enabled = true;

		public string repairStation = "";

		public string res1 = "";

		public string res2 = "";

		public string res3 = "";

		public string res4 = "";

		public string res5 = "";

		public string res6 = "";

		public List<Resource> resources = new List<Resource>();

		public bool wasLoaded = false;

		public void convertResToList()
		{
			int num = 0;
			if (resources.Count == 0)
			{
				num += stringArrayToResource(splitString(res1));
				num += stringArrayToResource(splitString(res2));
				num += stringArrayToResource(splitString(res3));
				num += stringArrayToResource(splitString(res4));
				num += stringArrayToResource(splitString(res5));
				num += stringArrayToResource(splitString(res6));
				if (num == 6)
				{
					Debug.LogWarning((object)("DVERGER FURNITURE: No resources found for recipe: " + name));
				}
			}
		}

		private string[] splitString(string res)
		{
			if (res != "")
			{
				return res.Split(new char[1] { ':' });
			}
			return null;
		}

		private int stringArrayToResource(string[] array)
		{
			if (array != null)
			{
				if (array.Length == 4)
				{
					Resource resource = new Resource();
					resource.item = array[0];
					resource.amount = Convert.ToInt32(array[1]);
					resource.amountPerLevel = Convert.ToInt32(array[2]);
					resource.recovery = Convert.ToBoolean(array[3]);
					resources.Add(resource);
					return 0;
				}
				Debug.LogWarning((object)("DVERGER FURNITURE: Incomplete array resource length: " + array.Length));
				return 1;
			}
			return 1;
		}

		public string ObjectToString()
		{
			return "Name:" + name + " Item:" + item + " Amount:" + amount + " Table:" + craftingStation + " Level:" + minStationLevel + " Enabled:" + enabled + " Repair:" + repairStation + " Resources:" + ResourcesToString();
		}

		public string ResourcesToString()
		{
			string text = "";
			foreach (Resource resource in resources)
			{
				text = text + " Name:" + resource.item + " Amount:" + resource.amount + " PerLevel:" + resource.amountPerLevel + " Recover:" + resource.recovery + ",";
			}
			return text;
		}
	}
	public class Resource
	{
		public int amount = 1;

		public int amountPerLevel = 0;

		public bool recovery = true;

		public ItemDrop itemDrop;

		public Requirement pieceConfig;

		public string item = "Wood";

		public Resource()
		{
		}

		public Resource(string item, int amount, int amountPerLevel = 0, bool recovery = true)
		{
			this.item = item;
			this.amount = amount;
			this.amountPerLevel = amountPerLevel;
			this.recovery = recovery;
		}

		public void setItemDrop(GameObject prefab)
		{
			if ((Object)(object)prefab.GetComponent<ItemDrop>() != (Object)null)
			{
				itemDrop = prefab.GetComponent<ItemDrop>();
			}
			else
			{
				Debug.LogWarning((object)("DVERGER FURNITURE: NO ITEM DROP FOUND on prefab name: " + ((Object)prefab).name));
			}
		}

		public Requirement getPieceConfig()
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_003e: Expected O, but got Unknown
			Requirement val = new Requirement
			{
				m_resItem = itemDrop,
				m_amount = amount,
				m_amountPerLevel = amountPerLevel,
				m_recover = recovery
			};
			Requirement result = val;
			pieceConfig = val;
			return result;
		}
	}
	public class RecipeBuilder
	{
		private List<GameObject> pieces;

		private List<GameObject> items;

		public List<Recipe> setupRecipes(List<GameObject> items, List<GameObject> objectDbItems)
		{
			this.items = objectDbItems;
			pieces = this.items.Find((GameObject x) => ((Object)x).name == "Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
			List<Recipe> list = new List<Recipe>();
			foreach (GameObject item in items)
			{
				if (!(((Object)item).name == "Dragonetta_NPC_Strike"))
				{
					Recipe val = createItemRecipe(item, objectDbItems);
					if ((Object)(object)val != (Object)null)
					{
						list.Add(val);
					}
				}
			}
			return list;
		}

		private Recipe createItemRecipe(GameObject item, List<GameObject> objectDbItems)
		{
			if (!isItemOnTheList(((Object)item).name))
			{
				return null;
			}
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			List<Requirement> list = new List<Requirement>();
			((Object)val).name = "Recipe_ClanItem_" + ((Object)item).name;
			val.m_item = item.GetComponent<ItemDrop>();
			switch (((Object)item).name)
			{
			case "ShieldClanSerpent":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 1, 1));
				list.Add(createReq("FineWood", 15, 8));
				list.Add(createReq("Iron", 15, 10));
				list.Add(createReq("TrollHide", 5, 2));
				break;
			case "ShieldClanDrake":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 1, 1));
				list.Add(createReq("FineWood", 15, 8));
				list.Add(createReq("Iron", 15, 10));
				list.Add(createReq("TrollHide", 5, 2));
				break;
			case "ShieldClanRaven":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 1, 1));
				list.Add(createReq("FineWood", 15, 8));
				list.Add(createReq("Iron", 15, 10));
				list.Add(createReq("TrollHide", 5, 2));
				break;
			case "ShieldClanWolf":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 1, 1));
				list.Add(createReq("FineWood", 15, 8));
				list.Add(createReq("Iron", 15, 10));
				list.Add(createReq("TrollHide", 5, 2));
				break;
			case "ArmorSerpentT1Legs":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 1, 1));
				list.Add(createReq("BearFur", 5, 2, "DeerHide", 5, 2));
				list.Add(createReq("BlackMetal", 20, 10));
				list.Add(createReq("Root", 20, 10));
				break;
			case "ArmorSerpentT2Legs":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 2, 2));
				list.Add(createReq("ArmorSerpentT1Legs", 1, 0));
				list.Add(createReq("ScaleHide", 20, 10));
				list.Add(createReq("SerpentScale", 20, 10));
				break;
			case "ArmorSerpentT3Legs":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolSerpent", 3, 3));
				list.Add(createReq("ArmorSerpentT2Legs", 1, 0));
				list.Add(createReq("BonemawSerpentScale", 10, 5, "SerpentScale", 10, 5));
				list.Add(createReq("StormScale", 10, 5, "SerpentScale", 10, 5));
				break;
			case "ArmorSerpentT1Chest":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 1, 1));
				list.Add(createReq("Chitin", 15, 7));
				list.Add(createReq("BlackMetal", 15, 7));
				list.Add(createReq("SerpentScale", 10, 5));
				break;
			case "ArmorSerpentT2Chest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 2, 2));
				list.Add(createReq("ArmorSerpentT1Chest", 1, 0));
				list.Add(createReq("SerpentScale", 10, 5));
				list.Add(createReq("Mandible", 5, 3));
				break;
			case "ArmorSerpentT3Chest":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolSerpent", 3, 3));
				list.Add(createReq("ArmorSerpentT2Chest", 1, 0));
				list.Add(createReq("Carapace", 10, 5));
				list.Add(createReq("BonemawSerpentScale", 10, 5, "SerpentScale", 20, 10));
				break;
			case "HelmetSerpentT1":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 1, 1));
				list.Add(createReq("TrophySerpent", 1, 0));
				list.Add(createReq("BlackMetal", 10, 7));
				list.Add(createReq("Chitin", 15, 10));
				break;
			case "HelmetSerpentT2":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 2, 2));
				list.Add(createReq("HelmetSerpentT1", 1, 0));
				list.Add(createReq("SerpentScale", 1, 1));
				list.Add(createReq("JuteRed", 10, 4));
				break;
			case "HelmetSerpentT3":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolSerpent", 3, 3));
				list.Add(createReq("HelmetSerpentT2", 1, 0));
				list.Add(createReq("TrophySerpent", 4, 2));
				list.Add(createReq("SilkReinforcedThread", 6, 3, "LinenThread", 20, 10));
				break;
			case "ArmorDrakeT1Legs":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 1, 1));
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("FreezeGland", 6, 2));
				list.Add(createReq("DrakeSkin", 10, 5, "WolfPelt", 10, 5));
				break;
			case "ArmorDrakeT2Legs":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 2, 2));
				list.Add(createReq("ArmorDrakeT1Legs", 1, 0));
				list.Add(createReq("ScaleHide", 8, 4));
				list.Add(createReq("DrakeSkin", 10, 5, "WolfPelt", 10, 5));
				break;
			case "ArmorDrakeT3Legs":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolDrake", 3, 3));
				list.Add(createReq("ArmorDrakeT3Legs", 1, 0));
				list.Add(createReq("FlametalNew", 10, 5));
				list.Add(createReq("BonemawSerpentScale", 10, 5, "SerpentScale", 20, 10));
				break;
			case "ArmorDrakeT1Chest":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 1, 1));
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("Chain", 4, 1));
				list.Add(createReq("DrakeSkin", 10, 5, "WolfPelt", 10, 5));
				break;
			case "ArmorDrakeT2Chest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 2, 2));
				list.Add(createReq("ArmorDrakeT1Chest", 1, 0));
				list.Add(createReq("Carapace", 8, 4));
				list.Add(createReq("Crystal", 10, 5));
				break;
			case "ArmorDrakeT3Chest":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolDrake", 3, 3));
				list.Add(createReq("ArmorDrakeT2Chest", 1, 0));
				list.Add(createReq("FlametalNew", 10, 5));
				list.Add(createReq("BonemawSerpentScale", 10, 5));
				break;
			case "HelmetDrakeT1":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 1, 1));
				list.Add(createReq("TrophyHatchling", 4, 0));
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("Crystal", 10, 5));
				break;
			case "HelmetDrakeT2":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 2, 2));
				list.Add(createReq("HelmetDrakeT1", 1, 0));
				list.Add(createReq("DarkSteel", 8, 4, "Chain", 5));
				list.Add(createReq("SerpentScale", 6, 3));
				break;
			case "HelmetDrakeT3":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolDrake", 3, 3));
				list.Add(createReq("HelmetDrakeT2", 1, 0));
				list.Add(createReq("TrophyBonemawSerpent", 1, 1));
				list.Add(createReq("FlametalNew", 10, 5));
				break;
			case "ArmorRavenT1Legs":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 1, 1));
				list.Add(createReq("BearFur", 6, 2, "DeerHide", 6, 2));
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("Feathers", 30, 15));
				break;
			case "ArmorRavenT2Legs":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 2, 2));
				list.Add(createReq("ArmorRavenT1Legs", 1, 0));
				list.Add(createReq("JuteRed", 10, 5));
				list.Add(createReq("Eitr", 20, 10));
				break;
			case "ArmorRavenT3Legs":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolRaven", 3, 3));
				list.Add(createReq("ArmorRavenT2Legs", 1, 0));
				list.Add(createReq("MushroomSmokePuff", 10, 5));
				list.Add(createReq("FlametalNew", 10, 5));
				break;
			case "ArmorRavenT1Chest":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 1, 1));
				list.Add(createReq("WolfHairBundle", 10, 5, "Feathers", 60));
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("Feathers", 30, 15));
				break;
			case "ArmorRavenT2Chest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 2, 2));
				list.Add(createReq("ArmorRavenT1Chest", 1, 0));
				list.Add(createReq("Crystal", 20, 10));
				list.Add(createReq("Eitr", 20, 10));
				break;
			case "ArmorRavenT3Chest":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolRaven", 3, 3));
				list.Add(createReq("ArmorRavenT2Chest", 1, 0));
				list.Add(createReq("SilkReinforcedThread", 20, 10, "LinenThread", 40, 20));
				list.Add(createReq("FlametalNew", 10, 5));
				break;
			case "HelmetRavenT1":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 1, 1));
				list.Add(createReq("Feathers", 60, 10, "Feathers", 60));
				list.Add(createReq("BlackMetal", 10, 5));
				list.Add(createReq("Ooze", 10, 5));
				break;
			case "HelmetRavenT2":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 2, 2));
				list.Add(createReq("HelmetRavenT1", 1, 0));
				list.Add(createReq("JuteRed", 10, 5));
				list.Add(createReq("MushroomJotunPuffs", 10, 5));
				break;
			case "HelmetRavenT3":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolRaven", 3, 3));
				list.Add(createReq("HelmetRavenT2", 1, 0));
				list.Add(createReq("SilkReinforcedThread", 10, 5, "LinenThread", 20, 10));
				list.Add(createReq("MushroomSmokePuff", 16, 8));
				break;
			case "ArmorWolfT1Legs":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 1, 1));
				list.Add(createReq("WolfPelt", 10, 5));
				list.Add(createReq("BlackMetal", 20, 10));
				list.Add(createReq("Bloodbag", 20, 0));
				break;
			case "ArmorWolfT2Legs":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 2, 2));
				list.Add(createReq("ArmorWolfT1Legs", 1, 0));
				list.Add(createReq("DarkSteel", 18, 9, "Chain", 10));
				list.Add(createReq("GiantBloodSack", 16, 8));
				break;
			case "ArmorWolfT3Legs":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 3, 3));
				list.Add(createReq("ArmorWolfT2Legs", 1, 0));
				list.Add(createReq("CharcoalResin", 30, 15));
				list.Add(createReq("FlametalNew", 20, 10));
				break;
			case "ArmorWolfT1Chest":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 1, 1));
				list.Add(createReq("TrophyWolf", 6, 3));
				list.Add(createReq("BlackMetal", 15, 8));
				list.Add(createReq("JuteRed", 10, 5));
				break;
			case "ArmorWolfT2Chest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 2, 2));
				list.Add(createReq("ArmorWolfT1Chest", 1, 0));
				list.Add(createReq("DarkSteel", 30, 15, "Chain", 15));
				list.Add(createReq("GiantBloodSack", 16, 8));
				break;
			case "ArmorWolfT3Chest":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 3, 3));
				list.Add(createReq("ArmorWolfT2Chest", 1, 0));
				list.Add(createReq("FenringInsygnia", 10, 5, "Chain", 6, 3));
				list.Add(createReq("FlametalNew", 10, 5));
				break;
			case "HelmetWolfT1":
				val.m_craftingStation = FindStation(pieces, "forge");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 1, 1));
				list.Add(createReq("TrophyCultist", 1, 0));
				list.Add(createReq("WolfHairBundle", 10, 5));
				list.Add(createReq("JuteRed", 10, 5));
				break;
			case "HelmetWolfT2":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 2, 2));
				list.Add(createReq("HelmetWolfT1", 1, 0));
				list.Add(createReq("DarkSteel", 20, 10, "Chain", 14));
				list.Add(createReq("GiantBloodSack", 10, 5));
				break;
			case "HelmetWolfT3":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 3, 3));
				list.Add(createReq("HelmetWolfT2", 1, 0));
				list.Add(createReq("MorgenHeart", 10, 5));
				list.Add(createReq("FlametalNew", 10, 5));
				break;
			case "CapeClanDrake":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolDrake", 1, 0));
				list.Add(createReq("TrophyDraugrElite", 1, 1));
				list.Add(createReq("DarkSteel", 3, 1, "Chain", 3));
				list.Add(createReq("WolfPelt", 6, 2));
				break;
			case "CapeClanRaven":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolRaven", 1, 0));
				list.Add(createReq("TrophyDraugrElite", 1, 1));
				list.Add(createReq("DarkSteel", 3, 1, "Chain", 3));
				list.Add(createReq("WolfPelt", 6, 2));
				break;
			case "CapeClanSerpent":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolSerpent", 1, 1));
				list.Add(createReq("TrophyDraugrElite", 1, 1));
				list.Add(createReq("DarkSteel", 3, 1, "Chain", 3));
				list.Add(createReq("WolfPelt", 6, 2));
				break;
			case "CapeClanWolf":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 3;
				list.Add(createReq("SymbolWolf", 1, 1));
				list.Add(createReq("TrophyDraugrElite", 1, 1));
				list.Add(createReq("DarkSteel", 3, 1, "Chain", 3));
				list.Add(createReq("WolfPelt", 6, 2));
				break;
			case "ClanDrakeAxe":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolDrake", 2, 2));
				list.Add(createReq("FlametalNew", 30, 10));
				list.Add(createReq("Ruby", 6, 1));
				list.Add(createReq("Crystal", 20, 10));
				break;
			case "ClanSerpentSpear":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolSerpent", 2, 2));
				list.Add(createReq("FlametalNew", 20, 7));
				list.Add(createReq("Ruby", 5, 1));
				list.Add(createReq("SerpentScale", 10, 5));
				break;
			case "ClanRavenStaff":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolRaven", 2, 2));
				list.Add(createReq("FlametalNew", 30, 15));
				list.Add(createReq("Ruby", 7, 1));
				list.Add(createReq("ThunderGland", 18, 9, "Thunderstone", 10, 5));
				break;
			case "ClanWolfSword":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 2, 2));
				list.Add(createReq("FlametalNew", 30, 15));
				list.Add(createReq("Ruby", 8, 2));
				list.Add(createReq("Iron", 10, 5));
				break;
			case "ArmorClanDrakeChest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolDrake", 1, 0));
				list.Add(createReq("Bronze", 20, 10));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "ArmorClanRavenChest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolRaven", 1, 0));
				list.Add(createReq("Bronze", 20, 10));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "ArmorClanSerpentChest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolSerpent", 1, 0));
				list.Add(createReq("Bronze", 20, 10));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "ArmorClanWolfChest":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 1, 0));
				list.Add(createReq("Bronze", 20, 10));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "ArmorClanLegs":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 1, 0));
				list.Add(createReq("Bronze", 10, 5));
				list.Add(createReq("LeatherScraps", 10, 5));
				list.Add(createReq("BearFur", 10, 2, "DeerHide", 10, 2));
				break;
			case "HelmetClanDrake":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolDrake", 1, 0));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("BearFur", 10, 2, "DeerHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "HelmetClanSerpent":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolSerpent", 1, 0));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("BearFur", 10, 2, "DeerHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "HelmetClanRaven":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolRaven", 1, 0));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("BearFur", 10, 2, "DeerHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "HelmetClanWolf":
				val.m_craftingStation = FindStation(pieces, "piece_workbench");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 1, 0));
				list.Add(createReq("TrollHide", 10, 2));
				list.Add(createReq("BearFur", 10, 2, "DeerHide", 10, 2));
				list.Add(createReq("LeatherScraps", 10, 5));
				break;
			case "CapeFeatherDrake":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolDrake", 1, 0));
				list.Add(createReq("Feathers", 10, 0));
				list.Add(createReq("ScaleHide", 5, 2));
				list.Add(createReq("Eitr", 20, 0));
				break;
			case "CapeFeatherSerpent":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolSerpent", 1, 0));
				list.Add(createReq("Feathers", 10, 0));
				list.Add(createReq("ScaleHide", 5, 2));
				list.Add(createReq("Eitr", 20, 0));
				break;
			case "CapeFeatherReaven":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolRaven", 1, 0));
				list.Add(createReq("Feathers", 10, 0));
				list.Add(createReq("ScaleHide", 5, 2));
				list.Add(createReq("Eitr", 20, 0));
				break;
			case "CapeFeatherWolf":
				val.m_craftingStation = FindStation(pieces, "blackforge");
				val.m_minStationLevel = 1;
				list.Add(createReq("SymbolWolf", 1, 0));
				list.Add(createReq("Feathers", 10, 0));
				list.Add(createReq("ScaleHide", 5, 2));
				list.Add(createReq("Eitr", 20, 0));
				break;
			}
			val.m_amount = 1;
			val.m_repairStation = val.m_craftingStation;
			val.m_resources = list.ToArray();
			return val;
		}

		private bool isItemOnTheList(string name)
		{
			return Launch.prefabNames.Contains(name);
		}

		public void setupPieces(List<GameObject> pieces, List<GameObject> prefabs)
		{
			items = prefabs;
			foreach (GameObject piece in pieces)
			{
				createPieceRecipe(piece, prefabs);
			}
		}

		private void createPieceRecipe(GameObject gameObject, List<GameObject> prefabs)
		{
			Piece component = gameObject.gameObject.GetComponent<Piece>();
			if (!((Object)(object)component == (Object)null))
			{
				List<Requirement> list = new List<Requirement>();
				switch (((Object)component).name)
				{
				case "piece_banner_drakes":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolDrake", 1, 0));
					list.Add(createReq("Wood", 3, 0));
					list.Add(createReq("LeatherScraps", 2, 0));
					list.Add(createReq("BoneFragments", 3, 0));
					component.m_resources = list.ToArray();
					break;
				case "piece_banner_serpents":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolSerpent", 1, 0));
					list.Add(createReq("Wood", 3, 0));
					list.Add(createReq("LeatherScraps", 2, 0));
					list.Add(createReq("BoneFragments", 3, 0));
					component.m_resources = list.ToArray();
					break;
				case "piece_banner_ravens":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolRaven", 1, 0));
					list.Add(createReq("Wood", 3, 0));
					list.Add(createReq("LeatherScraps", 2, 0));
					list.Add(createReq("BoneFragments", 3, 0));
					component.m_resources = list.ToArray();
					break;
				case "piece_banner_wolfs":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolWolf", 1, 0));
					list.Add(createReq("Wood", 3, 0));
					list.Add(createReq("LeatherScraps", 2, 0));
					list.Add(createReq("BoneFragments", 3, 0));
					component.m_resources = list.ToArray();
					break;
				case "carpetClanDrake":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolDrake", 1, 0));
					list.Add(createReq("LinenThread", 7, 0));
					list.Add(createReq("Dandelion", 4, 0));
					list.Add(createReq("Coal", 2, 0));
					break;
				case "carpetClanSerpent":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolSerpent", 1, 0));
					list.Add(createReq("LinenThread", 7, 0));
					list.Add(createReq("Dandelion", 4, 0));
					list.Add(createReq("Coal", 2, 0));
					component.m_resources = list.ToArray();
					break;
				case "carpetClanRaven":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolRaven", 1, 0));
					list.Add(createReq("LinenThread", 7, 0));
					list.Add(createReq("Dandelion", 4, 0));
					list.Add(createReq("Coal", 2, 0));
					component.m_resources = list.ToArray();
					break;
				case "carpetClanWolf":
					component.m_craftingStation = FindStation(prefabs, "piece_workbench");
					list.Add(createReq("SymbolWolf", 1, 0));
					list.Add(createReq("LinenThread", 7, 0));
					list.Add(createReq("Dandelion", 4, 0));
					list.Add(createReq("Coal", 2, 0));
					component.m_resources = list.ToArray();
					break;
				}
			}
		}

		private CraftingStation FindStation(List<GameObject> list, string name)
		{
			GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val != (Object)null)
			{
				return val.GetComponent<CraftingStation>();
			}
			return null;
		}

		private Requirement createReq(string name, int amount, int amountPerLevel, string altItem = "", int altAmount = 0, int altAmountPerLevel = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			Requirement val = new Requirement();
			val.m_recover = true;
			GameObject val2 = items.Find((GameObject x) => ((Object)x).name == name);
			if ((Object)(object)val2 != (Object)null)
			{
				ItemDrop component = val2.GetComponent<ItemDrop>();
				val.m_amount = amount;
				val.m_amountPerLevel = amountPerLevel;
				val.m_resItem = component;
			}
			else
			{
				val2 = items.Find((GameObject x) => ((Object)x).name == altItem);
				ItemDrop component2 = val2.GetComponent<ItemDrop>();
				val.m_amount = altAmount;
				val.m_amountPerLevel = altAmountPerLevel;
				val.m_resItem = component2;
			}
			return val;
		}
	}
	public class ShaderReplacment
	{
		public static List<GameObject> prefabsToReplaceShader = new List<GameObject>();

		public static List<Material> materialsInPrefabs = new List<Material>();

		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 static List<Shader> shaders = new List<Shader>();

		private static readonly HashSet<Shader> CachedShaders = new HashSet<Shader>();

		public static bool debug = true;

		public static Shader findShader(string name)
		{
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			if (array.Length == 0)
			{
				Debug.LogWarning((object)"SHADER LIST IS EMPTY!");
				return null;
			}
			if (debug)
			{
			}
			return shaders.Find((Shader x) => ((Object)x).name == name);
		}

		public static Shader GetShaderByName(string name)
		{
			return shaders.Find((Shader x) => ((Object)x).name == name.Trim());
		}

		public static void debugShaderList(List<Shader> shadersRes)
		{
			foreach (Shader shadersRe in shadersRes)
			{
				Debug.LogWarning((object)("SHADER NAME IS: " + ((Object)shadersRe).name));
			}
			debug = false;
		}

		public static void Replace(GameObject gameObject)
		{
			prefabsToReplaceShader.Add(gameObject);
			GetMaterialsInPrefab(gameObject);
		}

		public static void GetMaterialsInPrefab(GameObject gameObject)
		{
			Renderer[] componentsInChildren = gameObject.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = sharedMaterials;
				foreach (Material val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						materialsInPrefabs.Add(val2);
					}
				}
			}
		}

		public static void getMeShaders()
		{
			AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
			AssetBundle[] array2 = array;
			foreach (AssetBundle val in array2)
			{
				IEnumerable<Shader> enumerable3;
				try
				{
					IEnumerable<Shader> enumerable2;
					if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
					{
						IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
						enumerable2 = enumerable;
					}
					else
					{
						enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
							where (Object)(object)shader != (Object)null
							select shader;
					}
					enumerable3 = enumerable2;
				}
				catch (Exception)
				{
					continue;
				}
				if (enumerable3 == null)
				{
					continue;
				}
				foreach (Shader item in enumerable3)
				{
					CachedShaders.Add(item);
				}
			}
		}

		public static void runMaterialFix()
		{
			getMeShaders();
			shaders.AddRange(CachedShaders);
			foreach (Material materialsInPrefab in materialsInPrefabs)
			{
				Shader shader = materialsInPrefab.shader;
				if (!((Object)(object)shader == (Object)null))
				{
					string name = ((Object)shader).name;
					if (!(name == "Standard") && name.Contains("Balrond"))
					{
						setProperValue(materialsInPrefab, name);
					}
				}
			}
		}

		private static void setProperValue(Material material, string shaderName)
		{
			string name = shaderName.Replace("Balrond", "Custom");
			name = checkNaming(name);
			Shader shaderByName = GetShaderByName(name);
			if ((Object)(object)shaderByName == (Object)null)
			{
				Debug.LogWarning((object)("Shader not found " + name));
			}
			else
			{
				material.shader = shaderByName;
			}
		}

		private static 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 EotenasClans.Properties
{
	[GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.4.0.0")]
	[CompilerGenerated]
	internal sealed class Settings : ApplicationSettingsBase
	{
		private static Settings defaultInstance = (Settings)(object)SettingsBase.Synchronized((SettingsBase)(object)new Settings());

		public static Settings Default => defaultInstance;
	}
}