using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
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 BalrondFurRandomizer;

public class FxReplacment
{
	private List<GameObject> allPrefabs;

	private string projectName = "[BalrondFurRandomizer]";

	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 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 void ReplaceMaterial(Material material)
	{
		if ((Object)(object)material == (Object)null)
		{
			Debug.LogWarning((object)"Material is empty !");
		}
		else
		{
			materialsInPrefabs.Add(material);
		}
	}

	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)
		{
			if ((Object)(object)materialsInPrefab == (Object)null)
			{
				Debug.Log((object)"I had a null in list");
				continue;
			}
			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;
	}
}
public class BaseLevelEffectSetupValue
{
	public float scale = 1.1f;

	public float saturation = 0.5f;

	public float hue = -0.1f;

	public float value = -0.1f;

	public LevelSetup setup = null;

	public GameObject enabledObject = null;

	public GameObject enabledObjectLevel2 = null;

	public GameObject enabledObjectLevel3 = null;

	public bool setEmmisive = false;

	public Color emissive = Color.white;

	public float sumValue = 0.05f;

	public void getSetup(LevelEffects levelEffects)
	{
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)levelEffects == (Object)null)
		{
			Debug.LogWarning((object)"I should not be here i am null");
			return;
		}
		int num = 0;
		if (levelEffects.m_levelSetups != null && levelEffects.m_levelSetups.Count > 0)
		{
			num = levelEffects.m_levelSetups.Count;
			setup = levelEffects.m_levelSetups.Last();
		}
		if (num != 0 && setup != null)
		{
			scale = setup.m_scale;
			saturation = setup.m_saturation;
			hue = setup.m_hue;
			value = setup.m_value;
			enabledObject = setup.m_enableObject;
			emissive = setup.m_emissiveColor;
			setEmmisive = setup.m_setEmissiveColor;
			enabledObjectLevel2 = enabledObject;
			enabledObjectLevel3 = enabledObject;
		}
		else
		{
			setValues(num, levelEffects);
		}
		if ((Object)(object)levelEffects.m_character != (Object)null)
		{
			if (((Object)((Component)levelEffects.m_character).gameObject).name == "Deer")
			{
				EditDeer(levelEffects);
			}
			if (((Object)((Component)levelEffects.m_character).gameObject).name == "Boar")
			{
				EditBoar(levelEffects);
			}
		}
	}

	private void EditDeer(LevelEffects levelEffects)
	{
		GameObject enableObject = levelEffects.m_levelSetups[0].m_enableObject;
		GameObject enableObject2 = levelEffects.m_levelSetups[1].m_enableObject;
		enabledObjectLevel2 = enableObject;
		enabledObjectLevel3 = enableObject2;
		Transform parent = enableObject.transform.parent;
		GameObject enableObject3 = (enabledObject = ((Component)parent.Find("Antler1")).gameObject);
		levelEffects.m_levelSetups[0].m_enableObject = enableObject3;
		levelEffects.m_levelSetups[1].m_enableObject = enableObject3;
	}

	private void EditBoar(LevelEffects gameObject)
	{
	}

	private void setValues(int levels, LevelEffects levelEffects)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		float y = ((Component)levelEffects).transform.localScale.y;
		if (levels == 0)
		{
			scale = y;
			saturation = 0f;
			hue = 0f;
			value = 0f;
		}
		if (levels == 1)
		{
			scale = y + 0.05f;
			saturation = 0.5f;
			hue = -0.05f;
			value = -0.05f;
		}
		if (levels == 2)
		{
			scale = y + 0.1f;
			saturation = 0.5f;
			hue = -0.1f;
			value = -0.1f;
		}
	}
}
public class ItemSetBuilder
{
	public List<ItemSet> itemSets = new List<ItemSet>();

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

	public ModResourceLoader modResourceLoader;

	public static readonly List<MaterialPack> materialPacks = new List<MaterialPack>();

	public void Setup(List<GameObject> prefabs)
	{
		this.prefabs = prefabs ?? new List<GameObject>();
	}

	public void CreateMaterialPacks(ModResourceLoader loader)
	{
		if (loader == null)
		{
			Debug.LogWarning((object)"ModResourceLoader is null");
			return;
		}
		modResourceLoader = loader;
		if (materialPacks.Count <= 0)
		{
			BuildPack(loader.loxFace_Default, loader.loxtBody_Default, loader.loxFur_Default, "Lox", "Default");
			BuildPack(loader.loxFace_Albino, loader.loxtBody_Albino, loader.loxFur_Albino, "Lox", "Albino");
			BuildPack(loader.loxFace_Black, loader.loxtBody_Black, loader.loxFur_Black, "Lox", "Black");
			BuildPack(loader.loxFace_Blond, loader.loxtBody_Blond, loader.loxFur_Blond, "Lox", "Blond");
			BuildPack(loader.loxFace_DarkBrown, loader.loxtBody_DarkBrown, loader.loxFur_DarkBrown, "Lox", "Brown");
			BuildPack(loader.loxFace_Ginger, loader.loxtBody_Ginger, loader.loxFur_Ginger, "Lox", "Ginger");
			BuildPack(loader.wolfBody_Default, loader.wolfBody_Default, loader.wolfBody_Default, "Wolf", "Default");
			BuildPack(loader.wolfBody_Albino, loader.wolfBody_Albino, loader.wolfBody_Albino, "Wolf", "Albino");
			BuildPack(loader.wolfBody_Black, loader.wolfBody_Black, loader.wolfBody_Black, "Wolf", "Black");
			BuildPack(loader.wolfBody_DarkBrown, loader.wolfBody_DarkBrown, loader.wolfBody_DarkBrown, "Wolf", "Brown");
			BuildPack(loader.wolfBody_Grey, loader.wolfBody_Grey, loader.wolfBody_Grey, "Wolf", "Grey");
			BuildPack(loader.deerBody_Default, loader.deerBody_Default, loader.deerBody_Default, "Deer", "Default");
			BuildPack(loader.deerBody_Albino, loader.deerBody_Albino, loader.deerBody_Albino, "Deer", "Albino");
			BuildPack(loader.deerBody_Red, loader.deerBody_Red, loader.deerBody_Red, "Deer", "Red");
			BuildPack(loader.deerBody_DarkBrown, loader.deerBody_DarkBrown, loader.deerBody_DarkBrown, "Deer", "Brown");
			BuildPack(loader.deerBody_Grey, loader.deerBody_Grey, loader.deerBody_Grey, "Deer", "Grey");
			BuildPack(loader.boarBody_Default, loader.boarBody_Default, loader.boarBody_Default, "Boar", "Default");
			BuildPack(loader.boarBody_Grey, loader.boarBody_Grey, loader.boarBody_Grey, "Boar", "Grey");
			BuildPack(loader.boarBody_Black, loader.boarBody_Black, loader.boarBody_Black, "Boar", "Black");
			BuildPack(loader.boarBody_DarkBrown, loader.boarBody_DarkBrown, loader.boarBody_DarkBrown, "Boar", "Brown");
			BuildPack(loader.boarBody_LightBrown, loader.boarBody_LightBrown, loader.boarBody_LightBrown, "Boar", "Brown2");
			BuildPack(loader.neckBody_Default, loader.neckBody_Default, loader.neckBody_Default, "Neck", "Default");
			BuildPack(loader.neckBody_Albino, loader.neckBody_Albino, loader.neckBody_Albino, "Neck", "Albino");
			BuildPack(loader.neckBody_DarkBlue, loader.neckBody_DarkBlue, loader.neckBody_DarkBlue, "Neck", "Dark");
			BuildPack(loader.neckBody_DarkGreen, loader.neckBody_DarkGreen, loader.neckBody_DarkGreen, "Neck", "Green");
			BuildPack(loader.neckBody_Blue, loader.neckBody_Blue, loader.neckBody_Blue, "Neck", "Blue");
			BuildPack(loader.askvinBody_Default, loader.askvinBody_Default, loader.askvinBody_Default, "Asksvin", "Default");
			BuildPack(loader.askvinBody_Albino, loader.askvinBody_Albino, loader.askvinBody_Albino, "Asksvin", "Albino");
			BuildPack(loader.askvinBody_Black, loader.askvinBody_Black, loader.askvinBody_Black, "Asksvin", "Dark");
			BuildPack(loader.askvinBody_Purple, loader.askvinBody_Purple, loader.askvinBody_Purple, "Asksvin", "Purple");
			BuildPack(loader.askvinBody_Grey, loader.askvinBody_Grey, loader.askvinBody_Grey, "Asksvin", "Grey");
			BuildPack(loader.hareBody_Default, loader.hareBody_Default, loader.hareBody_Default, "Hare", "Default");
			BuildPack(loader.hareBody_Albino, loader.hareBody_Albino, loader.hareBody_Albino, "Hare", "Albino");
			BuildPack(loader.hareBody_Black, loader.hareBody_Black, loader.hareBody_Black, "Hare", "Black");
			BuildPack(loader.hareBody_DarkBlue, loader.hareBody_DarkBlue, loader.hareBody_DarkBlue, "Hare", "Blue");
			BuildPack(loader.hareBody_Ginger, loader.hareBody_Ginger, loader.hareBody_Ginger, "Hare", "Ginger");
			BuildPack(loader.drakeBody_Default, loader.drakeBody_Default, loader.drakeBody_Default, "Hatchling", "Default");
			BuildPack(loader.drakeBody_Red, loader.drakeBody_Red, loader.drakeBody_Red, "Hatchling", "Albino");
			BuildPack(loader.drakeBody_DarkBlue, loader.drakeBody_DarkBlue, loader.drakeBody_DarkBlue, "Hatchling", "Blue");
			BuildPack(loader.drakeBody_IceBlue, loader.drakeBody_IceBlue, loader.drakeBody_IceBlue, "Hatchling", "Ice");
			BuildPack(loader.drakeBody_Purple, loader.drakeBody_Purple, loader.drakeBody_Purple, "Hatchling", "Purple");
			BuildPack(loader.serpentBody_Default, loader.serpentBody_Default, loader.serpentBody_Default, "Serpent", "Default");
			BuildPack(loader.serpentBody_Albino, loader.serpentBody_Albino, loader.serpentBody_Albino, "Serpent", "Albino");
			BuildPack(loader.serpentBody_Black, loader.serpentBody_Black, loader.serpentBody_Black, "Serpent", "Black");
			BuildPack(loader.serpentBody_Blue, loader.serpentBody_Blue, loader.serpentBody_Blue, "Serpent", "Blue");
			BuildPack(loader.serpentBody_Green, loader.serpentBody_Green, loader.serpentBody_Green, "Serpent", "Green");
			BuildPack(loader.serpentBody_Red, loader.serpentBody_Red, loader.serpentBody_Red, "Serpent", "Red");
		}
	}

	private void BuildPack(Material face, Material body, Material body2, string name, string skin)
	{
		if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)body2 == (Object)null)
		{
			Debug.LogWarning((object)("Skipping null material pack: " + name + " / " + skin));
		}
		else
		{
			materialPacks.Add(new MaterialPack(face, body, body2, name, skin));
		}
	}

	public void SetupFurRandomizerForMonster(GameObject monster)
	{
		if ((Object)(object)monster == (Object)null)
		{
			Debug.LogWarning((object)"Monster not found");
		}
		else if ((Object)(object)monster.GetComponent<FurRandomizer>() == (Object)null)
		{
			monster.AddComponent<FurRandomizer>();
		}
	}
}
[Serializable]
public class FurRandomizer : MonoBehaviour
{
	private static readonly string[] ModelsToChange = new string[9] { "Wolf", "Lox", "Serpent", "Neck", "Hatchling", "Hare", "Boar", "Deer", "Asksvin" };

	private ZNetView m_zview;

	private MonsterAI m_monsterAI;

	private AnimalAI m_animalAI;

	private Humanoid m_humanoid;

	public List<MaterialPack> m_materials = new List<MaterialPack>();

	private string skinName;

	private MaterialPack m_materialPack;

	public SkinnedMeshRenderer face;

	public SkinnedMeshRenderer body;

	public SkinnedMeshRenderer fur;

	public static ModResourceLoader modResourceLoader = Launch.modResourceLoader;

	private readonly List<MaterialPack> materialPacks = ItemSetBuilder.materialPacks;

	private const string ZdoSetKey = "furRandomizerSet";

	private const string ZdoActiveKey = "furRandomizerSetActive";

	private void Awake()
	{
		if (!ValidatePrefab())
		{
			Debug.LogWarning((object)("I should not be randomized: " + ((Object)((Component)this).gameObject).name));
			return;
		}
		if (modResourceLoader == null)
		{
			Debug.LogWarning((object)"ModResourceLoader is null");
			return;
		}
		if ((Object)(object)modResourceLoader.drakeBody_DarkBlue == (Object)null)
		{
			Debug.LogWarning((object)"Nothing loaded");
		}
		m_zview = ((Component)this).GetComponent<ZNetView>();
		m_monsterAI = ((Component)this).GetComponent<MonsterAI>();
		m_animalAI = ((Component)this).GetComponent<AnimalAI>();
		m_humanoid = ((Component)this).GetComponent<Humanoid>();
		if ((Object)(object)m_zview == (Object)null || m_zview.m_zdo == null)
		{
			Debug.LogWarning((object)("Missing ZNetView or ZDO on " + ((Object)((Component)this).gameObject).name));
			return;
		}
		CreateMaterialPacksOnce();
		if (SetupFurRandomizerForMonster())
		{
			if (m_materials == null || m_materials.Count == 0)
			{
				Debug.LogWarning((object)("Material list is empty for " + ((Object)((Component)this).gameObject).name));
				return;
			}
			bool @bool = m_zview.m_zdo.GetBool("furRandomizerSetActive", false);
			PickRandomSet(@bool);
		}
	}

	private bool ValidatePrefab()
	{
		string value = EditZnetName(((Object)((Component)this).gameObject).name);
		return ModelsToChange.Contains(value);
	}

	private string EditZnetName(string name)
	{
		name = name.Replace("(Clone)", "");
		int num = name.IndexOf("(");
		if (num >= 0)
		{
			name = name.Substring(0, num);
		}
		return name.Trim();
	}

	private void PickRandomSet(bool chosen = false)
	{
		if (m_materials == null || m_materials.Count == 0)
		{
			Debug.LogWarning((object)("No material packs available for " + ((Object)((Component)this).gameObject).name));
			return;
		}
		int num = -1;
		if (chosen)
		{
			num = m_zview.m_zdo.GetInt("furRandomizerSet", 0);
		}
		if (!chosen || num < 0 || num >= m_materials.Count)
		{
			num = Random.Range(0, m_materials.Count);
		}
		m_zview.m_zdo.Set("furRandomizerSet", num);
		m_zview.m_zdo.Set("furRandomizerSetActive", true);
		MaterialPack materialPack = m_materials[num];
		skinName = materialPack.skin;
		m_materialPack = materialPack;
		SetSkin(materialPack);
	}

	private void SetSkin(MaterialPack pack)
	{
		switch (EditZnetName(((Object)((Component)this).gameObject).name))
		{
		case "Lox":
			ApplyLoxMaterials(pack);
			break;
		case "Hare":
		case "Serpent":
		case "Neck":
		case "Wolf":
		case "Boar":
		case "Deer":
		case "Asksvin":
			ApplySingleRendererMaterial(body, pack.face);
			break;
		case "Hatchling":
			ApplyHatchlingMaterials(pack);
			break;
		}
	}

	private void ApplyLoxMaterials(MaterialPack pack)
	{
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Expected O, but got Unknown
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Expected O, but got Unknown
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Expected O, but got Unknown
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Expected O, but got Unknown
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Expected O, but got Unknown
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Expected O, but got Unknown
		if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)fur == (Object)null)
		{
			Debug.LogWarning((object)("Lox renderers missing on " + ((Object)((Component)this).gameObject).name));
			return;
		}
		Material[] materials = ((Renderer)face).materials;
		if (materials.Length != 0)
		{
			materials[0] = new Material(pack.body);
			((Renderer)face).materials = materials;
		}
		Material[] materials2 = ((Renderer)body).materials;
		if (materials2.Length != 0)
		{
			materials2[0] = new Material(pack.body);
			((Renderer)body).materials = materials2;
		}
		Material[] materials3 = ((Renderer)fur).materials;
		if (materials3.Length != 0)
		{
			materials3[0] = new Material(pack.body2);
			((Renderer)fur).materials = materials3;
		}
		Material[] sharedMaterials = ((Renderer)face).sharedMaterials;
		if (sharedMaterials.Length > 1)
		{
			sharedMaterials[1] = new Material(pack.face);
			((Renderer)face).sharedMaterials = sharedMaterials;
		}
		Material[] sharedMaterials2 = ((Renderer)body).sharedMaterials;
		if (sharedMaterials2.Length != 0)
		{
			sharedMaterials2[0] = new Material(pack.body);
			((Renderer)body).sharedMaterials = sharedMaterials2;
		}
		Material[] sharedMaterials3 = ((Renderer)fur).sharedMaterials;
		if (sharedMaterials3.Length != 0)
		{
			sharedMaterials3[0] = new Material(pack.body2);
			((Renderer)fur).sharedMaterials = sharedMaterials3;
		}
	}

	private void ApplyHatchlingMaterials(MaterialPack pack)
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Expected O, but got Unknown
		if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)fur == (Object)null)
		{
			Debug.LogWarning((object)("Hatchling renderers missing on " + ((Object)((Component)this).gameObject).name));
			return;
		}
		Material[] materials = ((Renderer)face).materials;
		if (materials.Length != 0)
		{
			materials[0] = new Material(pack.body);
		}
		((Renderer)face).materials = materials;
		((Renderer)body).materials = materials;
		((Renderer)fur).materials = materials;
		((Renderer)face).sharedMaterials = materials;
		((Renderer)body).sharedMaterials = materials;
		((Renderer)fur).sharedMaterials = materials;
	}

	private void ApplySingleRendererMaterial(SkinnedMeshRenderer renderer, Material source)
	{
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Expected O, but got Unknown
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Expected O, but got Unknown
		if ((Object)(object)renderer == (Object)null || (Object)(object)source == (Object)null)
		{
			Debug.LogWarning((object)("Renderer or source material missing on " + ((Object)((Component)this).gameObject).name));
			return;
		}
		((Renderer)renderer).sharedMaterial = new Material(source);
		((Renderer)renderer).material = new Material(source);
	}

	private void CreateMaterialPacksOnce()
	{
		if (materialPacks == null)
		{
			Debug.LogWarning((object)"materialPacks list is null");
		}
		else if (materialPacks.Count <= 0)
		{
			BuildPack(modResourceLoader.loxFace_Default, modResourceLoader.loxtBody_Default, modResourceLoader.loxFur_Default, "Lox", "Default");
			BuildPack(modResourceLoader.loxFace_Albino, modResourceLoader.loxtBody_Albino, modResourceLoader.loxFur_Albino, "Lox", "Albino");
			BuildPack(modResourceLoader.loxFace_Black, modResourceLoader.loxtBody_Black, modResourceLoader.loxFur_Black, "Lox", "Black");
			BuildPack(modResourceLoader.loxFace_Blond, modResourceLoader.loxtBody_Blond, modResourceLoader.loxFur_Blond, "Lox", "Blond");
			BuildPack(modResourceLoader.loxFace_DarkBrown, modResourceLoader.loxtBody_DarkBrown, modResourceLoader.loxFur_DarkBrown, "Lox", "Brown");
			BuildPack(modResourceLoader.loxFace_Ginger, modResourceLoader.loxtBody_Ginger, modResourceLoader.loxFur_Ginger, "Lox", "Ginger");
			BuildPack(modResourceLoader.wolfBody_Default, modResourceLoader.wolfBody_Default, modResourceLoader.wolfBody_Default, "Wolf", "Default");
			BuildPack(modResourceLoader.wolfBody_Albino, modResourceLoader.wolfBody_Albino, modResourceLoader.wolfBody_Albino, "Wolf", "Albino");
			BuildPack(modResourceLoader.wolfBody_Black, modResourceLoader.wolfBody_Black, modResourceLoader.wolfBody_Black, "Wolf", "Black");
			BuildPack(modResourceLoader.wolfBody_DarkBrown, modResourceLoader.wolfBody_DarkBrown, modResourceLoader.wolfBody_DarkBrown, "Wolf", "Brown");
			BuildPack(modResourceLoader.wolfBody_Grey, modResourceLoader.wolfBody_Grey, modResourceLoader.wolfBody_Grey, "Wolf", "Grey");
			BuildPack(modResourceLoader.neckBody_Default, modResourceLoader.neckBody_Default, modResourceLoader.neckBody_Default, "Neck", "Default");
			BuildPack(modResourceLoader.neckBody_Albino, modResourceLoader.neckBody_Albino, modResourceLoader.neckBody_Albino, "Neck", "Albino");
			BuildPack(modResourceLoader.neckBody_DarkBlue, modResourceLoader.neckBody_DarkBlue, modResourceLoader.neckBody_DarkBlue, "Neck", "Dark");
			BuildPack(modResourceLoader.neckBody_DarkGreen, modResourceLoader.neckBody_DarkGreen, modResourceLoader.neckBody_DarkGreen, "Neck", "Green");
			BuildPack(modResourceLoader.neckBody_Blue, modResourceLoader.neckBody_Blue, modResourceLoader.neckBody_Blue, "Neck", "Blue");
			BuildPack(modResourceLoader.hareBody_Default, modResourceLoader.hareBody_Default, modResourceLoader.hareBody_Default, "Hare", "Default");
			BuildPack(modResourceLoader.hareBody_Albino, modResourceLoader.hareBody_Albino, modResourceLoader.hareBody_Albino, "Hare", "Albino");
			BuildPack(modResourceLoader.hareBody_Black, modResourceLoader.hareBody_Black, modResourceLoader.hareBody_Black, "Hare", "Black");
			BuildPack(modResourceLoader.hareBody_DarkBlue, modResourceLoader.hareBody_DarkBlue, modResourceLoader.hareBody_DarkBlue, "Hare", "Blue");
			BuildPack(modResourceLoader.hareBody_Ginger, modResourceLoader.hareBody_Ginger, modResourceLoader.hareBody_Ginger, "Hare", "Ginger");
			BuildPack(modResourceLoader.drakeBody_Default, modResourceLoader.drakeBody_Default, modResourceLoader.drakeBody_Default, "Hatchling", "Default");
			BuildPack(modResourceLoader.drakeBody_Red, modResourceLoader.drakeBody_Red, modResourceLoader.drakeBody_Red, "Hatchling", "Albino");
			BuildPack(modResourceLoader.drakeBody_DarkBlue, modResourceLoader.drakeBody_DarkBlue, modResourceLoader.drakeBody_DarkBlue, "Hatchling", "Blue");
			BuildPack(modResourceLoader.drakeBody_IceBlue, modResourceLoader.drakeBody_IceBlue, modResourceLoader.drakeBody_IceBlue, "Hatchling", "Ice");
			BuildPack(modResourceLoader.drakeBody_Purple, modResourceLoader.drakeBody_Purple, modResourceLoader.drakeBody_Purple, "Hatchling", "Purple");
			BuildPack(modResourceLoader.serpentBody_Default, modResourceLoader.serpentBody_Default, modResourceLoader.serpentBody_Default, "Serpent", "Default");
			BuildPack(modResourceLoader.serpentBody_Albino, modResourceLoader.serpentBody_Albino, modResourceLoader.serpentBody_Albino, "Serpent", "Albino");
			BuildPack(modResourceLoader.serpentBody_Black, modResourceLoader.serpentBody_Black, modResourceLoader.serpentBody_Black, "Serpent", "Black");
			BuildPack(modResourceLoader.serpentBody_Blue, modResourceLoader.serpentBody_Blue, modResourceLoader.serpentBody_Blue, "Serpent", "Blue");
			BuildPack(modResourceLoader.serpentBody_Green, modResourceLoader.serpentBody_Green, modResourceLoader.serpentBody_Green, "Serpent", "Green");
			BuildPack(modResourceLoader.serpentBody_Red, modResourceLoader.serpentBody_Red, modResourceLoader.serpentBody_Red, "Serpent", "Red");
			BuildPack(modResourceLoader.askvinBody_Default, modResourceLoader.askvinBody_Default, modResourceLoader.askvinBody_Default, "Asksvin", "Default");
			BuildPack(modResourceLoader.askvinBody_Albino, modResourceLoader.askvinBody_Albino, modResourceLoader.askvinBody_Albino, "Asksvin", "Albino");
			BuildPack(modResourceLoader.askvinBody_Black, modResourceLoader.askvinBody_Black, modResourceLoader.askvinBody_Black, "Asksvin", "Dark");
			BuildPack(modResourceLoader.askvinBody_Purple, modResourceLoader.askvinBody_Purple, modResourceLoader.askvinBody_Purple, "Asksvin", "Purple");
			BuildPack(modResourceLoader.askvinBody_Grey, modResourceLoader.askvinBody_Grey, modResourceLoader.askvinBody_Grey, "Asksvin", "Grey");
			BuildPack(modResourceLoader.deerBody_Default, modResourceLoader.deerBody_Default, modResourceLoader.deerBody_Default, "Deer", "Default");
			BuildPack(modResourceLoader.deerBody_Albino, modResourceLoader.deerBody_Albino, modResourceLoader.deerBody_Albino, "Deer", "Albino");
			BuildPack(modResourceLoader.deerBody_Red, modResourceLoader.deerBody_Red, modResourceLoader.deerBody_Red, "Deer", "Red");
			BuildPack(modResourceLoader.deerBody_DarkBrown, modResourceLoader.deerBody_DarkBrown, modResourceLoader.deerBody_DarkBrown, "Deer", "Brown");
			BuildPack(modResourceLoader.deerBody_Grey, modResourceLoader.deerBody_Grey, modResourceLoader.deerBody_Grey, "Deer", "Grey");
			BuildPack(modResourceLoader.boarBody_Default, modResourceLoader.boarBody_Default, modResourceLoader.boarBody_Default, "Boar", "Default");
			BuildPack(modResourceLoader.boarBody_Grey, modResourceLoader.boarBody_Grey, modResourceLoader.boarBody_Grey, "Boar", "Grey");
			BuildPack(modResourceLoader.boarBody_Black, modResourceLoader.boarBody_Black, modResourceLoader.boarBody_Black, "Boar", "Black");
			BuildPack(modResourceLoader.boarBody_DarkBrown, modResourceLoader.boarBody_DarkBrown, modResourceLoader.boarBody_DarkBrown, "Boar", "Brown");
			BuildPack(modResourceLoader.boarBody_LightBrown, modResourceLoader.boarBody_LightBrown, modResourceLoader.boarBody_LightBrown, "Boar", "Brown2");
		}
	}

	private void BuildPack(Material face, Material body, Material body2, string name, string skin)
	{
		if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)body2 == (Object)null)
		{
			Debug.LogWarning((object)("Skipping null material pack: " + name + " / " + skin));
		}
		else
		{
			materialPacks.Add(new MaterialPack(face, body, body2, name, skin));
		}
	}

	private bool SetupFurRandomizerForMonster()
	{
		string name = EditZnetName(((Object)((Component)this).gameObject).name);
		m_materials = materialPacks.FindAll((MaterialPack x) => x.animal == name);
		switch (name)
		{
		case "Lox":
		{
			Transform[] componentsInChildren4 = ((Component)this).gameObject.GetComponentsInChildren<Transform>(true);
			foreach (Transform val4 in componentsInChildren4)
			{
				if (((Object)((Component)val4).gameObject).name == "Body")
				{
					SkinnedMeshRenderer component4 = ((Component)val4).GetComponent<SkinnedMeshRenderer>();
					if ((Object)(object)component4 != (Object)null)
					{
						face = component4;
						body = component4;
					}
				}
				else if (((Object)((Component)val4).gameObject).name == "Furr1")
				{
					SkinnedMeshRenderer component5 = ((Component)val4).GetComponent<SkinnedMeshRenderer>();
					if ((Object)(object)component5 != (Object)null)
					{
						fur = component5;
					}
				}
			}
			break;
		}
		case "Hatchling":
		{
			Transform[] componentsInChildren2 = ((Component)this).gameObject.GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren2)
			{
				if (((Object)((Component)val2).gameObject).name == "Hatchling")
				{
					SkinnedMeshRenderer component = ((Component)val2).GetComponent<SkinnedMeshRenderer>();
					if ((Object)(object)component != (Object)null)
					{
						body = component;
						face = ((Component)this).gameObject.GetComponentInChildren<SkinnedMeshRenderer>(true);
					}
				}
				else if (((Object)((Component)val2).gameObject).name == "Hatchling.001")
				{
					SkinnedMeshRenderer component2 = ((Component)val2).GetComponent<SkinnedMeshRenderer>();
					if ((Object)(object)component2 != (Object)null)
					{
						fur = component2;
					}
				}
			}
			break;
		}
		case "Neck":
		{
			Transform[] componentsInChildren3 = ((Component)this).gameObject.GetComponentsInChildren<Transform>(true);
			foreach (Transform val3 in componentsInChildren3)
			{
				if (((Object)((Component)val3).gameObject).name == "Body")
				{
					SkinnedMeshRenderer component3 = ((Component)val3).GetComponent<SkinnedMeshRenderer>();
					if ((Object)(object)component3 != (Object)null)
					{
						face = component3;
						body = component3;
						fur = component3;
					}
				}
			}
			break;
		}
		case "Boar":
		{
			SkinnedMeshRenderer[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (((Object)val).name == "Poly Art Boar")
				{
					face = val;
					body = val;
					fur = val;
					break;
				}
			}
			break;
		}
		case "Asksvin":
		case "Deer":
		case "Serpent":
		case "Wolf":
		case "Hare":
			fur = (body = (face = ((Component)this).gameObject.GetComponentInChildren<SkinnedMeshRenderer>(true)));
			break;
		}
		if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)fur == (Object)null)
		{
			Debug.LogWarning((object)("Couldn't find renderers for " + ((Object)((Component)this).gameObject).name));
			return false;
		}
		return true;
	}
}
public class LevelEffectGenerator
{
	private BaseLevelEffectSetupValue baseLevelEffectSetupValue = new BaseLevelEffectSetupValue();

	public void CreateVisuals(LevelEffects levelEffects)
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		baseLevelEffectSetupValue.getSetup(levelEffects);
		int num = 0;
		if (levelEffects.m_levelSetups != null)
		{
			num = levelEffects.m_levelSetups.Count;
		}
		int num2 = 6 - num;
		for (int i = 0; i < num2; i++)
		{
			LevelSetup item = createSetup(baseLevelEffectSetupValue.scale, baseLevelEffectSetupValue.saturation, baseLevelEffectSetupValue.hue, baseLevelEffectSetupValue.value, baseLevelEffectSetupValue.setEmmisive, baseLevelEffectSetupValue.emissive, baseLevelEffectSetupValue.sumValue * (float)(i + 1), num2, i + 1);
			levelEffects.m_levelSetups.Add(item);
		}
	}

	public LevelEffects CreateLevelEffectAt(Transform visual, SkinnedMeshRenderer meshRenderer)
	{
		if ((Object)(object)meshRenderer == (Object)null)
		{
			return null;
		}
		if ((Object)(object)meshRenderer != (Object)null)
		{
			LevelEffects val = ((Component)visual).gameObject.AddComponent<LevelEffects>();
			val.m_mainRender = (Renderer)(object)meshRenderer;
			val.m_character = (Character)(object)((Component)visual.parent).gameObject.GetComponent<Humanoid>();
			return val;
		}
		return null;
	}

	public LevelEffects CreateLevelEffectComponent(Transform visual)
	{
		SkinnedMeshRenderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<SkinnedMeshRenderer>();
		if (componentsInChildren.Length > 1)
		{
			Debug.LogWarning((object)("To many renderers to create Visual Effects:" + ((Object)visual.parent).name));
			return null;
		}
		if (componentsInChildren.Length == 1)
		{
			LevelEffects val = ((Component)visual).gameObject.AddComponent<LevelEffects>();
			val.m_mainRender = (Renderer)(object)componentsInChildren[0];
			val.m_character = (Character)(object)((Component)visual.parent).gameObject.GetComponent<Humanoid>();
			return val;
		}
		return null;
	}

	private LevelSetup createSetup(float scale, float saturation, float hue, float value, bool isEmmisive, Color emission, float changeValue, int maxAmount, int lvl)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Expected O, but got Unknown
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		LevelSetup val = new LevelSetup();
		val.m_scale = scale + changeValue;
		val.m_saturation = saturation + changeValue;
		val.m_hue = hue + changeValue;
		val.m_value = value + changeValue;
		val.m_enableObject = pickEnabledObject(maxAmount, lvl);
		val.m_setEmissiveColor = isEmmisive;
		val.m_emissiveColor = new Color(emission.r + changeValue, emission.g + changeValue, emission.b + changeValue, emission.a);
		return val;
	}

	private GameObject pickEnabledObject(int maxAmount, int lvl)
	{
		if (maxAmount == 6)
		{
			if (lvl > 4)
			{
				return baseLevelEffectSetupValue.enabledObjectLevel3;
			}
			if (lvl > 2)
			{
				return baseLevelEffectSetupValue.enabledObjectLevel2;
			}
		}
		if (maxAmount == 3)
		{
			if (lvl > 3)
			{
				return baseLevelEffectSetupValue.enabledObjectLevel3;
			}
			if (lvl > 2)
			{
				return baseLevelEffectSetupValue.enabledObjectLevel2;
			}
		}
		if (maxAmount < 3)
		{
			switch (lvl)
			{
			case 2:
				return baseLevelEffectSetupValue.enabledObjectLevel3;
			case 1:
				return baseLevelEffectSetupValue.enabledObjectLevel2;
			}
		}
		return baseLevelEffectSetupValue.enabledObject;
	}
}
[Serializable]
public class MaterialPack
{
	public Material face;

	public Material body;

	public Material body2;

	public string animal;

	public string skin;

	public MaterialPack(Material body, Material body2, Material face, string monsterName, string skinName)
	{
		animal = monsterName;
		this.face = face;
		this.body = body;
		this.body2 = body2;
		skin = skinName;
	}
}
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)("BalrondFurRandomizer:  " + ((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)("BalrondFurRandomizer:  " + ((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)("BalrondFurRandomizer:  " + ((Object)newPrefab).name + " - ItemDrop not found on prefab"));
		}
	}
}
[BepInPlugin("balrond.astafaraios.BalrondFurRandomizer", "BalrondFurRandomizer", "1.0.7")]
public class Launch : BaseUnityPlugin
{
	[HarmonyPatch(typeof(Game), "Awake")]
	public static class Game_Awake_Patch
	{
		public static void Prefix()
		{
			ZNetScene_Awake_Patch.hasSpawned = false;
		}
	}

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

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

	[HarmonyPatch(typeof(Character), "OnDeath")]
	public static class Character_OnDeath_Patch
	{
		public static void Prefix(Character __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				Debug.LogWarning((object)"Character instance does not exist yet");
			}
			else
			{
				if (__instance.m_deathEffects == null || __instance.m_deathEffects.m_effectPrefabs == null)
				{
					return;
				}
				LevelEffects componentInChildren = ((Component)__instance).GetComponentInChildren<LevelEffects>();
				if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren.m_mainRender == (Object)null)
				{
					return;
				}
				Material[] sharedMaterials = componentInChildren.m_mainRender.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					return;
				}
				EffectData[] effectPrefabs = __instance.m_deathEffects.m_effectPrefabs;
				foreach (EffectData val in effectPrefabs)
				{
					if (val != null && !((Object)(object)val.m_prefab == (Object)null))
					{
						Ragdoll component = val.m_prefab.GetComponent<Ragdoll>();
						if ((Object)(object)component != (Object)null && (Object)(object)component.m_mainModel != (Object)null)
						{
							component.m_mainModel.sharedMaterials = sharedMaterials;
						}
					}
				}
			}
		}
	}

	[HarmonyPatch(typeof(LevelEffects), "SetupLevelVisualization")]
	public static class LevelEffects_SetupLevelVisualization_Patch
	{
		public static bool Prefix(LevelEffects __instance, int level)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return false;
			}
			if (level <= 1 || __instance.m_levelSetups.Count < level - 1)
			{
				return false;
			}
			LevelSetup val = __instance.m_levelSetups[level - 2];
			((Component)__instance).transform.localScale = new Vector3(val.m_scale, val.m_scale, val.m_scale);
			if ((Object)(object)__instance.m_mainRender != (Object)null)
			{
				Material[] sharedMaterials = __instance.m_mainRender.sharedMaterials;
				if (sharedMaterials != null && sharedMaterials.Length != 0 && (Object)(object)sharedMaterials[0] != (Object)null)
				{
					sharedMaterials[0] = new Material(sharedMaterials[0]);
					sharedMaterials[0].SetFloat("_Hue", val.m_hue);
					sharedMaterials[0].SetFloat("_Saturation", val.m_saturation);
					sharedMaterials[0].SetFloat("_Value", val.m_value);
					if (val.m_setEmissiveColor)
					{
						sharedMaterials[0].SetColor("_EmissionColor", val.m_emissiveColor);
					}
					__instance.m_mainRender.sharedMaterials = sharedMaterials;
					if ((Object)(object)__instance.m_character != (Object)null)
					{
						string key = Utils.GetPrefabName(((Component)__instance.m_character).gameObject) + level;
						LevelEffects.m_materials[key] = sharedMaterials[0];
					}
				}
			}
			if ((Object)(object)__instance.m_baseEnableObject != (Object)null)
			{
				__instance.m_baseEnableObject.SetActive(false);
			}
			if ((Object)(object)val.m_enableObject != (Object)null)
			{
				val.m_enableObject.SetActive(true);
			}
			return false;
		}
	}

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

		public static void Prefix(ZNetScene __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				Debug.LogWarning((object)"BalrondFurRandomizer: No ZNetScene found");
			}
			else if (!hasSpawned)
			{
				itemSetBuilder.CreateMaterialPacks(modResourceLoader);
				SetupFurRandomizers(__instance.m_prefabs);
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated())
				{
					hasSpawned = true;
					return;
				}
				ShaderReplacment.runMaterialFix();
				hasSpawned = true;
			}
		}

		private static void SetupFurRandomizers(List<GameObject> prefabs)
		{
			if (prefabs == null || prefabs.Count == 0)
			{
				Debug.LogWarning((object)"BalrondFurRandomizer: Prefab list is empty");
				return;
			}
			string[] array = new string[9] { "Wolf", "Neck", "Hare", "Serpent", "Hatchling", "Lox", "Deer", "Boar", "Asksvin" };
			string[] array2 = array;
			foreach (string targetName in array2)
			{
				GameObject monster = prefabs.Find((GameObject x) => (Object)(object)x != (Object)null && ((Object)x).name == targetName);
				itemSetBuilder.SetupFurRandomizerForMonster(monster);
			}
		}
	}

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

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

	public const string PluginName = "BalrondFurRandomizer";

	public const string PluginVersion = "1.0.7";

	public static ModResourceLoader modResourceLoader = new ModResourceLoader();

	public static DatabaseAddMethods databaseAddMethods = new DatabaseAddMethods();

	public static MonsterManager monsterManager = new MonsterManager();

	public static ItemSetBuilder itemSetBuilder = new ItemSetBuilder();

	public static GameObject gui;

	public static GameObject gui2;

	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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Expected O, but got Unknown
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Expected O, but got Unknown
		if (!((Object)(object)RootObject != (Object)null) || !((Object)(object)PrefabContainer != (Object)null))
		{
			RootObject = new GameObject("_ValheimReforgedRoot");
			Object.DontDestroyOnLoad((Object)(object)RootObject);
			PrefabContainer = new GameObject("Prefabs");
			PrefabContainer.transform.SetParent(RootObject.transform, false);
			PrefabContainer.SetActive(false);
		}
	}

	public static GameObject CloneMe(GameObject source, string name)
	{
		if ((Object)(object)source == (Object)null)
		{
			Debug.LogWarning((object)"BalrondFurRandomizer: CloneMe source is null");
			return null;
		}
		if ((Object)(object)PrefabContainer == (Object)null)
		{
			Debug.LogWarning((object)"BalrondFurRandomizer: PrefabContainer is null");
			return null;
		}
		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 != null && ObjectDB.instance.m_recipes != 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)
	{
		if (!((Object)(object)gameObject == (Object)null) && !((Object)(object)statusEffect == (Object)null))
		{
			ItemDrop component = gameObject.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogWarning((object)("BalrondFurRandomizer: ItemDrop not found on " + ((Object)gameObject).name));
			}
			else
			{
				component.m_itemData.m_shared.m_attackStatusEffect = statusEffect;
			}
		}
	}
}
public class ModResourceLoader
{
	public AssetBundle assetBundle;

	public Material loxFace_Default;

	public Material loxtBody_Default;

	public Material loxFur_Default;

	public Material loxFace_Albino;

	public Material loxtBody_Albino;

	public Material loxFur_Albino;

	public Material loxFace_Black;

	public Material loxtBody_Black;

	public Material loxFur_Black;

	public Material loxFace_Blond;

	public Material loxtBody_Blond;

	public Material loxFur_Blond;

	public Material loxFace_DarkBrown;

	public Material loxtBody_DarkBrown;

	public Material loxFur_DarkBrown;

	public Material loxFace_Ginger;

	public Material loxtBody_Ginger;

	public Material loxFur_Ginger;

	public Material wolfBody_Default;

	public Material wolfBody_Albino;

	public Material wolfBody_Black;

	public Material wolfBody_DarkBrown;

	public Material wolfBody_Grey;

	public Material boarBody_Default;

	public Material boarBody_Grey;

	public Material boarBody_Black;

	public Material boarBody_DarkBrown;

	public Material boarBody_LightBrown;

	public Material askvinBody_Default;

	public Material askvinBody_Albino;

	public Material askvinBody_Purple;

	public Material askvinBody_Black;

	public Material askvinBody_Grey;

	public Material deerBody_Default;

	public Material deerBody_Albino;

	public Material deerBody_Red;

	public Material deerBody_DarkBrown;

	public Material deerBody_Grey;

	public Material neckBody_Default;

	public Material neckBody_Albino;

	public Material neckBody_Blue;

	public Material neckBody_DarkBlue;

	public Material neckBody_DarkGreen;

	public Material hareBody_Default;

	public Material hareBody_Albino;

	public Material hareBody_Black;

	public Material hareBody_DarkBlue;

	public Material hareBody_Ginger;

	public Material drakeBody_Default;

	public Material drakeBody_DarkBlue;

	public Material drakeBody_IceBlue;

	public Material drakeBody_Purple;

	public Material drakeBody_Red;

	public Material serpentBody_Default;

	public Material serpentBody_Albino;

	public Material serpentBody_Black;

	public Material serpentBody_Blue;

	public Material serpentBody_Green;

	public Material serpentBody_Red;

	public void loadAssets()
	{
		assetBundle = GetAssetBundleFromResources("furrandomizer");
		string text = "Assets/BalrondFurRandomizer/";
		Material temp = assetBundle.LoadAsset<Material>(text + "Lox/Default/lox_face.mat");
		CreateLoxMaterial(temp, text);
		CreateWolfMaterial(temp, text);
		CreateNeckMaterial(temp, text);
		CreateHareMaterial(temp, text);
		CreateDrakeMaterial(temp, text);
		CreateSerpentMaterials(temp, text);
		CreateAskvinMaterial(temp, text);
		CreateBoarMaterial(temp, text);
		CreateDeerMaterial(temp, text);
	}

	private void CreateLoxMaterial(Material temp, string mainPath)
	{
		ShaderReplacment.ReplaceMaterial(temp);
		loxFace_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Default/lox_body1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxtBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Default/lox_fur1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFur_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Albino/lox_face.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFace_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Albino/lox_body1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxtBody_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Albino/lox_fur1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFur_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Black/lox_face.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFace_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Black/lox_body1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxtBody_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Black/lox_fur1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFur_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Blonde/lox_face.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFace_Blond = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Blonde/lox_body1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxtBody_Blond = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Blonde/lox_fur1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFur_Blond = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/DarkBrown/lox_face.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFace_DarkBrown = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/DarkBrown/lox_body1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxtBody_DarkBrown = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/DarkBrown/lox_fur1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFur_DarkBrown = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Ginger/lox_face.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFace_Ginger = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Ginger/lox_body1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxtBody_Ginger = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Ginger/lox_fur1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		loxFur_Ginger = temp;
	}

	private void CreateWolfMaterial(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Default/wolfMat.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		wolfBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Albino/wolfMat.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		wolfBody_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Black/wolfMat.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		wolfBody_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/DarkBrown/wolfMat.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		wolfBody_DarkBrown = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Grey/wolfMat.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		wolfBody_Grey = temp;
	}

	private void CreateBoarMaterial(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Default/Material_default.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		boarBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Grey/Material_grey.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		boarBody_Grey = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Black/Material_black.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		boarBody_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/DarkBrown/Material_darkBrown.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		boarBody_DarkBrown = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Young/Material_young.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		boarBody_LightBrown = temp;
	}

	private void CreateDeerMaterial(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Default/Deer_default.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		deerBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Albino/Deer_albino.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		deerBody_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Red/Deer_red.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		deerBody_Red = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/LightBrown/Deer_brown.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		deerBody_DarkBrown = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Grey/Deer_gray.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		deerBody_Grey = temp;
	}

	private void CreateAskvinMaterial(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Default/asksvin_Mat_default.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		askvinBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Albino/asksvin_Mat_albino.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		askvinBody_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Purple/asksvin_Mat_purple.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		askvinBody_Purple = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Black/asksvin_Mat_black.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		askvinBody_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Young/asksvincub_Mat_young.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		askvinBody_Grey = temp;
	}

	private void CreateNeckMaterial(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/Default/neck1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		neckBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/Albino/neck1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		neckBody_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/Blue/neck1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		neckBody_Blue = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/DarkBlue/neck1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		neckBody_DarkBlue = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/DarkGreen/neck1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		neckBody_DarkGreen = temp;
	}

	private void CreateHareMaterial(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Default/Hare_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		hareBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Albino/Hare_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		hareBody_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Black/Hare_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		hareBody_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/DarkBlue/Hare_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		hareBody_DarkBlue = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Ginger/Hare_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		hareBody_Ginger = temp;
	}

	private void CreateDrakeMaterial(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/Default/Hatchling_mountain_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		drakeBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/DarkBlue/Hatchling_mountain_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		drakeBody_DarkBlue = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/IceBlue/Hatchling_mountain_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		drakeBody_IceBlue = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/Purple/Hatchling_mountain_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		drakeBody_Purple = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/Red/Hatchling_mountain_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		drakeBody_Red = temp;
	}

	private void CreateSerpentMaterials(Material temp, string mainPath)
	{
		temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Default/SeaSerpent_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		serpentBody_Default = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Albino/SeaSerpent_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		serpentBody_Albino = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Black/SeaSerpent_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		serpentBody_Black = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Blue/SeaSerpent_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		serpentBody_Blue = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Green/SeaSerpent_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		serpentBody_Green = temp;
		temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Red/SeaSerpent_mat1.mat");
		ShaderReplacment.ReplaceMaterial(temp);
		serpentBody_Red = temp;
	}

	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 MonsterManager
{
	private readonly LevelEffectGenerator levelEffectGenerator = new LevelEffectGenerator();

	private List<GameObject> monsters = new List<GameObject>();

	private static readonly HashSet<string> VisualNames = new HashSet<string>
	{
		"Lox", "Wraith", "TentaRoot", "TheHive", "Hatchling", "GoblinKing", "Eikthyr", "Bonemass", "Frog", "Haugbui",
		"Greydwarf_Mystic", "Varsvin", "Varsvin_Brute", "Varsvin_Hunter", "SeekerQueen"
	};

	private static readonly HashSet<string> SkipNames = new HashSet<string> { "TheHive", "Haugbui", "Greydwarf_Mystic" };

	public void SetupMonsterList(List<GameObject> list)
	{
		if (list == null)
		{
			Debug.LogWarning((object)"I DID NOT FIND PREFAB LIST!");
			monsters = new List<GameObject>();
		}
		else
		{
			monsters = list.FindAll((GameObject x) => (Object)(object)x != (Object)null && (Object)(object)x.GetComponent<MonsterAI>() != (Object)null);
		}
	}

	public void ChangeMonsterResistance()
	{
		if (monsters == null || monsters.Count == 0)
		{
			Debug.LogWarning((object)"I DID NOT FIND ANY MONSTERS!");
			return;
		}
		foreach (GameObject monster in monsters)
		{
			if (!((Object)(object)monster == (Object)null))
			{
				SetupLevelVisual(monster);
			}
		}
	}

	private void SetupLevelVisual(GameObject gameObject)
	{
		if ((Object)(object)gameObject == (Object)null || SkipNames.Contains(((Object)gameObject).name))
		{
			return;
		}
		Transform val = gameObject.transform.Find("Visual");
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		LevelEffects val2 = gameObject.GetComponentInChildren<LevelEffects>();
		if (VisualNames.Contains(((Object)gameObject).name))
		{
			Transform val3 = FindSpecialBodyTransform(gameObject);
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			SkinnedMeshRenderer component = ((Component)val3).GetComponent<SkinnedMeshRenderer>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			val2 = levelEffectGenerator.CreateLevelEffectAt(val, component);
		}
		else if ((Object)(object)val2 == (Object)null)
		{
			val2 = levelEffectGenerator.CreateLevelEffectComponent(val);
		}
		if ((Object)(object)val2 != (Object)null)
		{
			levelEffectGenerator.CreateVisuals(val2);
		}
	}

	private Transform FindSpecialBodyTransform(GameObject gameObject)
	{
		switch (((Object)gameObject).name)
		{
		case "Lox":
			return gameObject.transform.Find("Visual/offset/Body");
		case "Wraith":
			return gameObject.transform.Find("Visual/wraith/wraith");
		case "TentaRoot":
			return gameObject.transform.Find("Visual/Tentaroots/Cube.001");
		case "Hatchling":
			return gameObject.transform.Find("Visual/Hatchling_mountain/Hatchling");
		case "GoblinKing":
			return gameObject.transform.Find("Visual/Yagluth");
		case "Eikthyr":
			return gameObject.transform.Find("Visual/Deer");
		case "Bonemass":
			return gameObject.transform.Find("Visual/model/bonemass");
		case "Varsvin":
		case "Varsvin_Brute":
		case "Varsvin_Hunter":
			return gameObject.transform.Find("Visual/Body");
		case "Frog":
			return gameObject.transform.Find("Visual/Frog2_mesh");
		case "SeekerQueen":
			return gameObject.transform.Find("Visual/Cube");
		default:
			return null;
		}
	}
}