using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using PieceManager;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Vikingsoldrepublicexp")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Azathoth")]
[assembly: AssemblyProduct("Vikingsoldrepublicexp")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		private readonly string <Name>k__BackingField;

		public string Name => <Name>k__BackingField;

		public ExtensionMarkerAttribute(string name)
		{
			<Name>k__BackingField = name;
		}
	}
}
namespace Vikingsoldrepublicexp
{
	[BepInPlugin("Azathoth.Vikingsoldrepublicexp", "Vikingsoldrepublicexp", "1.0.0")]
	public class VikingsoldrepublicexpPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string? Category;

			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;
		}

		internal const string ModName = "Vikingsoldrepublicexp";

		internal const string ModVersion = "1.0.0";

		internal const string Author = "Azathoth";

		private const string ModGUID = "Azathoth.Vikingsoldrepublicexp";

		private static string ConfigFileName = "Azathoth.Vikingsoldrepublicexp.cfg";

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

		private readonly Harmony _harmony = new Harmony("Azathoth.Vikingsoldrepublicexp");

		public static readonly ManualLogSource VikingsoldrepublicexpLogger;

		private static readonly ConfigSync ConfigSync;

		private static ConfigEntry<Toggle> _serverConfigLocked;

		private static ConfigEntry<Toggle> _recipeIsActiveConfig;

		public void Awake()
		{
			_serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			Item item = new Item("starwarsarmadurasexp", "STA_C3POHELMET");
			item.Name.English("C-3PO Head");
			item.Name.Spanish("Cabeza de C-3PO");
			item.Description.English("The golden head plating of a protocol droid. Equip it together with the C-3PO chest and legs to assume the appearance of C-3PO.");
			item.Description.Spanish("El revestimiento dorado de la cabeza de un droide de protocolo. Equípalo junto con el torso y las piernas de C-3PO para adoptar la apariencia de C-3PO.");
			item.Crafting.Add("ForjaEstelar", 2);
			item.RequiredItems.Add("Bronze", 3);
			item.RequiredItems.Add("ORV_Plastoide", 116);
			item.RequiredItems.Add("Iron", 2);
			item.RequiredItems.Add("Copper", 3);
			item.RequiredUpgradeItems.Add("Bronze", 2);
			item.RequiredUpgradeItems.Add("ORV_Plastoide", 1);
			item.RequiredUpgradeItems.Add("Iron", 1);
			item.CraftAmount = 1;
			_recipeIsActiveConfig = config("STA_C3POHELMET", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			Item item2 = new Item("starwarsarmadurasexp", "STA_C3POLEGS");
			item2.Name.English("C-3PO Legs");
			item2.Name.Spanish("Piernas de C-3PO");
			item2.Description.English("The articulated golden legs of a protocol droid. Equip them together with the C-3PO head and chest to assume the appearance of C-3PO.");
			item2.Description.Spanish("Las piernas doradas articuladas de un droide de protocolo. Equípalas junto con la cabeza y el torso de C-3PO para adoptar la apariencia de C-3PO.");
			item2.Crafting.Add("ForjaEstelar", 2);
			item2.RequiredItems.Add("Bronze", 5);
			item2.RequiredItems.Add("ORV_Plastoide", 114);
			item2.RequiredItems.Add("Iron", 4);
			item2.RequiredItems.Add("Copper", 4);
			item2.RequiredUpgradeItems.Add("Bronze", 3);
			item2.RequiredUpgradeItems.Add("ORV_Plastoide", 2);
			item2.RequiredUpgradeItems.Add("Iron", 2);
			item2.CraftAmount = 1;
			_recipeIsActiveConfig = config("STA_C3POLEGS", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item2.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			Item item3 = new Item("starwarsarmadurasexp", "STA_C3POCHEST");
			item3.Name.English("C-3PO Body");
			item3.Name.Spanish("Cuerpo de C-3PO");
			item3.Description.English("The golden torso plating of a protocol droid. Equip it together with the C-3PO head and legs to assume the appearance of C-3PO.");
			item3.Description.Spanish("El revestimiento dorado del torso de un droide de protocolo. Equípalo junto con la cabeza y las piernas de C-3PO para adoptar la apariencia de C-3PO.");
			item3.Crafting.Add("ForjaEstelar", 2);
			item3.RequiredItems.Add("Bronze", 5);
			item3.RequiredItems.Add("ORV_Plastoide", 116);
			item3.RequiredItems.Add("Iron", 4);
			item3.RequiredItems.Add("Copper", 5);
			item3.RequiredUpgradeItems.Add("Bronze", 3);
			item3.RequiredUpgradeItems.Add("ORV_Plastoide", 2);
			item3.RequiredUpgradeItems.Add("Iron", 2);
			item3.CraftAmount = 1;
			_recipeIsActiveConfig = config("STA_C3POCHEST", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item3.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			Item item4 = new Item("wookiearmor", "STA_WookibodyHead");
			item4.Name.English("Wookiee Head");
			item4.Name.Spanish("Cabeza de Wookiee");
			item4.Description.English("The head of a Wookiee. Equip it together with the Wookiee body and legs to assume the form of a Wookiee.");
			item4.Description.Spanish("La cabeza de un Wookiee. Equípala junto con el cuerpo y las piernas Wookiee para adoptar la forma de un Wookiee.");
			item4.Crafting.Add("ForjaEstelar", 2);
			item4.RequiredItems.Add("TrollHide", 4);
			item4.RequiredItems.Add("Bronze", 3);
			item4.RequiredItems.Add("ORV_Plastoide", 116);
			item4.RequiredItems.Add("DeerHide", 4);
			item4.RequiredUpgradeItems.Add("TrollHide", 2);
			item4.RequiredUpgradeItems.Add("ORV_Plastoide", 1);
			item4.RequiredUpgradeItems.Add("BoneFragments", 3);
			item4.CraftAmount = 1;
			_recipeIsActiveConfig = config("STA_WookibodyHead", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item4.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("wookiearmor", "STA_WookibodyLegs");
			item5.Name.English("Wookiee Legs");
			item5.Name.Spanish("Piernas de Wookiee");
			item5.Description.English("The powerful legs of a Wookiee. Equip them together with the Wookiee head and body to assume the form of a Wookiee.");
			item5.Description.Spanish("Las poderosas piernas de un Wookiee. Equípalas junto con la cabeza y el cuerpo Wookiee para adoptar la forma de un Wookiee.");
			item5.Crafting.Add("ForjaEstelar", 2);
			item5.RequiredItems.Add("TrollHide", 8);
			item5.RequiredItems.Add("Bronze", 5);
			item5.RequiredItems.Add("ORV_Plastoide", 114);
			item5.RequiredItems.Add("DeerHide", 6);
			item5.RequiredUpgradeItems.Add("TrollHide", 4);
			item5.RequiredUpgradeItems.Add("ORV_Plastoide", 2);
			item5.RequiredUpgradeItems.Add("FineWood", 2);
			item5.CraftAmount = 1;
			_recipeIsActiveConfig = config("STA_WookibodyLegs", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item5.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("wookiearmor", "STA_WookibodyArmor");
			item6.Name.English("Wookiee Body");
			item6.Name.Spanish("Cuerpo de Wookiee");
			item6.Description.English("The body of a Wookiee. Equip it together with the Wookiee head and legs to assume the form of a Wookiee.");
			item6.Description.Spanish("El cuerpo de un Wookiee. Equípalo junto con la cabeza y las piernas Wookiee para adoptar la forma de un Wookiee.");
			item6.Crafting.Add("ForjaEstelar", 2);
			item6.RequiredItems.Add("TrollHide", 8);
			item6.RequiredItems.Add("Bronze", 5);
			item6.RequiredItems.Add("ORV_Plastoide", 116);
			item6.RequiredItems.Add("DeerHide", 6);
			item6.RequiredUpgradeItems.Add("TrollHide", 4);
			item6.RequiredUpgradeItems.Add("ORV_Plastoide", 2);
			item6.RequiredUpgradeItems.Add("FineWood", 3);
			item6.CraftAmount = 1;
			_recipeIsActiveConfig = config("STA_WookibodyArmor", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item6.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("starwarsamors", "STA_BolsoWookie");
			item7.Name.English("Wookiee Hunter's Satchel");
			item7.Name.Spanish("Bolso de Cazador Wookiee");
			item7.Description.English("A rugged Wookiee field satchel crafted from hides, leather and reinforced fittings. Built to endure long hunts beneath the ancient forests of Kashyyyk.");
			item7.Description.Spanish("Un resistente bolso de campaña Wookiee fabricado con pieles, cuero y refuerzos metálicos. Creado para soportar largas cacerías bajo los antiguos bosques de Kashyyyk.");
			item7.Crafting.Add("ForjaEstelar", 2);
			item7.RequiredItems.Add("Iron", 8);
			item7.RequiredItems.Add("DeerHide", 10);
			item7.RequiredItems.Add("LeatherScraps", 8);
			item7.RequiredItems.Add("FineWood", 6);
			item7.RequiredUpgradeItems.Add("Iron", 3);
			item7.RequiredUpgradeItems.Add("DeerHide", 4);
			item7.RequiredUpgradeItems.Add("LeatherScraps", 4);
			item7.CraftAmount = 1;
			SharedData shared = item7.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
			shared.m_maxQuality = 4;
			_recipeIsActiveConfig = config("STA_BolsoWookie", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item7.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			Item item8 = new Item("starwarsamors", "STA_WookieWarrioramulet");
			item8.Name.English("Wookiee Warrior Relic");
			item8.Name.Spanish("Reliquia del Guerrero Wookiee");
			item8.Description.English("An ancestral Wookiee artifact preserving the memory of an ancient warrior's battle armor. When worn, the relic manifests the ceremonial war attire once carried by the warriors of Kashyyyk.");
			item8.Description.Spanish("Un artefacto ancestral Wookiee que conserva la memoria de la armadura de un antiguo guerrero. Al portarlo, la reliquia manifiesta la indumentaria de guerra ceremonial utilizada por los guerreros de Kashyyyk.");
			item8.Crafting.Add("ForjaEstelar", 2);
			item8.RequiredItems.Add("Iron", 20);
			item8.RequiredItems.Add("TrollHide", 8);
			item8.RequiredItems.Add("FineWood", 12);
			item8.RequiredItems.Add("DeerHide", 8);
			item8.CraftAmount = 1;
			item8.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality = 1;
			_recipeIsActiveConfig = config("STA_WookieWarrioramulet", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item8.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			Item item9 = new Item("starwarsamors", "STA_KashyyykWarriorAmulete");
			item9.Name.English("Kashyyyk Warrior Relic");
			item9.Name.Spanish("Reliquia del Guerrero de Kashyyyk");
			item9.Description.English("A revered artifact of Kashyyyk's warrior clans. Its ancient bindings preserve the form of a hardened Wookiee battle harness, carrying the legacy of generations who defended the great Wroshyr forests.");
			item9.Description.Spanish("Un venerado artefacto de los clanes guerreros de Kashyyyk. Sus antiguos vínculos conservan la forma de una poderosa armadura de combate Wookiee y el legado de generaciones que defendieron los grandes bosques Wroshyr.");
			item9.Crafting.Add("ForjaEstelar", 4);
			item9.RequiredItems.Add("BlackMetal", 25);
			item9.RequiredItems.Add("LoxPelt", 8);
			item9.RequiredItems.Add("LinenThread", 15);
			item9.RequiredItems.Add("FineWood", 12);
			item9.CraftAmount = 1;
			item9.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality = 1;
			_recipeIsActiveConfig = config("STA_KashyyykWarriorAmulete", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item9.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			Item item10 = new Item("starwarsamors", "STA_ShyyoWarriorAmulete");
			item10.Name.English("Shyyyo Warrior Relic");
			item10.Name.Spanish("Reliquia del Guerrero Shyyyo");
			item10.Description.English("A legendary Wookiee artifact associated with warriors who followed the spirit of the great Shyyyo bird. Its ancient power manifests an imposing ceremonial battle armor reserved for the mightiest champions of Kashyyyk.");
			item10.Description.Spanish("Un legendario artefacto Wookiee asociado a guerreros que seguían el espíritu del gran pájaro Shyyyo. Su antiguo poder manifiesta una imponente armadura ceremonial reservada para los campeones más poderosos de Kashyyyk.");
			item10.Crafting.Add("ForjaEstelar", 6);
			item10.RequiredItems.Add("FlametalNew", 25);
			item10.RequiredItems.Add("BlackMetal", 15);
			item10.RequiredItems.Add("CharredBone", 12);
			item10.RequiredItems.Add("LoxPelt", 8);
			item10.CraftAmount = 1;
			item10.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality = 1;
			_recipeIsActiveConfig = config("STA_ShyyoWarriorAmulete", "IsRecipeEnabled", Toggle.On, "Determines if the recipe is enabled for this prefab");
			item10.RecipeIsActive = (ConfigEntryBase?)(object)_recipeIsActiveConfig;
			MaterialReplacer.RegisterWookieeArmorForShaderSwap(item8.Prefab);
			MaterialReplacer.RegisterWookieeArmorForShaderSwap(item9.Prefab);
			MaterialReplacer.RegisterWookieeArmorForShaderSwap(item10.Prefab);
			MaterialReplacer.RegisterWookieeArmorForShaderSwap(item7.Prefab);
			GameObject val = PrefabManager.RegisterPrefab("wookiearmor", "sfx_SonidoWookie");
			starwarsexphiden.Init(((BaseUnityPlugin)this).Logger);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				VikingsoldrepublicexpLogger.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				VikingsoldrepublicexpLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				VikingsoldrepublicexpLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			SyncedConfigEntry<T> syncedConfigEntry = ConfigSync.AddConfigEntry<T>(val2);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		static VikingsoldrepublicexpPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			VikingsoldrepublicexpLogger = Logger.CreateLogSource("Vikingsoldrepublicexp");
			ConfigSync = new ConfigSync("Azathoth.Vikingsoldrepublicexp")
			{
				DisplayName = "Vikingsoldrepublicexp",
				CurrentVersion = "1.0.0",
				MinimumRequiredVersion = "1.0.0"
			};
			_serverConfigLocked = null;
			_recipeIsActiveConfig = null;
		}
	}
	public static class KeyboardExtensions
	{
		[SpecialName]
		public sealed class <G>$8D1D3E80A18AA9715780B6CB7003B2F1
		{
			[SpecialName]
			public static class <M>$895AB635D4D087636CF1C26BA650BA11
			{
			}

			[ExtensionMarker("<M>$895AB635D4D087636CF1C26BA650BA11")]
			public bool IsKeyDown()
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$895AB635D4D087636CF1C26BA650BA11")]
			public bool IsKeyHeld()
			{
				throw new NotSupportedException();
			}
		}

		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}
	}
	internal static class starwarsexphiden
	{
		private static readonly Dictionary<int, int[]> BonesByItemHash = new Dictionary<int, int[]>();

		private static ManualLogSource? _log;

		private static bool _initialized;

		public static void Init(ManualLogSource log)
		{
			if (!_initialized)
			{
				_initialized = true;
				_log = log;
				LoadEmbeddedProfiles();
				_log.LogInfo((object)$"Star Wars EXP body hiding profiles loaded: {BonesByItemHash.Count}");
			}
		}

		internal static bool TryGetBones(int itemHash, out int[] bones)
		{
			return BonesByItemHash.TryGetValue(itemHash, out bones) && bones.Length != 0;
		}

		internal static void RefreshEquipmentHash(VisEquipment vis, BodyHidingSlot slot, int itemHash)
		{
			if (!((Object)(object)vis == (Object)null) && vis.m_isPlayer)
			{
				StarWarsExpBodyHidingController orCreateController = GetOrCreateController(vis);
				orCreateController.Setup(vis);
				orCreateController.SetHash(slot, itemHash);
				orCreateController.FullUpdate();
			}
		}

		internal static void Refresh(VisEquipment vis)
		{
			if (!((Object)(object)vis == (Object)null) && vis.m_isPlayer)
			{
				StarWarsExpBodyHidingController orCreateController = GetOrCreateController(vis);
				orCreateController.Setup(vis);
				orCreateController.FullUpdate();
			}
		}

		private static StarWarsExpBodyHidingController GetOrCreateController(VisEquipment vis)
		{
			StarWarsExpBodyHidingController starWarsExpBodyHidingController = ((Component)vis).GetComponent<StarWarsExpBodyHidingController>();
			if ((Object)(object)starWarsExpBodyHidingController == (Object)null)
			{
				starWarsExpBodyHidingController = ((Component)vis).gameObject.AddComponent<StarWarsExpBodyHidingController>();
			}
			return starWarsExpBodyHidingController;
		}

		private static void LoadEmbeddedProfiles()
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			foreach (string item in from name in executingAssembly.GetManifestResourceNames()
				where name.IndexOf(".BodyProfiles.bsmith.", StringComparison.OrdinalIgnoreCase) >= 0 && name.EndsWith(".cfg", StringComparison.OrdinalIgnoreCase)
				select name)
			{
				int num = item.LastIndexOf("bsmith.", StringComparison.OrdinalIgnoreCase);
				if (num < 0)
				{
					continue;
				}
				string text = item.Substring(num);
				string text2 = text.Substring("bsmith.".Length);
				if (text2.EndsWith(".cfg", StringComparison.OrdinalIgnoreCase))
				{
					text2 = text2.Substring(0, text2.Length - 4);
				}
				using Stream stream = executingAssembly.GetManifestResourceStream(item);
				if (stream == null)
				{
					continue;
				}
				using StreamReader streamReader = new StreamReader(stream);
				int[] array = ParseProfile(streamReader.ReadToEnd());
				if (array.Length != 0)
				{
					BonesByItemHash[StringExtensionMethods.GetStableHashCode(text2)] = array;
				}
			}
		}

		private static int[] ParseProfile(string cfg)
		{
			if (string.IsNullOrWhiteSpace(cfg))
			{
				return Array.Empty<int>();
			}
			List<int> list = new List<int>();
			string[] array = cfg.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.StartsWith("List", StringComparison.OrdinalIgnoreCase) && text2.Contains("="))
				{
					string[] array2 = text2.Substring(text2.IndexOf('=') + 1).Split(new char[1] { ';' });
					foreach (string text3 in array2)
					{
						list.AddRange(BodyPartBones(text3.Trim()));
					}
				}
				else
				{
					if (!text2.StartsWith("Bone List", StringComparison.OrdinalIgnoreCase) || !text2.Contains("="))
					{
						continue;
					}
					string[] array3 = text2.Substring(text2.IndexOf('=') + 1).Split(new char[1] { ';' });
					foreach (string text4 in array3)
					{
						if (int.TryParse(text4.Trim(), out var result))
						{
							list.Add(result);
						}
					}
				}
			}
			return list.Where((int bone) => bone >= 0).Distinct().ToArray();
		}

		private static int[] BodyPartBones(string part)
		{
			return part switch
			{
				"Head" => new int[3] { 4, 5, 6 }, 
				"Torso" => new int[6] { 0, 1, 2, 3, 7, 26 }, 
				"ArmUpperLeft" => new int[1] { 8 }, 
				"ArmLowerLeft" => new int[1] { 9 }, 
				"HandLeft" => Enumerable.Range(10, 17).ToArray(), 
				"ArmUpperRight" => new int[1] { 27 }, 
				"ArmLowerRight" => new int[1] { 28 }, 
				"HandRight" => Enumerable.Range(29, 16).ToArray(), 
				"LegUpperLeft" => new int[1] { 45 }, 
				"LegLowerLeft" => new int[1] { 46 }, 
				"FootLeft" => new int[2] { 47, 48 }, 
				"LegUpperRight" => new int[1] { 49 }, 
				"LegLowerRight" => new int[1] { 50 }, 
				"FootRight" => new int[2] { 51, 52 }, 
				"All" => Enumerable.Range(0, 53).ToArray(), 
				_ => Array.Empty<int>(), 
			};
		}
	}
	internal enum BodyHidingSlot
	{
		Chest,
		Legs,
		Helmet,
		Shoulder,
		Utility
	}
	internal sealed class StarWarsExpBodyHidingController : MonoBehaviour
	{
		private readonly Dictionary<BodyHidingSlot, int> _equippedHashes = new Dictionary<BodyHidingSlot, int>();

		private VisEquipment? _vis;

		private Mesh?[]? _originalMeshes;

		private Mesh?[]? _sourceMeshes;

		private Mesh?[]? _generatedMeshes;

		private int _lastBonesHash = int.MinValue;

		private int _lastModelIndex = -1;

		internal void Setup(VisEquipment vis)
		{
			if ((Object)(object)vis == (Object)null)
			{
				return;
			}
			_vis = vis;
			if (_originalMeshes != null || vis.m_models == null)
			{
				return;
			}
			_originalMeshes = (Mesh?[]?)(object)new Mesh[vis.m_models.Length];
			_sourceMeshes = (Mesh?[]?)(object)new Mesh[vis.m_models.Length];
			_generatedMeshes = (Mesh?[]?)(object)new Mesh[vis.m_models.Length];
			for (int i = 0; i < vis.m_models.Length; i++)
			{
				if ((Object)(object)vis.m_models[i].m_mesh != (Object)null)
				{
					_originalMeshes[i] = Object.Instantiate<Mesh>(vis.m_models[i].m_mesh);
				}
			}
		}

		internal void SetHash(BodyHidingSlot slot, int itemHash)
		{
			if (itemHash == 0)
			{
				_equippedHashes.Remove(slot);
			}
			else
			{
				_equippedHashes[slot] = itemHash;
			}
		}

		internal void FullUpdate()
		{
			if ((Object)(object)_vis == (Object)null || _originalMeshes == null || _sourceMeshes == null || _generatedMeshes == null || _vis.m_models == null)
			{
				return;
			}
			int num = Mathf.Clamp(_vis.GetModelIndex(), 0, _vis.m_models.Length - 1);
			int[] activeBones = GetActiveBones();
			if (activeBones.Length == 0)
			{
				Restore(num);
				_lastBonesHash = 0;
				_lastModelIndex = num;
				return;
			}
			int hash = GetHash(activeBones);
			bool flag = (Object)(object)_generatedMeshes[num] == (Object)null || (Object)(object)_vis.m_models[num].m_mesh != (Object)(object)_generatedMeshes[num];
			if (_lastBonesHash != hash || _lastModelIndex != num || flag)
			{
				Apply(num, activeBones);
				_lastBonesHash = hash;
				_lastModelIndex = num;
			}
		}

		private int[] GetActiveBones()
		{
			HashSet<int> hashSet = new HashSet<int>();
			foreach (int value in _equippedHashes.Values)
			{
				if (starwarsexphiden.TryGetBones(value, out int[] bones))
				{
					int[] array = bones;
					foreach (int item in array)
					{
						hashSet.Add(item);
					}
				}
			}
			return hashSet.OrderBy((int bone) => bone).ToArray();
		}

		private void Apply(int modelIndex, int[] bones)
		{
			if ((Object)(object)_vis == (Object)null || _originalMeshes == null || _sourceMeshes == null || _generatedMeshes == null)
			{
				return;
			}
			Mesh applySource = GetApplySource(modelIndex);
			if ((Object)(object)applySource == (Object)null || !applySource.isReadable)
			{
				return;
			}
			Mesh val = _generatedMeshes[modelIndex];
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)val);
			}
			Mesh val2 = Object.Instantiate<Mesh>(applySource);
			((Object)val2).name = ((Object)applySource).name;
			BoneWeight[] boneWeights = val2.boneWeights;
			HashSet<int> hidden = new HashSet<int>(bones);
			for (int i = 0; i < val2.subMeshCount; i++)
			{
				List<int> list = new List<int>();
				int[] triangles = val2.GetTriangles(i);
				for (int j = 0; j + 2 < triangles.Length; j += 3)
				{
					if (!TriangleBelongsToHiddenBone(triangles, j, boneWeights, hidden))
					{
						list.Add(triangles[j]);
						list.Add(triangles[j + 1]);
						list.Add(triangles[j + 2]);
					}
				}
				val2.SetTriangles(list, i);
			}
			_sourceMeshes[modelIndex] = applySource;
			_generatedMeshes[modelIndex] = val2;
			_vis.m_models[modelIndex].m_mesh = val2;
		}

		private Mesh? GetApplySource(int modelIndex)
		{
			if ((Object)(object)_vis == (Object)null || _originalMeshes == null || _sourceMeshes == null || _generatedMeshes == null)
			{
				return null;
			}
			Mesh mesh = _vis.m_models[modelIndex].m_mesh;
			Mesh val = _originalMeshes[modelIndex];
			Mesh val2 = _generatedMeshes[modelIndex];
			if ((Object)(object)mesh == (Object)(object)val2 && (Object)(object)_sourceMeshes[modelIndex] != (Object)null)
			{
				return _sourceMeshes[modelIndex];
			}
			if ((Object)(object)mesh != (Object)null && (Object)(object)mesh != (Object)(object)val2 && (Object)(object)mesh != (Object)(object)val)
			{
				return mesh;
			}
			return val;
		}

		private void Restore(int modelIndex)
		{
			if ((Object)(object)_vis == (Object)null || _originalMeshes == null || _sourceMeshes == null || _generatedMeshes == null || modelIndex < 0 || modelIndex >= _originalMeshes.Length || (Object)(object)_originalMeshes[modelIndex] == (Object)null)
			{
				return;
			}
			Mesh val = _generatedMeshes[modelIndex];
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)_vis.m_models[modelIndex].m_mesh == (Object)(object)val)
				{
					_vis.m_models[modelIndex].m_mesh = _sourceMeshes[modelIndex] ?? _originalMeshes[modelIndex];
				}
				Object.Destroy((Object)(object)val);
				_sourceMeshes[modelIndex] = null;
				_generatedMeshes[modelIndex] = null;
			}
		}

		private static bool TriangleBelongsToHiddenBone(int[] triangles, int start, BoneWeight[] weights, HashSet<int> hidden)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 3; i++)
			{
				BoneWeight val = weights[triangles[start + i]];
				float num = Mathf.Max(new float[4]
				{
					((BoneWeight)(ref val)).weight0,
					((BoneWeight)(ref val)).weight1,
					((BoneWeight)(ref val)).weight2,
					((BoneWeight)(ref val)).weight3
				});
				if (!(num <= 0f) && ((hidden.Contains(((BoneWeight)(ref val)).boneIndex0) && ((BoneWeight)(ref val)).weight0 / num > 0.9f) || (hidden.Contains(((BoneWeight)(ref val)).boneIndex1) && ((BoneWeight)(ref val)).weight1 / num > 0.9f) || (hidden.Contains(((BoneWeight)(ref val)).boneIndex2) && ((BoneWeight)(ref val)).weight2 / num > 0.9f) || (hidden.Contains(((BoneWeight)(ref val)).boneIndex3) && ((BoneWeight)(ref val)).weight3 / num > 0.9f)))
				{
					return true;
				}
			}
			return false;
		}

		private static int GetHash(IEnumerable<int> bones)
		{
			int num = 17;
			foreach (int bone in bones)
			{
				num = num * 31 + bone;
			}
			return num;
		}
	}
	[HarmonyPatch]
	internal static class StarWarsExpBodyHidingPatches
	{
		private static void RefreshHash(VisEquipment vis, BodyHidingSlot slot, int hash, bool result)
		{
			if (result)
			{
				starwarsexphiden.RefreshEquipmentHash(vis, slot, hash);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "Awake")]
		[HarmonyPostfix]
		private static void OnVisEquipmentAwake(VisEquipment __instance)
		{
			starwarsexphiden.Refresh(__instance);
		}

		[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void OnEquipmentVisualsUpdated(VisEquipment __instance)
		{
			starwarsexphiden.Refresh(__instance);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetRightHandEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void AfterRightHand(VisEquipment __instance)
		{
			starwarsexphiden.Refresh(__instance);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLeftHandEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void AfterLeftHand(VisEquipment __instance)
		{
			starwarsexphiden.Refresh(__instance);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void AfterChest(VisEquipment __instance, int hash, bool __result)
		{
			RefreshHash(__instance, BodyHidingSlot.Chest, hash, __result);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void AfterLegs(VisEquipment __instance, int hash, bool __result)
		{
			RefreshHash(__instance, BodyHidingSlot.Legs, hash, __result);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetHelmetEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void AfterHelmet(VisEquipment __instance, int hash, bool __result)
		{
			RefreshHash(__instance, BodyHidingSlot.Helmet, hash, __result);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void AfterShoulder(VisEquipment __instance, int hash, bool __result)
		{
			RefreshHash(__instance, BodyHidingSlot.Shoulder, hash, __result);
		}

		[HarmonyPatch(typeof(VisEquipment), "SetUtilityEquipped")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void AfterUtility(VisEquipment __instance, int hash, bool __result)
		{
			RefreshHash(__instance, BodyHidingSlot.Utility, hash, __result);
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("Vikingsoldrepublicexp_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_Vikingsoldrepublicexp_Version);
			VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogInfo((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("1.0.0");
			peer.m_rpc.Invoke("Vikingsoldrepublicexp_VersionCheck", new object[1] { val });
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") never sent version or couldn't due to previous disconnect, disconnecting"));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}

		private static void Postfix(ZNet __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "VikingsoldrepublicexpRequestAdminSync", new object[1] { (object)new ZPackage() });
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		private static void Postfix(FejdStartup __instance)
		{
			if (__instance.m_connectionFailedPanel.activeSelf)
			{
				__instance.m_connectionFailedError.fontSizeMax = 25f;
				__instance.m_connectionFailedError.fontSizeMin = 15f;
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + VikingsoldrepublicexpPlugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogInfo((object)("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list"));
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_Vikingsoldrepublicexp_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogInfo((object)("Version check, local: 1.0.0,  remote: " + text));
			if (text != "1.0.0")
			{
				VikingsoldrepublicexpPlugin.ConnectionError = "Vikingsoldrepublicexp Installed: 1.0.0\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!ZNet.instance.IsServer())
			{
				VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogInfo((object)"Received same version from server!");
			}
			else
			{
				VikingsoldrepublicexpPlugin.VikingsoldrepublicexpLogger.LogInfo((object)("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}

		public static string ComputeHashForMod()
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(File.ReadAllBytes(Assembly.GetExecutingAssembly().Location));
			StringBuilder stringBuilder = new StringBuilder();
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("X2"));
			}
			return stringBuilder.ToString();
		}
	}
	internal sealed class WookieSetScaleController : MonoBehaviour
	{
		internal const string HeadPrefabName = "STA_WookibodyHead";

		internal const string ChestPrefabName = "STA_WookibodyArmor";

		internal const string LegsPrefabName = "STA_WookibodyLegs";

		internal const float WookieWorldScale = 1.5f;

		private static readonly int WookieSetActiveHash = StringExtensionMethods.GetStableHashCode("VSR_WookieFullSetActive");

		private const float OwnerCheckInterval = 0.15f;

		private const float RemoteRefreshInterval = 0.2f;

		private Player m_player;

		private ZNetView m_nview;

		private Transform m_visualTransform;

		private Vector3 m_baseVisualLocalScale = Vector3.one;

		private bool m_scaleApplied;

		private float m_nextOwnerCheck;

		private float m_nextRemoteRefresh;

		private bool m_lastSyncedSetState;

		private bool m_hasSyncedState;

		private void Awake()
		{
			CacheReferences();
		}

		private void Start()
		{
			CacheReferences();
			Refresh(force: true);
		}

		private void Update()
		{
			if (CacheReferences())
			{
				if (((Character)m_player).IsDead())
				{
					ApplyWookieScale(active: false);
				}
				else if ((Object)(object)Player.m_localPlayer == (Object)(object)m_player && (Object)(object)m_nview != (Object)null && m_nview.IsValid() && m_nview.IsOwner() && Time.time >= m_nextOwnerCheck)
				{
					m_nextOwnerCheck = Time.time + 0.15f;
					bool active = HasCompleteWookieSet(m_player);
					WriteSetState(active);
					ApplyWookieScale(active);
				}
				else if (Time.time >= m_nextRemoteRefresh)
				{
					m_nextRemoteRefresh = Time.time + 0.2f;
					Refresh(force: false);
				}
			}
		}

		internal void RequestImmediateRefresh()
		{
			m_nextOwnerCheck = 0f;
			m_nextRemoteRefresh = 0f;
			Refresh(force: true);
		}

		private void Refresh(bool force)
		{
			if (!CacheReferences())
			{
				return;
			}
			if (((Character)m_player).IsDead())
			{
				ApplyWookieScale(active: false);
				return;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)(object)m_player && (Object)(object)m_nview != (Object)null && m_nview.IsValid() && m_nview.IsOwner())
			{
				bool active = HasCompleteWookieSet(m_player);
				WriteSetState(active);
				ApplyWookieScale(active);
				return;
			}
			if ((Object)(object)m_nview == (Object)null || !m_nview.IsValid())
			{
				if (force)
				{
					ApplyWookieScale(active: false);
				}
				return;
			}
			ZDO zDO = m_nview.GetZDO();
			if (zDO != null)
			{
				bool active2 = zDO.GetBool(WookieSetActiveHash, false);
				ApplyWookieScale(active2);
			}
		}

		private bool CacheReferences()
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_player == (Object)null)
			{
				m_player = ((Component)this).GetComponent<Player>();
			}
			if ((Object)(object)m_nview == (Object)null && (Object)(object)m_player != (Object)null)
			{
				m_nview = (((Object)(object)((Character)m_player).m_nview != (Object)null) ? ((Character)m_player).m_nview : ((Component)this).GetComponent<ZNetView>());
			}
			Transform val = null;
			if ((Object)(object)m_player != (Object)null && (Object)(object)((Character)m_player).m_visual != (Object)null)
			{
				val = ((Character)m_player).m_visual.transform;
			}
			if ((Object)(object)val != (Object)(object)m_visualTransform)
			{
				RestorePreviousVisual();
				m_visualTransform = val;
				if ((Object)(object)m_visualTransform != (Object)null)
				{
					m_baseVisualLocalScale = m_visualTransform.localScale;
				}
				m_scaleApplied = false;
			}
			return (Object)(object)m_player != (Object)null && (Object)(object)m_visualTransform != (Object)null;
		}

		private void WriteSetState(bool active)
		{
			if (!((Object)(object)m_nview == (Object)null) && m_nview.IsValid() && m_nview.IsOwner())
			{
				ZDO zDO = m_nview.GetZDO();
				if (zDO != null && (!m_hasSyncedState || m_lastSyncedSetState != active))
				{
					zDO.Set(WookieSetActiveHash, active);
					m_lastSyncedSetState = active;
					m_hasSyncedState = true;
				}
			}
		}

		private void ApplyWookieScale(bool active)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_visualTransform == (Object)null)
			{
				return;
			}
			if (!active)
			{
				if (m_scaleApplied)
				{
					m_visualTransform.localScale = m_baseVisualLocalScale;
					m_scaleApplied = false;
				}
				else
				{
					m_baseVisualLocalScale = m_visualTransform.localScale;
				}
				return;
			}
			if (!m_scaleApplied)
			{
				m_baseVisualLocalScale = m_visualTransform.localScale;
				m_scaleApplied = true;
			}
			float num = Mathf.Abs(((Component)this).transform.lossyScale.x);
			if (num < 0.01f)
			{
				num = 1f;
			}
			float num2 = 1.5f / num;
			Vector3 val = m_baseVisualLocalScale * num2;
			Vector3 val2 = m_visualTransform.localScale - val;
			if (((Vector3)(ref val2)).sqrMagnitude > 1E-06f)
			{
				m_visualTransform.localScale = val;
			}
		}

		private void RestorePreviousVisual()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_visualTransform != (Object)null && m_scaleApplied)
			{
				m_visualTransform.localScale = m_baseVisualLocalScale;
			}
			m_scaleApplied = false;
		}

		private void OnDisable()
		{
			RestorePreviousVisual();
		}

		private void OnDestroy()
		{
			RestorePreviousVisual();
		}

		internal static bool HasCompleteWookieSet(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != null && allItem.m_equipped && !((Object)(object)allItem.m_dropPrefab == (Object)null))
				{
					switch (Utils.GetPrefabName(allItem.m_dropPrefab))
					{
					case "STA_WookibodyHead":
						flag = true;
						break;
					case "STA_WookibodyArmor":
						flag2 = true;
						break;
					case "STA_WookibodyLegs":
						flag3 = true;
						break;
					}
					if (flag && flag2 && flag3)
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class WookieSetScalePatches
	{
		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[HarmonyPostfix]
		private static void AddControllerToPlayerPrefab(FejdStartup __instance)
		{
			WookieSetScaleController wookieSetScaleController = default(WookieSetScaleController);
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.m_playerPrefab == (Object)null) && !__instance.m_playerPrefab.TryGetComponent<WookieSetScaleController>(ref wookieSetScaleController))
			{
				__instance.m_playerPrefab.AddComponent<WookieSetScaleController>();
			}
		}

		[HarmonyPatch(typeof(Player), "Awake")]
		[HarmonyPostfix]
		private static void EnsureControllerOnSpawnedPlayer(Player __instance)
		{
			WookieSetScaleController wookieSetScaleController = default(WookieSetScaleController);
			if (!((Object)(object)__instance == (Object)null) && !((Component)__instance).TryGetComponent<WookieSetScaleController>(ref wookieSetScaleController))
			{
				((Component)__instance).gameObject.AddComponent<WookieSetScaleController>();
			}
		}

		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		[HarmonyPostfix]
		private static void AfterEquip(Humanoid __instance, ItemData item)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			WookieSetScaleController wookieSetScaleController = default(WookieSetScaleController);
			if (val != null && item != null && IsWookiePiece(item) && ((Component)val).TryGetComponent<WookieSetScaleController>(ref wookieSetScaleController))
			{
				wookieSetScaleController.RequestImmediateRefresh();
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		[HarmonyPostfix]
		private static void AfterUnequip(Humanoid __instance, ItemData item)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			WookieSetScaleController wookieSetScaleController = default(WookieSetScaleController);
			if (val != null && item != null && IsWookiePiece(item) && ((Component)val).TryGetComponent<WookieSetScaleController>(ref wookieSetScaleController))
			{
				wookieSetScaleController.RequestImmediateRefresh();
			}
		}

		private static bool IsWookiePiece(ItemData item)
		{
			if (item == null || (Object)(object)item.m_dropPrefab == (Object)null)
			{
				return false;
			}
			string prefabName = Utils.GetPrefabName(item.m_dropPrefab);
			return prefabName == "STA_WookibodyHead" || prefabName == "STA_WookibodyArmor" || prefabName == "STA_WookibodyLegs";
		}
	}
}
namespace PieceManager
{
	[PublicAPI]
	public static class MaterialReplacer
	{
		public enum ShaderType
		{
			PieceShader,
			VegetationShader,
			RockShader,
			RugShader,
			GrassShader,
			CustomCreature,
			UseUnityShader,
			ToonDeferred
		}

		private static readonly Dictionary<GameObject, bool> ObjectToSwap;

		private static readonly Dictionary<string, Material> OriginalMaterials;

		private static readonly Dictionary<GameObject, ShaderType> ObjectsForShaderReplace;

		private static readonly HashSet<GameObject> ArmoredHumanoidShaderObjects;

		private static readonly HashSet<GameObject> FurCreatureShaderObjects;

		private static readonly HashSet<GameObject> SkeletonHammerShaderObjects;

		private static readonly HashSet<GameObject> DoubleSidedUseUnityShaderObjects;

		private static readonly HashSet<GameObject> StarwarsCharacterMaterialFixObjects;

		private static readonly HashSet<GameObject> WookieeRendererSplitFixObjects;

		private static readonly HashSet<GameObject> WookieeArmorShaderObjects;

		private static readonly Dictionary<Mesh, Mesh> BackfaceMeshCache;

		private static readonly HashSet<Mesh> BackfaceMeshWarnings;

		private static readonly Dictionary<GameObject, Color> LightsaberBladeObjects;

		private static readonly Dictionary<GameObject, Color> EmbeddedLightsaberBladeObjects;

		private static readonly Dictionary<GameObject, Color> EmissiveVfxObjects;

		private static readonly HashSet<Shader> CachedShaders;

		private static bool hasRun;

		static MaterialReplacer()
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			ArmoredHumanoidShaderObjects = new HashSet<GameObject>();
			FurCreatureShaderObjects = new HashSet<GameObject>();
			SkeletonHammerShaderObjects = new HashSet<GameObject>();
			DoubleSidedUseUnityShaderObjects = new HashSet<GameObject>();
			StarwarsCharacterMaterialFixObjects = new HashSet<GameObject>();
			WookieeRendererSplitFixObjects = new HashSet<GameObject>();
			WookieeArmorShaderObjects = new HashSet<GameObject>();
			BackfaceMeshCache = new Dictionary<Mesh, Mesh>();
			BackfaceMeshWarnings = new HashSet<Mesh>();
			LightsaberBladeObjects = new Dictionary<GameObject, Color>();
			EmbeddedLightsaberBladeObjects = new Dictionary<GameObject, Color>();
			EmissiveVfxObjects = new Dictionary<GameObject, Color>();
			CachedShaders = new HashSet<Shader>();
			hasRun = false;
			OriginalMaterials = new Dictionary<string, Material>();
			ObjectToSwap = new Dictionary<GameObject, bool>();
			ObjectsForShaderReplace = new Dictionary<GameObject, ShaderType>();
			Harmony val = new Harmony("org.bepinex.helpers.PieceManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZoneSystem), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(MaterialReplacer), "ReplaceAllMaterialsWithOriginal", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void RegisterGameObjectForShaderSwap(GameObject go, ShaderType type)
		{
			if (!((Object)(object)go == (Object)null))
			{
				if (!ObjectsForShaderReplace.ContainsKey(go))
				{
					ObjectsForShaderReplace.Add(go, type);
				}
				else
				{
					ObjectsForShaderReplace[go] = type;
				}
			}
		}

		public static void RegisterArmoredHumanoidForShaderSwap(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				FurCreatureShaderObjects.Remove(go);
				if (!ArmoredHumanoidShaderObjects.Contains(go))
				{
					ArmoredHumanoidShaderObjects.Add(go);
				}
				if (!ObjectsForShaderReplace.ContainsKey(go))
				{
					ObjectsForShaderReplace.Add(go, ShaderType.ToonDeferred);
				}
				else
				{
					ObjectsForShaderReplace[go] = ShaderType.ToonDeferred;
				}
			}
		}

		public static void RegisterFurCreatureForShaderSwap(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				if (!FurCreatureShaderObjects.Contains(go))
				{
					FurCreatureShaderObjects.Add(go);
				}
				if (!ObjectsForShaderReplace.ContainsKey(go))
				{
					ObjectsForShaderReplace.Add(go, ShaderType.CustomCreature);
				}
				else
				{
					ObjectsForShaderReplace[go] = ShaderType.CustomCreature;
				}
			}
		}

		public static void RegisterSkeletonHammerForShaderSwap(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				FurCreatureShaderObjects.Remove(go);
				if (!SkeletonHammerShaderObjects.Contains(go))
				{
					SkeletonHammerShaderObjects.Add(go);
				}
				if (!ObjectsForShaderReplace.ContainsKey(go))
				{
					ObjectsForShaderReplace.Add(go, ShaderType.CustomCreature);
				}
				else
				{
					ObjectsForShaderReplace[go] = ShaderType.CustomCreature;
				}
			}
		}

		public static void RegisterDoubleSidedUseUnityShader(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				FurCreatureShaderObjects.Remove(go);
				SkeletonHammerShaderObjects.Remove(go);
				StarwarsCharacterMaterialFixObjects.Remove(go);
				if (!DoubleSidedUseUnityShaderObjects.Contains(go))
				{
					DoubleSidedUseUnityShaderObjects.Add(go);
				}
				if (!ObjectsForShaderReplace.ContainsKey(go))
				{
					ObjectsForShaderReplace.Add(go, ShaderType.UseUnityShader);
				}
				else
				{
					ObjectsForShaderReplace[go] = ShaderType.UseUnityShader;
				}
			}
		}

		public static void RegisterWookieeFurFix(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				FurCreatureShaderObjects.Remove(go);
				SkeletonHammerShaderObjects.Remove(go);
				DoubleSidedUseUnityShaderObjects.Remove(go);
				StarwarsCharacterMaterialFixObjects.Remove(go);
				if (!WookieeRendererSplitFixObjects.Contains(go))
				{
					WookieeRendererSplitFixObjects.Add(go);
				}
				if (!ObjectsForShaderReplace.ContainsKey(go))
				{
					ObjectsForShaderReplace.Add(go, ShaderType.UseUnityShader);
				}
				else
				{
					ObjectsForShaderReplace[go] = ShaderType.UseUnityShader;
				}
			}
		}

		public static void RegisterStarwarsCharacterMaterialFix(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				FurCreatureShaderObjects.Remove(go);
				SkeletonHammerShaderObjects.Remove(go);
				DoubleSidedUseUnityShaderObjects.Remove(go);
				if (!StarwarsCharacterMaterialFixObjects.Contains(go))
				{
					StarwarsCharacterMaterialFixObjects.Add(go);
				}
				if (!ObjectsForShaderReplace.ContainsKey(go))
				{
					ObjectsForShaderReplace.Add(go, ShaderType.CustomCreature);
				}
				else
				{
					ObjectsForShaderReplace[go] = ShaderType.CustomCreature;
				}
			}
		}

		public static void RegisterWookieeArmorForShaderSwap(GameObject go)
		{
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				FurCreatureShaderObjects.Remove(go);
				SkeletonHammerShaderObjects.Remove(go);
				DoubleSidedUseUnityShaderObjects.Remove(go);
				StarwarsCharacterMaterialFixObjects.Remove(go);
				WookieeRendererSplitFixObjects.Remove(go);
				WookieeArmorShaderObjects.Add(go);
				ObjectsForShaderReplace[go] = ShaderType.CustomCreature;
			}
		}

		public static void RegisterLightsaberBlade(GameObject go, Color bladeColor)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				FurCreatureShaderObjects.Remove(go);
				SkeletonHammerShaderObjects.Remove(go);
				DoubleSidedUseUnityShaderObjects.Remove(go);
				StarwarsCharacterMaterialFixObjects.Remove(go);
				WookieeRendererSplitFixObjects.Remove(go);
				WookieeArmorShaderObjects.Remove(go);
				ObjectsForShaderReplace.Remove(go);
				LightsaberBladeObjects[go] = bladeColor;
			}
		}

		public static void RegisterEmbeddedLightsaberBlade(GameObject go, Color bladeColor)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)go == (Object)null))
			{
				EmbeddedLightsaberBladeObjects[go] = bladeColor;
			}
		}

		public static void RegisterEmissiveVfx(GameObject go, Color vfxColor)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)go == (Object)null))
			{
				ArmoredHumanoidShaderObjects.Remove(go);
				FurCreatureShaderObjects.Remove(go);
				SkeletonHammerShaderObjects.Remove(go);
				DoubleSidedUseUnityShaderObjects.Remove(go);
				StarwarsCharacterMaterialFixObjects.Remove(go);
				WookieeRendererSplitFixObjects.Remove(go);
				WookieeArmorShaderObjects.Remove(go);
				ObjectsForShaderReplace.Remove(go);
				EmissiveVfxObjects[go] = vfxColor;
			}
		}

		public static void RegisterGameObjectForMatSwap(GameObject go, bool isJotunnMock = false)
		{
			if (!((Object)(object)go == (Object)null) && !ObjectToSwap.ContainsKey(go))
			{
				ObjectToSwap.Add(go, isJotunnMock);
			}
		}

		private static void GetAllMaterials()
		{
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				OriginalMaterials[((Object)val).name] = val;
			}
		}

		[HarmonyPriority(700)]
		private static void ReplaceAllMaterialsWithOriginal()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)SystemInfo.graphicsDeviceType == 4 || hasRun)
			{
				return;
			}
			if (OriginalMaterials.Count == 0)
			{
				GetAllMaterials();
			}
			foreach (KeyValuePair<GameObject, bool> item in ObjectToSwap)
			{
				GameObject key = item.Key;
				bool value = item.Value;
				ProcessGameObjectMaterials(key, value);
			}
			AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
			AssetBundle[] array2 = array;
			foreach (AssetBundle val in array2)
			{
				IEnumerable<Shader> enumerable3;
				try
				{
					IEnumerable<Shader> enumerable2;
					if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
					{
						IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
						enumerable2 = enumerable;
					}
					else
					{
						enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
							where (Object)(object)shader != (Object)null
							select shader;
					}
					enumerable3 = enumerable2;
				}
				catch (Exception)
				{
					continue;
				}
				if (enumerable3 == null)
				{
					continue;
				}
				foreach (Shader item2 in enumerable3)
				{
					CachedShaders.Add(item2);
				}
			}
			foreach (KeyValuePair<GameObject, ShaderType> item3 in ObjectsForShaderReplace)
			{
				GameObject key2 = item3.Key;
				ShaderType value2 = item3.Value;
				ProcessGameObjectShaders(key2, value2);
			}
			foreach (KeyValuePair<GameObject, Color> lightsaberBladeObject in LightsaberBladeObjects)
			{
				ProcessLightsaberBladeMaterials(lightsaberBladeObject.Key, lightsaberBladeObject.Value);
			}
			foreach (KeyValuePair<GameObject, Color> embeddedLightsaberBladeObject in EmbeddedLightsaberBladeObjects)
			{
				ProcessLightsaberBladeMaterials(embeddedLightsaberBladeObject.Key, embeddedLightsaberBladeObject.Value, includeCylinderRenderers: true);
			}
			foreach (KeyValuePair<GameObject, Color> emissiveVfxObject in EmissiveVfxObjects)
			{
				ProcessEmissiveVfxMaterials(emissiveVfxObject.Key, emissiveVfxObject.Value);
			}
			hasRun = true;
		}

		private static void ProcessGameObjectMaterials(GameObject go, bool isJotunnMock)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials.Select((Material material) => ((Object)(object)material == (Object)null) ? null : ReplaceMaterial(material, isJotunnMock)).ToArray();
				val.sharedMaterials = sharedMaterials;
			}
		}

		private static Material ReplaceMaterial(Material originalMaterial, bool isJotunnMock)
		{
			if ((Object)(object)originalMaterial == (Object)null)
			{
				return null;
			}
			string text = (isJotunnMock ? "JVLmock_" : "_REPLACE_");
			if (!((Object)originalMaterial).name.StartsWith(text, StringComparison.Ordinal))
			{
				return originalMaterial;
			}
			string text2 = ((Object)originalMaterial).name.Replace(" (Instance)", "").Replace(text, "");
			if (OriginalMaterials.TryGetValue(text2, out Material value))
			{
				return value;
			}
			Debug.LogWarning((object)("No suitable material found to replace: " + text2));
			return originalMaterial;
		}

		private static void ProcessGameObjectShaders(GameObject go, ShaderType shaderType)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			if (WookieeArmorShaderObjects.Contains(go))
			{
				ProcessWookieeArmorShaders(go);
				return;
			}
			if (DoubleSidedUseUnityShaderObjects.Contains(go))
			{
				ProcessDoubleSidedUseUnityShader(go);
				return;
			}
			if (StarwarsCharacterMaterialFixObjects.Contains(go))
			{
				ProcessStarwarsCharacterMaterialShaders(go);
				return;
			}
			if (WookieeRendererSplitFixObjects.Contains(go))
			{
				ProcessWookieeRendererSplitFix(go);
				return;
			}
			if (SkeletonHammerShaderObjects.Contains(go))
			{
				ProcessSkeletonHammerShaders(go);
				return;
			}
			if (ArmoredHumanoidShaderObjects.Contains(go))
			{
				ProcessArmoredHumanoidShaders(go);
				return;
			}
			if (FurCreatureShaderObjects.Contains(go))
			{
				ProcessFurCreatureShaders(go);
				return;
			}
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						val2.shader = GetShaderForType(val2.shader, shaderType, ((Object)val2.shader).name);
					}
				}
			}
		}

		private static bool ShouldSkipRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return true;
			}
			string text = ((Object)renderer).name.ToLowerInvariant();
			return text.Contains("eyepos") || text.Contains("collider") || text.Contains("hitbox") || text.Contains("ragdoll") || text.Contains("trigger") || text.Contains("starwarsbackface");
		}

		private static void ProcessDoubleSidedUseUnityShader(GameObject go)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (ShouldSkipRenderer(val))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				bool flag = false;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null))
					{
						Material val3 = new Material(val2)
						{
							name = ((Object)val2).name + "_StarwarsUnityDoubleSided"
						};
						val3.shader = GetShaderForType(val3.shader, ShaderType.UseUnityShader, ((Object)val3.shader).name);
						ApplyDoubleSidedCreatureSettings(val3);
						PreserveTransparency(val3);
						sharedMaterials[j] = val3;
						flag = true;
					}
				}
				if (flag)
				{
					val.sharedMaterials = sharedMaterials;
				}
			}
			EnsureBackfaceRenderers(go);
		}

		private static void ProcessStarwarsCharacterMaterialShaders(GameObject go)
		{
			//IL_0073: 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_0092: Expected O, but got Unknown
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (ShouldSkipRenderer(val))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				bool flag = false;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null))
					{
						Material val3 = new Material(val2)
						{
							name = ((Object)val2).name + "_StarwarsCharacterCreature"
						};
						ApplyStarwarsCharacterMaterial(val3);
						sharedMaterials[j] = val3;
						flag = true;
					}
				}
				if (flag)
				{
					val.sharedMaterials = sharedMaterials;
				}
			}
			EnsureBackfaceRenderers(go);
		}

		private static void ApplyStarwarsCharacterMaterial(Material material)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			Texture firstTextureOrDefault = GetFirstTextureOrDefault(material, "_MainTex", "_BaseMap", "_BaseColorMap");
			Texture firstTextureOrDefault2 = GetFirstTextureOrDefault(material, "_BumpMap", "_NormalMap", "_NormalTex");
			Color val = GetFirstColorOrDefault(material, Color.white, "_Color", "_BaseColor", "_MainColor");
			float floatOrDefault = GetFloatOrDefault(material, "_Metallic", 0f);
			float floatOrDefault2 = GetFloatOrDefault(material, "_Glossiness", 0.32f);
			float floatOrDefault3 = GetFloatOrDefault(material, "_Smoothness", floatOrDefault2);
			float floatOrDefault4 = GetFloatOrDefault(material, "_Cutoff", 0.5f);
			material.shader = FindShaderWithName(material.shader, "Custom/Creature");
			ApplyDoubleSidedCreatureSettings(material);
			if (LooksLikeUnityMissingShaderTint(val))
			{
				val = Color.white;
			}
			SetTextureIfExists(material, "_MainTex", firstTextureOrDefault);
			SetTextureIfExists(material, "_BaseMap", firstTextureOrDefault);
			if ((Object)(object)firstTextureOrDefault2 != (Object)null)
			{
				SetTextureIfExists(material, "_BumpMap", firstTextureOrDefault2);
				SetTextureIfExists(material, "_NormalMap", firstTextureOrDefault2);
				SetTextureIfExists(material, "_NormalTex", firstTextureOrDefault2);
				material.EnableKeyword("_NORMALMAP");
			}
			float floatOrDefault5 = GetFloatOrDefault(material, "_BumpScale", 1f);
			float value = Mathf.Clamp(floatOrDefault5, 0.15f, 0.35f);
			SetFloatIfExists(material, "_BumpScale", value);
			SetColorIfExists(material, "_Color", val);
			SetColorIfExists(material, "_BaseColor", val);
			SetColorIfExists(material, "_MainColor", val);
			SetFloatIfExists(material, "_Metallic", floatOrDefault);
			SetFloatIfExists(material, "_Glossiness", floatOrDefault2);
			SetFloatIfExists(material, "_Smoothness", floatOrDefault3);
			SetFloatIfExists(material, "_Cutoff", floatOrDefault4);
		}

		private static void PreserveTransparency(Material material)
		{
			if (!((Object)(object)material == (Object)null))
			{
				float floatOrDefault = GetFloatOrDefault(material, "_Cutoff", 0.5f);
				SetFloatIfExists(material, "_Cutoff", floatOrDefault);
				if (material.HasProperty("_Mode"))
				{
					SetFloatIfExists(material, "_Mode", material.GetFloat("_Mode"));
				}
				if (material.HasProperty("_SrcBlend") && material.HasProperty("_DstBlend"))
				{
					SetFloatIfExists(material, "_SrcBlend", material.GetFloat("_SrcBlend"));
					SetFloatIfExists(material, "_DstBlend", material.GetFloat("_DstBlend"));
				}
			}
		}

		private static void EnsureBackfaceRenderers(GameObject go)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00f7: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			SkinnedMeshRenderer[] componentsInChildren = go.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sharedMesh == (Object)null) && !ShouldSkipRenderer((Renderer)(object)val) && !((Object)(object)((Component)val).transform.Find("StarwarsBackfaceRenderer") != (Object)null))
				{
					Mesh backfaceMesh = GetBackfaceMesh(val.sharedMesh);
					if (!((Object)(object)backfaceMesh == (Object)null))
					{
						GameObject val2 = new GameObject("StarwarsBackfaceRenderer");
						val2.transform.SetParent(((Component)val).transform, false);
						SkinnedMeshRenderer val3 = val2.AddComponent<SkinnedMeshRenderer>();
						val3.sharedMesh = backfaceMesh;
						((Renderer)val3).sharedMaterials = CreateBackfaceSafeMaterials(((Renderer)val).sharedMaterials);
						val3.rootBone = val.rootBone;
						val3.bones = val.bones;
						((Renderer)val3).localBounds = ((Renderer)val).localBounds;
						val3.updateWhenOffscreen = val.updateWhenOffscreen;
						val3.quality = val.quality;
						((Renderer)val3).shadowCastingMode = ((Renderer)val).shadowCastingMode;
						((Renderer)val3).receiveShadows = ((Renderer)val).receiveShadows;
					}
				}
			}
			MeshRenderer[] componentsInChildren2 = go.GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val4 in componentsInChildren2)
			{
				if ((Object)(object)val4 == (Object)null || ShouldSkipRenderer((Renderer)(object)val4) || (Object)(object)((Component)val4).transform.Find("StarwarsBackfaceRenderer") != (Object)null)
				{
					continue;
				}
				MeshFilter component = ((Component)val4).GetComponent<MeshFilter>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)component.sharedMesh == (Object)null))
				{
					Mesh backfaceMesh2 = GetBackfaceMesh(component.sharedMesh);
					if (!((Object)(object)backfaceMesh2 == (Object)null))
					{
						GameObject val5 = new GameObject("StarwarsBackfaceRenderer");
						val5.transform.SetParent(((Component)val4).transform, false);
						MeshFilter val6 = val5.AddComponent<MeshFilter>();
						val6.sharedMesh = backfaceMesh2;
						MeshRenderer val7 = val5.AddComponent<MeshRenderer>();
						((Renderer)val7).sharedMaterials = CreateBackfaceSafeMaterials(((Renderer)val4).sharedMaterials);
						((Renderer)val7).shadowCastingMode = ((Renderer)val4).shadowCastingMode;
						((Renderer)val7).receiveShadows = ((Renderer)val4).receiveShadows;
					}
				}
			}
		}

		private static Material[] CreateBackfaceSafeMaterials(Material[] sourceMaterials)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			if (sourceMaterials == null)
			{
				return Array.Empty<Material>();
			}
			Material[] array = (Material[])(object)new Material[sourceMaterials.Length];
			for (int i = 0; i < sourceMaterials.Length; i++)
			{
				Material val = sourceMaterials[i];
				if ((Object)(object)val == (Object)null)
				{
					array[i] = null;
					continue;
				}
				Material val2 = new Material(val)
				{
					name = ((Object)val).name + "_StarwarsBackfaceSafe"
				};
				SetFloatIfExists(val2, "_BumpScale", 0f);
				if (val2.HasProperty("_BumpMap"))
				{
					val2.SetTexture("_BumpMap", (Texture)null);
				}
				if (val2.HasProperty("_NormalMap"))
				{
					val2.SetTexture("_NormalMap", (Texture)null);
				}
				if (val2.HasProperty("_NormalTex"))
				{
					val2.SetTexture("_NormalTex", (Texture)null);
				}
				val2.DisableKeyword("_NORMALMAP");
				ApplyDoubleSidedCreatureSettings(val2);
				PreserveTransparency(val2);
				array[i] = val2;
			}
			return array;
		}

		private static Mesh GetBackfaceMesh(Mesh originalMesh)
		{
			if ((Object)(object)originalMesh == (Object)null)
			{
				return null;
			}
			if (BackfaceMeshCache.TryGetValue(originalMesh, out Mesh value))
			{
				return value;
			}
			if (!originalMesh.isReadable)
			{
				if (BackfaceMeshWarnings.Add(originalMesh))
				{
					Debug.LogWarning((object)("[Starwars Backface] La malla '" + ((Object)originalMesh).name + "' no tiene Read/Write Enabled. Se omitirá su copia de caras internas. Activa Read/Write Enabled en el FBX y reconstruye el AssetBundle."));
				}
				return null;
			}
			Mesh val = null;
			try
			{
				val = Object.Instantiate<Mesh>(originalMesh);
				((Object)val).name = ((Object)originalMesh).name + "_StarwarsBackface";
				for (int i = 0; i < val.subMeshCount; i++)
				{
					int[] triangles = val.GetTriangles(i);
					for (int j = 0; j + 2 < triangles.Length; j += 3)
					{
						int num = triangles[j];
						triangles[j] = triangles[j + 1];
						triangles[j + 1] = num;
					}
					val.SetTriangles(triangles, i, false);
				}
				val.RecalculateBounds();
				BackfaceMeshCache[originalMesh] = val;
				return val;
			}
			catch (Exception ex)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
				if (BackfaceMeshWarnings.Add(originalMesh))
				{
					Debug.LogWarning((object)("[Starwars Backface] No se pudo generar la malla interna para '" + ((Object)originalMesh).name + "': " + ex.Message));
				}
				return null;
			}
		}

		private static void ProcessWookieeRendererSplitFix(GameObject go)
		{
			//IL_0073: 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_0092: Expected O, but got Unknown
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (ShouldSkipRenderer(val))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				bool flag = false;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null))
					{
						Material val3 = new Material(val2)
						{
							name = ((Object)val2).name + "_StarwarsWookieeSplit"
						};
						if (IsWookieeHairRenderer(val))
						{
							ApplyWookieeHairCutout(val3);
						}
						else
						{
							ApplyWookieeSolidOpaque(val3);
						}
						sharedMaterials[j] = val3;
						flag = true;
					}
				}
				if (flag)
				{
					val.sharedMaterials = sharedMaterials;
				}
			}
			EnsureWookieeSolidCoreRenderers(go);
		}

		private static void EnsureWookieeSolidCoreRenderers(GameObject go)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			SkinnedMeshRenderer[] componentsInChildren = go.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sharedMesh == (Object)null) && !ShouldSkipRenderer((Renderer)(object)val) && !IsWookieeHairRenderer((Renderer)(object)val) && !((Object)(object)((Component)val).transform.Find("StarwarsWookieeSolidCoreRenderer") != (Object)null))
				{
					string text = ((Object)val).name.ToLowerInvariant();
					if (text.Contains("head") || text.Contains("body") || text.Contains("cuerpo") || text.Contains("cabeza") || text.Contains("m_head"))
					{
						GameObject val2 = new GameObject("StarwarsWookieeSolidCoreRenderer");
						val2.transform.SetParent(((Component)val).transform, false);
						val2.transform.localPosition = Vector3.zero;
						val2.transform.localRotation = Quaternion.identity;
						val2.transform.localScale = Vector3.one * 0.992f;
						SkinnedMeshRenderer val3 = val2.AddComponent<SkinnedMeshRenderer>();
						val3.sharedMesh = val.sharedMesh;
						val3.rootBone = val.rootBone;
						val3.bones = val.bones;
						((Renderer)val3).localBounds = ((Renderer)val).localBounds;
						val3.updateWhenOffscreen = val.updateWhenOffscreen;
						val3.quality = val.quality;
						((Renderer)val3).shadowCastingMode = ((Renderer)val).shadowCastingMode;
						((Renderer)val3).receiveShadows = ((Renderer)val).receiveShadows;
						((Renderer)val3).sharedMaterials = CreateWookieeSolidCoreMaterials(((Renderer)val).sharedMaterials);
					}
				}
			}
		}

		private static Material[] CreateWookieeSolidCoreMaterials(Material[] sourceMaterials)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (sourceMaterials == null)
			{
				return Array.Empty<Material>();
			}
			Material[] array = (Material[])(object)new Material[sourceMaterials.Length];
			for (int i = 0; i < sourceMaterials.Length; i++)
			{
				Material val = sourceMaterials[i];
				if ((Object)(object)val == (Object)null)
				{
					array[i] = null;
					continue;
				}
				Material val2 = new Material(val)
				{
					name = ((Object)val).name + "_StarwarsWookieeSolidCore"
				};
				ApplyWookieeSolidOpaque(val2);
				val2.renderQueue = 1990;
				array[i] = val2;
			}
			return array;
		}

		private static bool IsWookieeHairRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			string text = ((Object)renderer).name.ToLowerInvariant();
			return text.Contains("haircard") || text.Contains("haircards") || text.Contains("hair_card") || text.Contains("hair cards");
		}

		private static void ApplyWookieeHairCutout(Material material)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)material == (Object)null) && !((Object)(object)material.shader == (Object)null))
			{
				Texture firstTextureOrDefault = GetFirstTextureOrDefault(material, "_MainTex", "_BaseMap", "_BaseColorMap");
				Texture firstTextureOrDefault2 = GetFirstTextureOrDefault(material, "_BumpMap", "_NormalMap", "_NormalTex");
				Color firstColorOrDefault = GetFirstColorOrDefault(material, Color.white, "_Color", "_BaseColor", "_MainColor");
				material.shader = GetShaderForType(material.shader, ShaderType.UseUnityShader, ((Object)material.shader).name);
				SetTextureIfExists(material, "_MainTex", firstTextureOrDefault);
				SetTextureIfExists(material, "_BaseMap", firstTextureOrDefault);
				if ((Object)(object)firstTextureOrDefault2 != (Object)null)
				{
					SetTextureIfExists(material, "_BumpMap", firstTextureOrDefault2);
					SetTextureIfExists(material, "_NormalMap", firstTextureOrDefault2);
					SetTextureIfExists(material, "_NormalTex", firstTextureOrDefault2);
					material.EnableKeyword("_NORMALMAP");
				}
				firstColorOrDefault.a = 1f;
				SetColorIfExists(material, "_Color", firstColorOrDefault);
				SetColorIfExists(material, "_BaseColor", firstColorOrDefault);
				SetColorIfExists(material, "_MainColor", firstColorOrDefault);
				SetFloatIfExists(material, "_Mode", 1f);
				SetFloatIfExists(material, "_Surface", 0f);
				SetFloatIfExists(material, "_AlphaClip", 1f);
				SetFloatIfExists(material, "_Cutoff", Mathf.Clamp(GetFloatOrDefault(material, "_Cutoff", 0.5f), 0.35f, 0.6f));
				SetFloatIfExists(material, "_SrcBlend", 1f);
				SetFloatIfExists(material, "_DstBlend", 0f);
				SetFloatIfExists(material, "_ZWrite", 1f);
				SetFloatIfExists(material, "_Cull", 0f);
				SetFloatIfExists(material, "_CullMode", 0f);
				material.SetOverrideTag("RenderType", "TransparentCutout");
				material.EnableKeyword("_ALPHATEST_ON");
				material.DisableKeyword("_ALPHABLEND_ON");
				material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				material.doubleSidedGI = true;
				material.renderQueue = 2450;
			}
		}

		private static void ApplyWookieeSolidOpaque(Material material)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)material == (Object)null) && !((Object)(object)material.shader == (Object)null))
			{
				Texture firstTextureOrDefault = GetFirstTextureOrDefault(material, "_MainTex", "_BaseMap", "_BaseColorMap");
				Texture firstTextureOrDefault2 = GetFirstTextureOrDefault(material, "_BumpMap", "_NormalMap", "_NormalTex");
				Color val = GetFirstColorOrDefault(material, Color.white, "_Color", "_BaseColor", "_MainColor");
				float floatOrDefault = GetFloatOrDefault(material, "_Metallic", 0f);
				float floatOrDefault2 = GetFloatOrDefault(material, "_Glossiness", 0.25f);
				float floatOrDefault3 = GetFloatOrDefault(material, "_Smoothness", floatOrDefault2);
				material.shader = GetShaderForType(material.shader, ShaderType.UseUnityShader, ((Object)material.shader).name);
				if (LooksLikeUnityMissingShaderTint(val))
				{
					val = Color.white;
				}
				val.a = 1f;
				SetTextureIfExists(material, "_MainTex", firstTextureOrDefault);
				SetTextureIfExists(material, "_BaseMap", firstTextureOrDefault);
				if ((Object)(object)firstTextureOrDefault2 != (Object)null)
				{
					SetTextureIfExists(material, "_BumpMap", firstTextureOrDefault2);
					SetTextureIfExists(material, "_NormalMap", firstTextureOrDefault2);
					SetTextureIfExists(material, "_NormalTex", firstTextureOrDefault2);
					material.EnableKeyword("_NORMALMAP");
				}
				SetColorIfExists(material, "_Color", val);
				SetColorIfExists(material, "_BaseColor", val);
				SetColorIfExists(material, "_MainColor", val);
				SetFloatIfExists(material, "_Metallic", floatOrDefault);
				SetFloatIfExists(material, "_Glossiness", floatOrDefault2);
				SetFloatIfExists(material, "_Smoothness", floatOrDefault3);
				ForceMaterialOpaqueHard(material);
				SetFloatIfExists(material, "_Cull", 0f);
				SetFloatIfExists(material, "_CullMode", 0f);
				material.doubleSidedGI = true;
			}
		}

		private static void ForceMaterialOpaqueHard(Material material)
		{
			if (!((Object)(object)material == (Object)null))
			{
				material.SetOverrideTag("RenderType", "Opaque");
				SetFloatIfExists(material, "_Mode", 0f);
				SetFloatIfExists(material, "_Surface", 0f);
				SetFloatIfExists(material, "_Blend", 0f);
				SetFloatIfExists(material, "_Alpha", 1f);
				SetFloatIfExists(material, "_AlphaClip", 0f);
				SetFloatIfExists(material, "_AlphaToMask", 0f);
				SetFloatIfExists(material, "_Cutoff", 0f);
				SetFloatIfExists(material, "_SrcBlend", 1f);
				SetFloatIfExists(material, "_DstBlend", 0f);
				SetFloatIfExists(material, "_ZWrite", 1f);
				material.DisableKeyword("_ALPHATEST_ON");
				material.DisableKeyword("_ALPHABLEND_ON");
				material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				material.DisableKeyword("_SURFACE_TYPE_TRANSPARENT");
				material.EnableKeyword("_SURFACE_TYPE_OPAQUE");
				material.renderQueue = 2000;
			}
		}

		private static void ProcessWookieeArmorShaders(GameObject go)
		{
			//IL_00e6: 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_0105: Expected O, but got Unknown
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Shader val = FindShaderRuntime("Custom/Creature");
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)("[WookieeArmor] No encontré 'Custom/Creature' para '" + ((Object)go).name + "'. Se conservará el shader original."));
				return;
			}
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				if (ShouldSkipRenderer(val2) || val2 is ParticleSystemRenderer || val2 is TrailRenderer || val2 is LineRenderer || (Object)(object)((Component)val2).GetComponent<ParticleSystem>() != (Object)null)
				{
					continue;
				}
				Material[] sharedMaterials = val2.sharedMaterials;
				Material[] array = (Material[])(object)new Material[sharedMaterials.Length];
				bool flag = false;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val3 = sharedMaterials[j];
					if ((Object)(object)val3 == (Object)null)
					{
						array[j] = null;
						continue;
					}
					Material val4 = new Material(val3)
					{
						name = ((Object)val3).name + "_WookieeCreatureRuntime"
					};
					ApplyWookieeArmorCreatureMaterial(val4, val);
					array[j] = val4;
					flag = true;
				}
				if (flag)
				{
					val2.sharedMaterials = array;
				}
			}
		}

		private static void ApplyWookieeArmorCreatureMaterial(Material material, Shader creatureShader)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)material == (Object)null) && !((Object)(object)creatureShader == (Object)null))
			{
				Texture firstTextureOrDefault = GetFirstTextureOrDefault(material, "_MainTex", "_BaseMap", "_BaseColorMap");
				Texture firstTextureOrDefault2 = GetFirstTextureOrDefault(material, "_BumpMap", "_NormalMap", "_NormalTex");
				Color val = GetFirstColorOrDefault(material, Color.white, "_Color", "_BaseColor", "_MainColor");
				float floatOrDefault = GetFloatOrDefault(material, "_Metallic", 0f);
				float floatOrDefault2 = GetFloatOrDefault(material, "_Glossiness", 0.22f);
				float floatOrDefault3 = GetFloatOrDefault(material, "_Smoothness", floatOrDefault2);
				float floatOrDefault4 = GetFloatOrDefault(material, "_BumpScale", 1f);
				float floatOrDefault5 = GetFloatOrDefault(material, "_Cutoff", 0.5f);
				if (LooksLikeUnityMissingShaderTint(val))
				{
					val = Color.white;
				}
				val.a = 1f;
				material.shader = creatureShader;
				SetTextureIfExists(material, "_MainTex", firstTextureOrDefault);
				SetTextureIfExists(material, "_BaseMap", firstTextureOrDefault);
				SetTextureIfExists(material, "_BaseColorMap", firstTextureOrDefault);
				if ((Object)(object)firstTextureOrDefault2 != (Object)null)
				{
					SetTextureIfExists(material, "_BumpMap", firstTextureOrDefault2);
					SetTextureIfExists(material, "_NormalMap", firstTextureOrDefault2);
					SetTextureIfExists(material, "_NormalTex", firstTextureOrDefault2);
					SetFloatIfExists(material, "_BumpScale", Mathf.Clamp(floatOrDefault4, 0.15f, 1f));
					material.EnableKeyword("_NORMALMAP");
				}
				else
				{
					material.DisableKeyword("_NORMALMAP");
				}
				SetColorIfExists(material, "_Color", val);
				SetColorIfExists(material, "_BaseColor", val);
				SetColorIfExists(material, "_MainColor", val);
				SetFloatIfExists(material, "_Metallic", Mathf.Clamp(floatOrDefault, 0f, 0.55f));
				SetFloatIfExists(material, "_Glossiness", Mathf.Clamp(floatOrDefault2, 0.05f, 0.38f));
				SetFloatIfExists(material, "_Smoothness", Mathf.Clamp(floatOrDefault3, 0.05f, 0.38f));
				SetFloatIfExists(material, "_Cutoff", floatOrDefault5);
				ForceMaterialOpaqueHard(material);
				material.doubleSidedGI = false;
			}
		}

		private static Shader FindShaderRuntime(string shaderName)
		{
			if (string.IsNullOrWhiteSpace(shaderName))
			{
				return null;
			}
			foreach (Shader cachedShader in CachedShaders)
			{
				if ((Object)(object)cachedShader != (Object)null && ((Object)cachedShader).name == shaderName)
				{
					return cachedShader;
				}
			}
			Shader val = Shader.Find(shaderName);
			if ((Object)(object)val != (Object)null && ((Object)val).name != "Hidden/InternalErrorShader")
			{
				return val;
			}
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			foreach (Shader val2 in array)
			{
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name == shaderName)
				{
					CachedShaders.Add(val2);
					return val2;
				}
			}
			return null;
		}

		private static void ProcessArmoredHumanoidShaders(GameObject go)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = ((Object)val).name.ToLowerInvariant();
				if (text.Contains("eyepos") || text.Contains("collider") || text.Contains("hitbox"))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null))
					{
						val2.shader = FindShaderWithName(val2.shader, "ToonDeferredShading2017");
					}
				}
			}
		}

		private static void ProcessFurCreatureShaders(GameObject go)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = ((Object)val).name.ToLowerInvariant();
				if (text.Contains("eyepos") || text.Contains("collider") || text.Contains("hitbox"))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				bool flag = false;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null))
					{
						Material val3 = new Material(val2)
						{
							name = ((Object)val2).name + "_GlitnirCreature"
						};
						ApplyFurCreatureMaterial(val3);
						sharedMaterials[j] = val3;
						flag = true;
					}
				}
				if (flag)
				{
					val.sharedMaterials = sharedMaterials;
				}
			}
		}

		private static void ApplyFurCreatureMaterial(Material material)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			Texture firstTextureOrDefault = GetFirstTextureOrDefault(material, "_MainTex", "_BaseMap", "_BaseColorMap");
			Texture firstTextureOrDefault2 = GetFirstTextureOrDefault(material, "_BumpMap", "_NormalMap", "_NormalTex");
			Color val = GetFirstColorOrDefault(material, Color.white, "_Color", "_BaseColor", "_MainColor");
			float floatOrDefault = GetFloatOrDefault(material, "_Metallic", 0f);
			float floatOrDefault2 = GetFloatOrDefault(material, "_Glossiness", 0.18f);
			float floatOrDefault3 = GetFloatOrDefault(material, "_Smoothness", floatOrDefault2);
			float floatOrDefault4 = GetFloatOrDefault(material, "_Cutoff", 0.5f);
			material.shader = FindShaderWithName(material.shader, "Custom/Creature");
			ApplyDoubleSidedCreatureSettings(material);
			if (LooksLikeUnityMissingShaderTint(val))
			{
				val = Color.white;
			}
			SetTextureIfExists(material, "_MainTex", firstTextureOrDefault);
			SetTextureIfExists(material, "_BaseMap", firstTextureOrDefault);
			if ((Object)(object)firstTextureOrDefault2 != (Object)null)
			{
				SetTextureIfExists(material, "_BumpMap", firstTextureOrDefault2);
				material.EnableKeyword("_NORMALMAP");
			}
			SetColorIfExists(material, "_Color", val);
			SetColorIfExists(material, "_BaseColor", val);
			SetColorIfExists(material, "_MainColor", val);
			SetFloatIfExists(material, "_Metallic", floatOrDefault);
			SetFloatIfExists(material, "_Glossiness", floatOrDefault2);
			SetFloatIfExists(material, "_Smoothness", floatOrDefault3);
			SetFloatIfExists(material, "_Cutoff", floatOrDefault4);
		}

		private static void ProcessSkeletonHammerShaders(GameObject go)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = ((Object)val).name.ToLowerInvariant();
				if (text.Contains("eyepos") || text.Contains("collider") || text.Contains("hitbox"))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				bool flag = false;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null))
					{
						Material val3 = new Material(val2)
						{
							name = ((Object)val2).name + "_GlitnirSkeleton"
						};
						ApplySkeletonHammerMaterial(val, val3);
						sharedMaterials[j] = val3;
						flag = true;
					}
				}
				if (flag)
				{
					val.sharedMaterials = sharedMaterials;
				}
			}
		}

		private static void ApplySkeletonHammerMaterial(Renderer renderer, Material material)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			Texture textureOrDefault = GetTextureOrDefault(material, "_MainTex");
			Texture textureOrDefault2 = GetTextureOrDefault(material, "_BumpMap");
			Color colorOrDefault = GetColorOrDefault(material, "_Color", Color.white);
			float floatOrDefault = GetFloatOrDefault(material, "_Cutoff", 0.5f);
			string text = ((Object)material).name.Replace(" (Instance)", "").ToLowerInvariant();
			string text2 = ((Object)renderer).name.ToLowerInvariant();
			bool flag = text.Contains("armor") || text.Contains("hammer") || text.Contains("mace") || text.Contains("metal") || text.Contains("plate") || text.Contains("helm") || text2.Contains("weapon") || text2.Contains("hammer") || text2.Contains("mace");
			material.shader = FindShaderWithName(material.shader, "Custom/Creature");
			ApplyDoubleSidedCreatureSettings(material);
			if ((Object)(object)textureOrDefault != (Object)null && material.HasProperty("_MainTex"))
			{
				material.SetTexture("_MainTex", textureOrDefault);
			}
			if ((Object)(object)textureOrDefault2 != (Object)null && material.HasProperty("_BumpMap"))
			{
				material.SetTexture("_BumpMap", textureOrDefault2);
				material.EnableKeyword("_NORMALMAP");
			}
			float num = (flag ? 0.82f : 0.95f);
			Color value = default(Color);
			((Color)(ref value))..ctor(Mathf.Clamp01(colorOrDefault.r * num), Mathf.Clamp01(colorOrDefault.g * num), Mathf.Clamp01(colorOrDefault.b * num), colorOrDefault.a);
			SetColorIfExists(material, "_Color", value);
			SetColorIfExists(mat