using System;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using LasyBastardEngineer.Properties;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using R2API;
using R2API.Utils;
using RoR2;
using RoR2.Achievements;
using RoR2.Projectile;
using RoR2BepInExPack.VanillaFixes;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("LasyBastardEngineer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LasyBastardEngineer")]
[assembly: AssemblyTitle("LasyBastardEngineer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace LasyBastardEngineer
{
	[RegisterAchievement("LazyBastardEngineer", "Skins.Engineer.LazyBastard", "Complete30StagesCareer", 3u, null)]
	public class Achievement : BaseAchievement
	{
		private int skillUseCount = 0;

		public override BodyIndex LookUpRequiredBodyIndex()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return BodyCatalog.FindBodyIndex("EngiBody");
		}

		public override void OnBodyRequirementMet()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			((BaseAchievement)this).OnBodyRequirementMet();
			Run.onRunStartGlobal += ResetSkillUseCount;
			Run.onClientGameOverGlobal += ClearCheck;
			CharacterBody.OnSkillActivated += new hook_OnSkillActivated(SkillCheck);
		}

		public override void OnBodyRequirementBroken()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Run.onRunStartGlobal += ResetSkillUseCount;
			Run.onClientGameOverGlobal -= ClearCheck;
			CharacterBody.OnSkillActivated -= new hook_OnSkillActivated(SkillCheck);
			((BaseAchievement)this).OnBodyRequirementBroken();
		}

		private void SkillCheck(orig_OnSkillActivated orig, CharacterBody self, GenericSkill skill)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			if (self.bodyIndex == ((BaseAchievement)this).LookUpRequiredBodyIndex() && (int)self.teamComponent.teamIndex == 1 && (Object)(object)skill != (Object)(object)self.skillLocator.special)
			{
				if (skillUseCount == 0)
				{
					Debug.Log((object)"DEBUG: Lazy Bastard challenge failed.");
					if (Base.AnnounceWhenFail.Value)
					{
						Chat.AddMessage("Lazy Bastard challenge failed!");
					}
				}
				skillUseCount++;
			}
			orig.Invoke(self, skill);
		}

		private void ResetSkillUseCount(Run obj)
		{
			skillUseCount = 0;
		}

		public void ClearCheck(Run run, RunReport runReport)
		{
			bool flag = skillUseCount == 0 && ((BaseAchievement)this).meetsBodyRequirement;
			skillUseCount = 0;
			if (!((Object)(object)run == (Object)null) && runReport != null && Object.op_Implicit((Object)(object)runReport.gameEnding) && runReport.gameEnding.isWin && flag)
			{
				((BaseAchievement)this).Grant();
			}
		}
	}
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[R2APISubmoduleDependency(new string[] { "LanguageAPI", "LoadoutAPI" })]
	[BepInPlugin("com.Borbo.LazyBastardEngineer", "LazyBastardEngineer", "2.3.0")]
	internal class Base : BaseUnityPlugin
	{
		[HarmonyPatch]
		public class PatchAchievementDefs
		{
			public static void ILManipulator(ILContext il, MethodBase original, ILLabel retLabel)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Expected O, but got Unknown
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				int attr = -1;
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCastclass<RegisterAchievementAttribute>(x),
					(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref attr)
				});
				val.Emit(OpCodes.Ldloc, attr - 1);
				val.Emit(OpCodes.Ldloc, attr);
				val.EmitDelegate<Func<Type, RegisterAchievementAttribute, RegisterAchievementAttribute>>((Func<Type, RegisterAchievementAttribute, RegisterAchievementAttribute>)((Type type, RegisterAchievementAttribute achievementAttribute) => (ForceUnlock.Value && achievementAttribute != null && achievementAttribute.unlockableRewardIdentifier == "Skins.Engineer.LazyBastard") ? null : achievementAttribute));
				val.Emit(OpCodes.Stloc, attr);
			}

			public static MethodBase TargetMethod()
			{
				return AccessTools.DeclaredMethod(typeof(SaferAchievementManager).GetNestedType("<SaferCollectAchievementDefs>d__12", AccessTools.all), "MoveNext", (Type[])null, (Type[])null);
			}
		}

		public static Harmony Harmony;

		public static string modPrefix = string.Format("@{0}+{1}", "LazyBastardEngineer", "lazybastardengi");

		public static Sprite skinIcon = LoadoutAPI.CreateSkinIcon(new Color(1f, 0.7f, 0.3f), new Color(0.7f, 0.5f, 0.3f), new Color(0.3f, 0.3f, 0.3f), new Color(0.8f, 0.8f, 0.8f));

		public static AssetBundle skinBundle = LoadAssetBundleResourcesProvider(modPrefix, Resources.lazybastardengi);

		public static string skinsPath = "Assets/LazyBastardSkins/";

		public static UnlockableDef unlock;

		public static GameObject engiBodyPrefab;

		public static GameObject turretBodyPrefab;

		public static GameObject walkerBodyPrefab;

		public static GameObject grenadePrefab;

		public static GameObject grenadeGhost;

		public static GameObject minePrefab;

		public static GameObject mineGhost;

		public static GameObject spiderPrefab;

		public static GameObject spiderGhost;

		private static ConfigFile CustomConfigFile { get; set; }

		public static ConfigEntry<bool> ForceUnlock { get; set; }

		public static ConfigEntry<bool> AnnounceWhenFail { get; set; }

		public static AssetBundle LoadAssetBundleResourcesProvider(string prefix, byte[] resourceBytes)
		{
			if (resourceBytes == null)
			{
				throw new ArgumentNullException("resourceBytes");
			}
			if (string.IsNullOrEmpty(prefix) || !prefix.StartsWith("@"))
			{
				throw new ArgumentException("Invalid prefix format", "prefix");
			}
			AssetBundle val = AssetBundle.LoadFromMemory(resourceBytes);
			if ((Object)(object)val == (Object)null)
			{
				throw new NullReferenceException(string.Format("{0} did not resolve to an assetbundle.", "resourceBytes"));
			}
			return val;
		}

		private void Awake()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			InitializeConfig();
			unlock = ScriptableObject.CreateInstance<UnlockableDef>();
			unlock.cachedName = "Skins.Engineer.LazyBastard";
			unlock.nameToken = "ACHIEVEMENT_LAZYBASTARDENGINEER_NAME";
			unlock.achievementIcon = skinIcon;
			ContentAddition.AddUnlockableDef(unlock);
			SwapAllShaders(skinBundle);
			AddFactorioSkin();
			LanguageAPI.Add("FACTORIO_SKIN_ENGINEER", "Power Armor MK2");
			LanguageAPI.Add("ACHIEVEMENT_LAZYBASTARDENGINEER_NAME", "Engineer: Lazy Bastard");
			LanguageAPI.Add("ACHIEVEMENT_LAZYBASTARDENGINEER_DESCRIPTION", "As Engineer, beat the game or obliterate without using your Primary, Secondary, or Utility skills.");
			Harmony = new Harmony("com.Borbo.LazyBastardEngineer");
			Harmony.PatchAll(typeof(PatchAchievementDefs));
		}

		private void InitializeConfig()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			CustomConfigFile = new ConfigFile(Paths.ConfigPath + "\\LazyBastardEngi.cfg", true);
			ForceUnlock = CustomConfigFile.Bind<bool>("Achievements", "Force Unlock Lazy Bastard Skin", false, "Set this to true to bypass the unlock requirement for the Lazy Bastard Skin.");
			AnnounceWhenFail = CustomConfigFile.Bind<bool>("Debug", "Announce When Fail", true, "Set this to true to add an announcement to the chat when the Lazy Bastard challenge fails. ");
		}

		private void AddFactorioSkin()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			engiBodyPrefab = Resources.Load<GameObject>("prefabs/characterbodies/EngiBody");
			turretBodyPrefab = Resources.Load<GameObject>("prefabs/characterbodies/EngiTurretBody");
			walkerBodyPrefab = Resources.Load<GameObject>("prefabs/characterbodies/EngiWalkerTurretBody");
			grenadePrefab = Resources.Load<GameObject>("prefabs/projectiles/EngiGrenadeProjectile");
			grenadeGhost = Resources.Load<GameObject>("prefabs/projectileghosts/EngiGrenadeGhost");
			minePrefab = Resources.Load<GameObject>("prefabs/projectiles/EngiMine");
			mineGhost = Resources.Load<GameObject>("prefabs/projectileghosts/EngiMineGhost");
			spiderPrefab = Resources.Load<GameObject>("prefabs/projectiles/SpiderMine");
			spiderGhost = Resources.Load<GameObject>("prefabs/projectileghosts/SpiderMineGhost");
			Renderer[] componentsInChildren = engiBodyPrefab.GetComponentsInChildren<Renderer>(true);
			ModelSkinController componentInChildren = engiBodyPrefab.GetComponentInChildren<ModelSkinController>();
			GameObject gameObject = ((Component)componentInChildren).gameObject;
			SkinDefInfo val = default(SkinDefInfo);
			val.Icon = skinIcon;
			val.Name = "LazyBastardEngineer";
			val.NameToken = "FACTORIO_SKIN_ENGINEER";
			val.RootObject = gameObject;
			val.BaseSkins = (SkinDef[])(object)new SkinDef[1] { componentInChildren.skins[0] };
			val.UnlockableDef = (ForceUnlock.Value ? null : unlock);
			val.GameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[0];
			val.RendererInfos = (RendererInfo[])(object)new RendererInfo[1]
			{
				new RendererInfo
				{
					defaultMaterial = skinBundle.LoadAsset<Material>(skinsPath + "matLazyBastard.mat"),
					defaultShadowCastingMode = (ShadowCastingMode)1,
					ignoreOverlays = false,
					renderer = componentsInChildren[4]
				}
			};
			val.MeshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
			{
				new MeshReplacement
				{
					mesh = skinBundle.LoadAsset<Mesh>(skinsPath + "EngiMesh.mesh"),
					renderer = componentsInChildren[4]
				}
			};
			val.ProjectileGhostReplacements = (ProjectileGhostReplacement[])(object)new ProjectileGhostReplacement[2]
			{
				new ProjectileGhostReplacement
				{
					projectilePrefab = minePrefab,
					projectileGhostReplacementPrefab = NewProjectileGhost(mineGhost, "EngiMineGhost.prefab")
				},
				new ProjectileGhostReplacement
				{
					projectilePrefab = grenadePrefab,
					projectileGhostReplacementPrefab = NewProjectileGhost(grenadeGhost, "EngiGrenadeGhost.prefab")
				}
			};
			val.MinionSkinReplacements = (MinionSkinReplacement[])(object)new MinionSkinReplacement[2]
			{
				new MinionSkinReplacement
				{
					minionBodyPrefab = turretBodyPrefab,
					minionSkin = GetSkinFromTurretBody(turretBodyPrefab, "matLazyBastard.mat", "EngiTurretMesh.mesh")
				},
				new MinionSkinReplacement
				{
					minionBodyPrefab = walkerBodyPrefab,
					minionSkin = GetSkinFromTurretBody(walkerBodyPrefab, "matLazyBastard.mat", "EngiWalkerTurretMesh.mesh")
				}
			};
			SkinDefInfo val2 = val;
			LoadoutAPI.AddSkinToCharacter(engiBodyPrefab, val2);
		}

		private GameObject ModifyProjectileGhost(GameObject ghostPrefab, string material, string mesh)
		{
			Material val = skinBundle.LoadAsset<Material>(skinsPath + material);
			Mesh val2 = skinBundle.LoadAsset<Mesh>(skinsPath + mesh);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)ghostPrefab == (Object)null)
			{
				Debug.Log((object)("New skin for " + ((Object)ghostPrefab).name + " failed to load."));
				return ghostPrefab;
			}
			GameObject val3 = PrefabAPI.InstantiateClone(ghostPrefab, "LazyBastard" + ((Object)ghostPrefab).name, true);
			val3.AddComponent<NetworkIdentity>();
			Renderer[] componentsInChildren = val3.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val4 in array)
			{
				val4.sharedMaterial = val;
			}
			MeshFilter[] componentsInChildren2 = val3.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val5 in componentsInChildren2)
			{
				val5.sharedMesh = val2;
			}
			SkinnedMeshRenderer[] componentsInChildren3 = val3.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			SkinnedMeshRenderer[] array2 = componentsInChildren3;
			foreach (SkinnedMeshRenderer val6 in array2)
			{
				val6.sharedMesh = val2;
			}
			return val3;
		}

		private GameObject NewProjectileGhost(GameObject ghostPrefab, string prefab)
		{
			GameObject val = skinBundle.LoadAsset<GameObject>(skinsPath + prefab);
			if ((Object)(object)val == (Object)null)
			{
				Debug.Log((object)("New ghost skin for " + ((Object)ghostPrefab).name + " failed to load."));
				return ghostPrefab;
			}
			val.AddComponent<NetworkIdentity>();
			val.AddComponent<ProjectileGhostController>();
			return val;
		}

		private SkinDef GetSkinFromTurretBody(GameObject bodyPrefab, string materialName, string meshName)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			Material val = skinBundle.LoadAsset<Material>(skinsPath + materialName);
			Mesh val2 = skinBundle.LoadAsset<Mesh>(skinsPath + meshName);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)bodyPrefab == (Object)null)
			{
				Debug.Log((object)("New skin for " + ((Object)bodyPrefab).name + " failed to load."));
				return bodyPrefab.GetComponentInChildren<ModelSkinController>().skins[0];
			}
			Renderer[] componentsInChildren = bodyPrefab.GetComponentsInChildren<Renderer>(true);
			ModelSkinController componentInChildren = bodyPrefab.GetComponentInChildren<ModelSkinController>();
			GameObject gameObject = ((Component)componentInChildren).gameObject;
			Debug.Log((object)"Creating turret skin...");
			SkinDefInfo val3 = default(SkinDefInfo);
			val3.Icon = skinIcon;
			val3.Name = "LazyBastard" + ((Object)bodyPrefab).name;
			val3.NameToken = "FACTORIO_SKIN_" + ((Object)bodyPrefab).name.ToUpper();
			val3.RootObject = gameObject;
			val3.BaseSkins = (SkinDef[])(object)new SkinDef[1] { componentInChildren.skins[0] };
			val3.UnlockableDef = null;
			val3.GameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[0];
			val3.RendererInfos = (RendererInfo[])(object)new RendererInfo[1]
			{
				new RendererInfo
				{
					defaultMaterial = val,
					defaultShadowCastingMode = (ShadowCastingMode)1,
					ignoreOverlays = false,
					renderer = componentsInChildren[0]
				}
			};
			val3.MeshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
			{
				new MeshReplacement
				{
					mesh = val2,
					renderer = componentsInChildren[0]
				}
			};
			val3.ProjectileGhostReplacements = (ProjectileGhostReplacement[])(object)new ProjectileGhostReplacement[0];
			val3.MinionSkinReplacements = (MinionSkinReplacement[])(object)new MinionSkinReplacement[0];
			SkinDefInfo val4 = val3;
			SkinDef val5 = LoadoutAPI.CreateNewSkinDef(val4);
			LoadoutAPI.AddSkinToCharacter(bodyPrefab, val5);
			return val5;
		}

		private SkinDef GetNewSkinFromTurretBody(GameObject bodyPrefab, string material, string mesh)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			Material val = skinBundle.LoadAsset<Material>(skinsPath + material);
			Mesh val2 = skinBundle.LoadAsset<Mesh>(skinsPath + mesh);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)bodyPrefab == (Object)null)
			{
				Debug.Log((object)("New skin for " + ((Object)bodyPrefab).name + " failed to load."));
				return bodyPrefab.GetComponentInChildren<ModelSkinController>().skins[0];
			}
			Renderer[] componentsInChildren = bodyPrefab.GetComponentsInChildren<Renderer>(true);
			ModelSkinController componentInChildren = bodyPrefab.GetComponentInChildren<ModelSkinController>();
			GameObject gameObject = ((Component)componentInChildren).gameObject;
			SkinDefInfo val3 = default(SkinDefInfo);
			val3.Icon = skinIcon;
			val3.Name = "LazyBastard" + ((Object)bodyPrefab).name;
			val3.NameToken = "FACTORIO_SKIN_" + ((Object)bodyPrefab).name.ToUpper();
			val3.RootObject = gameObject;
			val3.BaseSkins = (SkinDef[])(object)new SkinDef[1] { componentInChildren.skins[0] };
			val3.UnlockableDef = ScriptableObject.CreateInstance<UnlockableDef>();
			val3.GameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[0];
			val3.RendererInfos = (RendererInfo[])(object)new RendererInfo[1]
			{
				new RendererInfo
				{
					defaultMaterial = val,
					defaultShadowCastingMode = (ShadowCastingMode)1,
					ignoreOverlays = false,
					renderer = componentsInChildren[0]
				}
			};
			val3.MeshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
			{
				new MeshReplacement
				{
					mesh = val2,
					renderer = componentsInChildren[0]
				}
			};
			val3.ProjectileGhostReplacements = (ProjectileGhostReplacement[])(object)new ProjectileGhostReplacement[0];
			val3.MinionSkinReplacements = (MinionSkinReplacement[])(object)new MinionSkinReplacement[0];
			SkinDefInfo val4 = val3;
			LoadoutAPI.AddSkinToCharacter(bodyPrefab, val4);
			return LoadoutAPI.CreateNewSkinDef(val4);
		}

		public void SwapAllShaders(AssetBundle bundle)
		{
			Material[] array = bundle.LoadAllAssets<Material>();
			Material[] array2 = array;
			Material[] array3 = array2;
			foreach (Material val in array3)
			{
				switch (((Object)val.shader).name)
				{
				case "Stubbed Hopoo Games/Deferred/Standard":
					val.shader = Resources.Load<Shader>("shaders/deferred/hgstandard");
					break;
				case "Stubbed Hopoo Games/Deferred/Snow Topped":
					val.shader = Resources.Load<Shader>("shaders/deferred/hgsnowtopped");
					break;
				case "Stubbed Hopoo Games/FX/Cloud Remap":
					val.shader = Resources.Load<Shader>("shaders/fx/hgcloudremap");
					break;
				case "Stubbed Hopoo Games/FX/Cloud Intersection Remap":
					val.shader = Resources.Load<Shader>("shaders/fx/hgintersectioncloudremap");
					break;
				case "Stubbed Hopoo Games/FX/Opaque Cloud Remap":
					val.shader = Resources.Load<Shader>("shaders/fx/hgopaquecloudremap");
					break;
				case "Stubbed Hopoo Games/FX/Distortion":
					val.shader = Resources.Load<Shader>("shaders/fx/hgdistortion");
					break;
				case "Stubbed Hopoo Games/FX/Solid Parallax":
					val.shader = Resources.Load<Shader>("shaders/fx/hgsolidparallax");
					break;
				case "Stubbed Hopoo Games/Environment/Distant Water":
					val.shader = Resources.Load<Shader>("shaders/environment/hgdistantwater");
					break;
				}
			}
		}
	}
}
namespace LasyBastardEngineer.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("LasyBastardEngineer.Properties.Resources", typeof(Resources).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] lazybastardengi
		{
			get
			{
				object @object = ResourceManager.GetObject("lazybastardengi", resourceCulture);
				return (byte[])@object;
			}
		}

		internal Resources()
		{
		}
	}
}