Decompiled source of Risk of Gregor v1.0.0

RiskOfGregor.dll

Decompiled 2 days ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using MonoMod.RuntimeDetour.HookGen;
using RoR2;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace RiskOfGregor;

[BepInPlugin("com.TheRealGregorSamsa.RiskOfGregor", "Risk of Gregor", "1.0.0")]
public class RiskOfGregorPlugin : BaseUnityPlugin
{
	private class FieldException : Exception
	{
		public FieldException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}

	private class ElementException : Exception
	{
		public int Index { get; }

		public ElementException(int index, string message)
			: base(message)
		{
			Index = index;
		}
	}

	private static AssetBundle assetBundle;

	private static readonly List<Material> materialsWithRoRShader = new List<Material>();

	internal static RiskOfGregorPlugin Instance { get; private set; }

	internal static ManualLogSource InstanceLogger
	{
		get
		{
			RiskOfGregorPlugin instance = Instance;
			if (instance == null)
			{
				return null;
			}
			return ((BaseUnityPlugin)instance).Logger;
		}
	}

	private void Start()
	{
		Instance = this;
		using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("RiskOfGregor.therealgregorsamsariskofgregor"))
		{
			assetBundle = AssetBundle.LoadFromStream(stream);
		}
		((ResourceAvailability)(ref BodyCatalog.availability)).CallWhenAvailable((Action)BodyCatalogInit);
		HookEndpointManager.Add((MethodBase)typeof(Language).GetMethod("LoadStrings"), (Delegate)new Action<Action<Language>, Language>(LanguageLoadStrings));
		ReplaceShaders();
	}

	private static void ReplaceShaders()
	{
		LoadMaterialsWithReplacedShader("RoR2/Base/Shaders/HGStandard.shader", "Assets/Resources/Skin.mat");
	}

	private static void LoadMaterialsWithReplacedShader(string shaderPath, params string[] materialPaths)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		Shader shader = Addressables.LoadAssetAsync<Shader>((object)shaderPath).WaitForCompletion();
		foreach (string text in materialPaths)
		{
			Material val = assetBundle.LoadAsset<Material>(text);
			val.shader = shader;
			materialsWithRoRShader.Add(val);
		}
	}

	private static void LanguageLoadStrings(Action<Language> orig, Language self)
	{
		orig(self);
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_CAPTAIN_GREGOR_DEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_ACRID_GREGOR_DEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_COMMANDO_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_HUNTRESS_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_BANDIT_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_OPERATOR_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_VOID_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_REX_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_DRIFTER_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_FALSE_SON_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_MULT_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_ARTIFICER_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_ENGINEER_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_MERCENARY_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_LOADER_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_CHEF_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_RAILGUNNER_GREGORDEF_NAME", "Gregor");
		self.SetStringByToken("THE_REAL_GREGOR_SAMSA_SKIN_SEEKER_GREGORDEF_NAME", "Gregor");
	}

	private static void BodyCatalogInit()
	{
		AddCaptainBodyCaptainGregorDefSkin();
		AddCrocoBodyAcridGregorDefSkin();
		AddCommandoBodyCommandoGregorDefSkin();
		AddHuntressBodyHuntressGregorDefSkin();
		AddBandit2BodyBanditGregorDefSkin();
		AddDroneTechBodyOperatorGregorDefSkin();
		AddVoidSurvivorBodyVoidGregorDefSkin();
		AddTreebotBodyRexGregorDefSkin();
		AddDrifterBodyDrifterGregorDefSkin();
		AddFalseSonBodyFalseSonGregorDefSkin();
		AddToolbotBodyMulTGregorDefSkin();
		AddMageBodyArtificerGregorDefSkin();
		AddEngiBodyEngineerGregorDefSkin();
		AddMercBodyMercenaryGregorDefSkin();
		AddLoaderBodyLoaderGregorDefSkin();
		AddChefBodyChefGregorDefSkin();
		AddRailgunnerBodyRailgunnerGregorDefSkin();
		AddSeekerBodySeekerGregorDefSkin();
	}

	private static void AddCaptainBodyCaptainGregorDefSkin()
	{
		string text = "CaptainBody";
		string text2 = "Captain Gregor Def";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Captain Gregor DefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_CAPTAIN_GREGOR_DEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[1]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"CaptainHat\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainHat")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: 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)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: 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_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: 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_02b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[6]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"Captain\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Captain")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"CaptainChestArmor\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainChestArmor")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(2, "There is no renderer with the name \"CaptainGunArm\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainGunArm")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(3, "There is no renderer with the name \"CaptainHead\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainHead")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(4, "There is no renderer with the name \"CaptainUndercoat\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainUndercoat")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(5, "There is no renderer with the name \"CaptainCoat\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainCoat")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: 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_0252: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[6]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Captain Legs.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"Captain\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Captain")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Captain Torso.mesh"),
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"CaptainChestArmor\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainChestArmor")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Captain Hand.mesh"),
						renderer = ThrowIfNull<Renderer>(2, "There is no renderer with the name \"CaptainGunArm\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainGunArm")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Captain Head.mesh"),
						renderer = ThrowIfNull<Renderer>(3, "There is no renderer with the name \"CaptainHead\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainHead")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Ass.mesh"),
						renderer = ThrowIfNull<Renderer>(4, "There is no renderer with the name \"CaptainUndercoat\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainUndercoat")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Captain Arms.mesh"),
						renderer = ThrowIfNull<Renderer>(5, "There is no renderer with the name \"CaptainCoat\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CaptainCoat")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddCrocoBodyAcridGregorDefSkin()
	{
		string text = "CrocoBody";
		string text2 = "Acrid Gregor Def";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Acrid Gregor DefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_ACRID_GREGOR_DEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[2]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"CrocoSpineMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CrocoSpineMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"Goo\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Goo")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[1]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"CrocoMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CrocoMesh")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Acrid Body.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"CrocoMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CrocoMesh")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddCommandoBodyCommandoGregorDefSkin()
	{
		string text = "CommandoBody";
		string text2 = "Commando GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Commando GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_COMMANDO_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[2]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"GunMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "GunMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"GunMesh.001\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "GunMesh.001")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[1]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"CommandoMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CommandoMesh")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\GregorCommandoBody.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"CommandoMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "CommandoMesh")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddHuntressBodyHuntressGregorDefSkin()
	{
		string text = "HuntressBody";
		string text2 = "Huntress GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Huntress GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_HUNTRESS_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[1]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"HuntressScarfMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "HuntressScarfMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: 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)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[2]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"HuntressMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "HuntressMesh")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"BowMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "BowMesh")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[2]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Huntress Body.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"HuntressMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "HuntressMesh")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Bow.mesh"),
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"BowMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "BowMesh")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddBandit2BodyBanditGregorDefSkin()
	{
		string text = "Bandit2Body";
		string text2 = "Bandit GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Bandit GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_BANDIT_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: 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)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[3]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"Bandit2AccessoriesMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2AccessoriesMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"Bandit2HatMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2HatMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(2, "There is no renderer with the name \"BanditShotgunMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "BanditShotgunMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: 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)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: 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_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[4]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"Bandit2CoatMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2CoatMesh")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"Bandit2BodyMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2BodyMesh")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(2, "There is no renderer with the name \"Bandit2ArmsMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2ArmsMesh")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(3, "There is no renderer with the name \"BanditPistolMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "BanditPistolMesh")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[4]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Bandit Shoulder.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"Bandit2CoatMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2CoatMesh")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Bandit Body.mesh"),
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"Bandit2BodyMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2BodyMesh")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Bandit Hands.mesh"),
						renderer = ThrowIfNull<Renderer>(2, "There is no renderer with the name \"Bandit2ArmsMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Bandit2ArmsMesh")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\default.mesh"),
						renderer = ThrowIfNull<Renderer>(3, "There is no renderer with the name \"BanditPistolMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "BanditPistolMesh")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddDroneTechBodyOperatorGregorDefSkin()
	{
		string text = "DroneTechBody";
		string text2 = "Operator GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Operator GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_OPERATOR_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: 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_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[5]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"DroneTech_Gun\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "DroneTech_Gun")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"Operator_Glow_01\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Operator_Glow_01")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(2, "There is no renderer with the name \"Operator_Glow_02\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Operator_Glow_02")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(3, "There is no renderer with the name \"Operator_Glow_03\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Operator_Glow_03")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(4, "There is no renderer with the name \"Operator_Glow_04\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Operator_Glow_04")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[1]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"DroneTech_Body\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "DroneTech_Body")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Operator Body.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"DroneTech_Body\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "DroneTech_Body")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddVoidSurvivorBodyVoidGregorDefSkin()
	{
		string text = "VoidSurvivorBody";
		string text2 = "Void GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Void GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_VOID_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: 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)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: 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_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_024d: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0257: 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_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_030f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0310: Unknown result type (might be due to invalid IL or missing references)
				//IL_0319: Unknown result type (might be due to invalid IL or missing references)
				//IL_0370: Unknown result type (might be due to invalid IL or missing references)
				//IL_0371: Unknown result type (might be due to invalid IL or missing references)
				//IL_037b: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03de: Unknown result type (might be due to invalid IL or missing references)
				//IL_0436: Unknown result type (might be due to invalid IL or missing references)
				//IL_0437: Unknown result type (might be due to invalid IL or missing references)
				//IL_0441: Unknown result type (might be due to invalid IL or missing references)
				//IL_0499: Unknown result type (might be due to invalid IL or missing references)
				//IL_049a: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[12]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"mdlVoidSurvivorMetal\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "mdlVoidSurvivorMetal")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"metalcollar.001\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "metalcollar.001")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(2, "There is no renderer with the name \"Goo, World\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Goo, World")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(3, "There is no renderer with the name \"Goo, Local\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Goo, Local")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(4, "There is no renderer with the name \"Vacuum Radial\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Vacuum Radial")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(5, "There is no renderer with the name \"Vacuum Radial\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Vacuum Radial")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(6, "There is no renderer with the name \"Vacuum Stars\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Vacuum Stars")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(7, "There is no renderer with the name \"Vacuum Stars\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Vacuum Stars")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(8, "There is no renderer with the name \"Smoke\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Smoke")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(9, "There is no renderer with the name \"Debris\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Debris")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(10, "There is no renderer with the name \"Dust\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Dust")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(11, "There is no renderer with the name \"Sparks\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Sparks")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: 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)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[3]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"Core\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Core")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"mdlVoidSurvivorHead\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "mdlVoidSurvivorHead")))
					},
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(2, "There is no renderer with the name \"mdlVoidSurvivorBody\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "mdlVoidSurvivorBody")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[2]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Void Arms.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"mdlVoidSurvivorBody\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "mdlVoidSurvivorBody")))
					},
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Void Head.mesh"),
						renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"mdlVoidSurvivorHead\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "mdlVoidSurvivorHead")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddTreebotBodyRexGregorDefSkin()
	{
		string text = "TreebotBody";
		string text2 = "Rex GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Rex GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_REX_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: 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)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[3]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"TreebotLeafletMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "TreebotLeafletMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"TreebotFlowerMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "TreebotFlowerMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(2, "There is no renderer with the name \"TreebotRootMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "TreebotRootMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[1]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"TreebotBotMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "TreebotBotMesh")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Spider.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"TreebotBotMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "TreebotBotMesh")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddDrifterBodyDrifterGregorDefSkin()
	{
		string text = "DrifterBody";
		string text2 = "Drifter GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Drifter GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_DRIFTER_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[2]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"meshBag\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshBag")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"meshJunk\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshJunk")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[1]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"meshDrifter\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshDrifter")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor Drifter Body.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"meshDrifter\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshDrifter")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddFalseSonBodyFalseSonGregorDefSkin()
	{
		string text = "FalseSonBody";
		string text2 = "False Son GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\False Son GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_FALSE_SON_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[2]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"FalseSon_Cloth\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "FalseSon_Cloth")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"L_FalseSon_Weapon\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "L_FalseSon_Weapon")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[1]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)2,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"FalseSon_Body\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "FalseSon_Body")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor False Body.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"FalseSon_Body\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "FalseSon_Body")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddToolbotBodyMulTGregorDefSkin()
	{
		string text = "ToolbotBody";
		string text2 = "MulT GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\MulT GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_MULT_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[2]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"SparkEmitter\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "SparkEmitter")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					},
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(1, "There is no renderer with the name \"RebarMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "RebarMesh")))).gameObject,
						shouldActivate = false,
						spawnPrefabOnModelObject = false
					}
				};
			});
			TryCatchThrow("Renderer Infos", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[1]
				{
					new RendererInfo
					{
						defaultMaterial = assetBundle.LoadAsset<Material>("Assets/Resources/Skin.mat"),
						defaultShadowCastingMode = (ShadowCastingMode)1,
						ignoreOverlays = true,
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"ToolbotMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "ToolbotMesh")))
					}
				};
			});
			TryCatchThrow("Mesh Replacements", delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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)
				skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
				{
					new MeshReplacement
					{
						mesh = assetBundle.LoadAsset<Mesh>("Assets\\SkinMods\\RiskOfGregor\\Meshes\\Gregor MulT Body.mesh"),
						renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"ToolbotMesh\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "ToolbotMesh")))
					}
				};
			});
			TryCatchThrow("Light Infos", delegate
			{
				skinParams.lightReplacements = (LightInfo[])(object)new LightInfo[0];
			});
			TryCatchThrow("Minion Skin Replacements", delegate
			{
				skinParams.minionSkinReplacements = Array.Empty<MinionSkinReplacement>();
			});
			TryCatchThrow("Projectile Ghost Replacements", delegate
			{
				skinParams.projectileGhostReplacements = Array.Empty<ProjectileGhostReplacement>();
			});
			Array.Resize(ref val2.skins, val2.skins.Length + 1);
			val2.skins[val2.skins.Length - 1] = skin;
		}
		catch (FieldException ex)
		{
			if (ex.InnerException is ElementException ex2)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
				InstanceLogger.LogWarning((object)ex2.Message);
				InstanceLogger.LogError((object)ex.InnerException);
			}
			else
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
				InstanceLogger.LogError((object)ex.InnerException);
			}
		}
		catch (Exception ex3)
		{
			InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
			InstanceLogger.LogError((object)ex3);
		}
	}

	private static void AddMageBodyArtificerGregorDefSkin()
	{
		string text = "MageBody";
		string text2 = "Artificer GregorDef";
		try
		{
			GameObject val = BodyCatalog.FindBodyPrefab(text);
			if (!Object.op_Implicit((Object)(object)val))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
				return;
			}
			ModelLocator component = val.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
				return;
			}
			GameObject gameObject = ((Component)component.modelTransform).gameObject;
			ModelSkinController val2 = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
				return;
			}
			Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
			gameObject.GetComponentsInChildren<Light>(true);
			SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
			SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
			skin.skinDefParams = skinParams;
			TryCatchThrow("Icon", delegate
			{
				skin.icon = assetBundle.LoadAsset<Sprite>("Assets\\SkinMods\\RiskOfGregor\\Icons\\Artificer GregorDefIcon.png");
			});
			((Object)skin).name = text2;
			skin.nameToken = "THE_REAL_GREGOR_SAMSA_SKIN_ARTIFICER_GREGORDEF_NAME";
			skin.rootObject = gameObject;
			TryCatchThrow("Base Skins", delegate
			{
				skin.baseSkins = Array.Empty<SkinDef>();
			});
			TryCatchThrow("Unlockable Name", delegate
			{
				skin.unlockableDef = null;
			});
			TryCatchThrow("Game Object Activations", delegate
			{
				//IL_0010: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: 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_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				skinParams.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[5]
				{
					new GameObjectActivation
					{
						gameObject = ((Component)ThrowIfNull<Renderer>(0, "There is no renderer with the name \"Fire\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "Fire")))).gameObject,
						shouldActi