using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Tolga")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TranslucentCart")]
[assembly: AssemblyTitle("TranslucentCart")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
namespace TranslucentCart
{
	[HarmonyPatch(typeof(PhysGrabCart))]
	internal static class PhysGrabCartPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Start_Postfix(PhysGrabCart __instance)
		{
			TranslucentCart.ApplyCartTransparency(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("StateSwitchRPC")]
		private static void StateSwitchRPC_Postfix(PhysGrabCart __instance)
		{
			TranslucentCart.ApplyCartTransparency(__instance);
		}
	}
	[HarmonyPatch(typeof(PhysGrabObject))]
	internal static class PhysGrabObjectCartGrabPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("GrabStarted")]
		private static void GrabStarted_Postfix(PhysGrabObject __instance)
		{
			PhysGrabCart component = ((Component)__instance).GetComponent<PhysGrabCart>();
			if (Object.op_Implicit((Object)(object)component))
			{
				TranslucentCart.ApplyCartTransparency(component);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("GrabEnded")]
		private static void GrabEnded_Postfix(PhysGrabObject __instance)
		{
			PhysGrabCart component = ((Component)__instance).GetComponent<PhysGrabCart>();
			if (Object.op_Implicit((Object)(object)component))
			{
				TranslucentCart.ApplyCartTransparency(component);
			}
		}
	}
	[BepInPlugin("Tolga.TranslucentCart", "TranslucentCart", "1.0")]
	public class TranslucentCart : BaseUnityPlugin
	{
		private struct MaterialSnapshot
		{
			public bool Initialized;

			public int RenderQueue;

			public string RenderTypeTag;

			public bool HasSurface;

			public float Surface;

			public bool HasMode;

			public float Mode;

			public bool HasSrcBlend;

			public int SrcBlend;

			public bool HasDstBlend;

			public int DstBlend;

			public bool HasZWrite;

			public int ZWrite;

			public bool HasAlphaClip;

			public float AlphaClip;

			public bool HasCutoff;

			public float Cutoff;

			public bool AlphaTestKeyword;

			public bool AlphaBlendKeyword;

			public bool AlphaPremultiplyKeyword;

			public bool HasColor;

			public Color Color;

			public bool HasBaseColor;

			public Color BaseColor;

			public bool HasTintColor;

			public Color TintColor;
		}

		private struct RendererSnapshot
		{
			public bool Initialized;

			public bool Enabled;

			public ShadowCastingMode ShadowCastingMode;

			public bool ReceiveShadows;
		}

		private static readonly Dictionary<int, MaterialSnapshot> MaterialSnapshots = new Dictionary<int, MaterialSnapshot>();

		private static readonly Dictionary<int, RendererSnapshot> RendererSnapshots = new Dictionary<int, RendererSnapshot>();

		private static readonly HashSet<string> VanillaCartNames = new HashSet<string> { "Item Cart Small", "Item Cart Medium" };

		private static readonly HashSet<string> CustomCartNames = new HashSet<string> { "Shopping Cart" };

		private static readonly HashSet<string> SeenCartNames = new HashSet<string>();

		private static bool _refreshAllCartsRequested;

		internal static TranslucentCart Instance { get; private set; } = null;


		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		internal static ConfigEntry<float> CartTransparencyPercent { get; private set; } = null;


		internal static ConfigEntry<bool> OnlyWhenGrabbing { get; private set; } = null;


		internal static ConfigEntry<bool> IncludeCustomCarts { get; private set; } = null;


		internal static float CartAlpha
		{
			get
			{
				float num = Mathf.Clamp(CartTransparencyPercent.Value, 0f, 100f) / 100f;
				return Mathf.Clamp01(1f - num);
			}
		}

		private void Awake()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			Instance = this;
			CartTransparencyPercent = ((BaseUnityPlugin)this).Config.Bind<float>("General", "CartTransparencyPercent", 40f, new ConfigDescription("How transparent the cart should be as a percent. 0 = opaque, 100 = invisible.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			OnlyWhenGrabbing = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "OnlyWhenGrabbing", false, "If true, only apply transparency while you are grabbing the cart (local player). If false, always apply.");
			IncludeCustomCarts = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "IncludeCustomCarts", false, "If true, also apply translucency to custom/modded carts (not just vanilla carts). Uses a safer cutout-preserving transparency mode for basket/wire meshes to avoid black/solid artifacts.");
			CartTransparencyPercent.SettingChanged += OnAnySettingChanged;
			OnlyWhenGrabbing.SettingChanged += OnAnySettingChanged;
			IncludeCustomCarts.SettingChanged += OnAnySettingChanged;
			((BaseUnityPlugin)this).Config.ConfigReloaded += OnConfigReloaded;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		private void OnDestroy()
		{
			try
			{
				CartTransparencyPercent.SettingChanged -= OnAnySettingChanged;
				OnlyWhenGrabbing.SettingChanged -= OnAnySettingChanged;
				IncludeCustomCarts.SettingChanged -= OnAnySettingChanged;
				((BaseUnityPlugin)this).Config.ConfigReloaded -= OnConfigReloaded;
			}
			catch
			{
			}
		}

		private static void OnAnySettingChanged(object sender, EventArgs e)
		{
			RequestRefreshAllCarts();
		}

		private static void OnConfigReloaded(object sender, EventArgs e)
		{
			RequestRefreshAllCarts();
		}

		private static void RequestRefreshAllCarts()
		{
			_refreshAllCartsRequested = true;
		}

		internal void Patch()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0025: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
			if (_refreshAllCartsRequested)
			{
				_refreshAllCartsRequested = false;
				RefreshAllCarts();
			}
		}

		internal static void RefreshAllCarts()
		{
			PhysGrabCart[] array;
			try
			{
				array = Object.FindObjectsOfType<PhysGrabCart>();
			}
			catch
			{
				return;
			}
			PhysGrabCart[] array2 = array;
			foreach (PhysGrabCart cart in array2)
			{
				ApplyCartTransparency(cart);
			}
		}

		internal static void ApplyCartTransparency(PhysGrabCart cart)
		{
			if (!Object.op_Implicit((Object)(object)cart))
			{
				return;
			}
			string text = ((Object)cart).name.Replace("(Clone)", "").Trim();
			if (!SeenCartNames.Contains(text))
			{
				SeenCartNames.Add(text);
				Logger.LogInfo((object)("[CartDiscovery] New cart type seen: '" + text + "'"));
			}
			bool flag = IsLikelyCustomCart(cart);
			if (flag && !IncludeCustomCarts.Value)
			{
				Logger.LogInfo((object)("[CartTransparency] '" + text + "' → SKIPPED (custom cart, IncludeCustomCarts=false)"));
				RestoreCartOpacity(cart);
				return;
			}
			if (!flag)
			{
				Logger.LogInfo((object)("[CartTransparency] '" + text + "' → APPLYING (vanilla cart)"));
			}
			else
			{
				Logger.LogInfo((object)("[CartTransparency] '" + text + "' → APPLYING (custom cart, IncludeCustomCarts=true)"));
			}
			float effectiveAlpha = GetEffectiveAlpha(cart);
			Renderer[] componentsInChildren = ((Component)cart).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((val is MeshRenderer || val is SkinnedMeshRenderer) && !((Object)(object)((Component)val).GetComponent("TMPro.TMP_Text") != (Object)null) && !((Object)(object)((Component)val).GetComponent("TMPro.TextMeshPro") != (Object)null))
				{
					Material[] materials;
					try
					{
						materials = val.materials;
					}
					catch
					{
						continue;
					}
					Material[] array = materials;
					foreach (Material material in array)
					{
						bool preferCutout = flag || IsBasketLike(((Object)((Component)val).gameObject).name);
						ApplyMaterialFade(material, effectiveAlpha, preferCutout);
					}
					ApplyRendererShadowRules(val, effectiveAlpha);
				}
			}
		}

		private static void RestoreCartOpacity(PhysGrabCart cart)
		{
			Renderer[] componentsInChildren = ((Component)cart).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (val is MeshRenderer || val is SkinnedMeshRenderer)
				{
					Material[] materials;
					try
					{
						materials = val.materials;
					}
					catch
					{
						continue;
					}
					Material[] array = materials;
					foreach (Material material in array)
					{
						ApplyMaterialFade(material, 1f, preferCutout: false);
					}
					ApplyRendererShadowRules(val, 1f);
				}
			}
		}

		private static float GetEffectiveAlpha(PhysGrabCart cart)
		{
			if (!OnlyWhenGrabbing.Value)
			{
				return CartAlpha;
			}
			PhysGrabObject val;
			try
			{
				val = ((Component)cart).GetComponent<PhysGrabObject>();
			}
			catch
			{
				val = null;
			}
			if (!((Object)(object)val != (Object)null) || !val.grabbedLocal)
			{
				return 1f;
			}
			return CartAlpha;
		}

		private static void ApplyRendererShadowRules(Renderer renderer, float alphaMultiplier)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			alphaMultiplier = Mathf.Clamp01(alphaMultiplier);
			int instanceID = ((Object)renderer).GetInstanceID();
			if (!RendererSnapshots.TryGetValue(instanceID, out var value) || !value.Initialized)
			{
				RendererSnapshot rendererSnapshot = default(RendererSnapshot);
				rendererSnapshot.Initialized = true;
				rendererSnapshot.Enabled = renderer.enabled;
				rendererSnapshot.ShadowCastingMode = renderer.shadowCastingMode;
				rendererSnapshot.ReceiveShadows = renderer.receiveShadows;
				value = rendererSnapshot;
				RendererSnapshots[instanceID] = value;
			}
			if (alphaMultiplier <= 0.001f)
			{
				renderer.enabled = false;
				renderer.shadowCastingMode = (ShadowCastingMode)0;
			}
			else
			{
				renderer.enabled = value.Enabled;
				renderer.shadowCastingMode = value.ShadowCastingMode;
			}
			renderer.receiveShadows = value.ReceiveShadows;
		}

		private static void ApplyMaterialFade(Material material, float alphaMultiplier, bool preferCutout)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)material))
			{
				return;
			}
			alphaMultiplier = Mathf.Clamp01(alphaMultiplier);
			int instanceID = ((Object)material).GetInstanceID();
			if (!MaterialSnapshots.TryGetValue(instanceID, out var value) || !value.Initialized)
			{
				value = CaptureSnapshot(material);
				MaterialSnapshots[instanceID] = value;
			}
			if (alphaMultiplier >= 0.999f)
			{
				RestoreSnapshot(material, value);
				return;
			}
			if (preferCutout || IsCutoutLike(material, value))
			{
				SetMaterialTransparentPreserveCutout(material, value);
			}
			else
			{
				SetMaterialTransparent(material);
			}
			if (value.HasColor && material.HasProperty("_Color"))
			{
				Color color = value.Color;
				color.a = Mathf.Clamp01(value.Color.a * alphaMultiplier);
				material.color = color;
			}
			if (value.HasBaseColor && material.HasProperty("_BaseColor"))
			{
				Color baseColor = value.BaseColor;
				baseColor.a = Mathf.Clamp01(value.BaseColor.a * alphaMultiplier);
				material.SetColor("_BaseColor", baseColor);
			}
			if (value.HasTintColor && material.HasProperty("_TintColor"))
			{
				Color tintColor = value.TintColor;
				tintColor.a = Mathf.Clamp01(value.TintColor.a * alphaMultiplier);
				material.SetColor("_TintColor", tintColor);
			}
		}

		private static MaterialSnapshot CaptureSnapshot(Material material)
		{
			//IL_0196: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			MaterialSnapshot materialSnapshot = default(MaterialSnapshot);
			materialSnapshot.Initialized = true;
			materialSnapshot.RenderQueue = material.renderQueue;
			materialSnapshot.RenderTypeTag = material.GetTag("RenderType", false, "");
			MaterialSnapshot result = materialSnapshot;
			if (material.HasProperty("_Surface"))
			{
				result.HasSurface = true;
				result.Surface = material.GetFloat("_Surface");
			}
			if (material.HasProperty("_Mode"))
			{
				result.HasMode = true;
				result.Mode = material.GetFloat("_Mode");
			}
			if (material.HasProperty("_SrcBlend"))
			{
				result.HasSrcBlend = true;
				result.SrcBlend = material.GetInt("_SrcBlend");
			}
			if (material.HasProperty("_DstBlend"))
			{
				result.HasDstBlend = true;
				result.DstBlend = material.GetInt("_DstBlend");
			}
			if (material.HasProperty("_ZWrite"))
			{
				result.HasZWrite = true;
				result.ZWrite = material.GetInt("_ZWrite");
			}
			if (material.HasProperty("_AlphaClip"))
			{
				result.HasAlphaClip = true;
				result.AlphaClip = material.GetFloat("_AlphaClip");
			}
			if (material.HasProperty("_Cutoff"))
			{
				result.HasCutoff = true;
				result.Cutoff = material.GetFloat("_Cutoff");
			}
			result.AlphaTestKeyword = material.IsKeywordEnabled("_ALPHATEST_ON");
			result.AlphaBlendKeyword = material.IsKeywordEnabled("_ALPHABLEND_ON");
			result.AlphaPremultiplyKeyword = material.IsKeywordEnabled("_ALPHAPREMULTIPLY_ON");
			if (material.HasProperty("_Color"))
			{
				result.HasColor = true;
				result.Color = material.color;
			}
			if (material.HasProperty("_BaseColor"))
			{
				result.HasBaseColor = true;
				result.BaseColor = material.GetColor("_BaseColor");
			}
			if (material.HasProperty("_TintColor"))
			{
				result.HasTintColor = true;
				result.TintColor = material.GetColor("_TintColor");
			}
			return result;
		}

		private static void RestoreSnapshot(Material material, MaterialSnapshot snap)
		{
			//IL_019e: 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_01ea: Unknown result type (might be due to invalid IL or missing references)
			material.renderQueue = snap.RenderQueue;
			material.SetOverrideTag("RenderType", snap.RenderTypeTag);
			if (snap.HasSurface && material.HasProperty("_Surface"))
			{
				material.SetFloat("_Surface", snap.Surface);
			}
			if (snap.HasMode && material.HasProperty("_Mode"))
			{
				material.SetFloat("_Mode", snap.Mode);
			}
			if (snap.HasSrcBlend && material.HasProperty("_SrcBlend"))
			{
				material.SetInt("_SrcBlend", snap.SrcBlend);
			}
			if (snap.HasDstBlend && material.HasProperty("_DstBlend"))
			{
				material.SetInt("_DstBlend", snap.DstBlend);
			}
			if (snap.HasZWrite && material.HasProperty("_ZWrite"))
			{
				material.SetInt("_ZWrite", snap.ZWrite);
			}
			if (snap.HasAlphaClip && material.HasProperty("_AlphaClip"))
			{
				material.SetFloat("_AlphaClip", snap.AlphaClip);
			}
			if (snap.HasCutoff && material.HasProperty("_Cutoff"))
			{
				material.SetFloat("_Cutoff", snap.Cutoff);
			}
			if (snap.AlphaTestKeyword)
			{
				material.EnableKeyword("_ALPHATEST_ON");
			}
			else
			{
				material.DisableKeyword("_ALPHATEST_ON");
			}
			if (snap.AlphaBlendKeyword)
			{
				material.EnableKeyword("_ALPHABLEND_ON");
			}
			else
			{
				material.DisableKeyword("_ALPHABLEND_ON");
			}
			if (snap.AlphaPremultiplyKeyword)
			{
				material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
			}
			else
			{
				material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			}
			if (snap.HasColor && material.HasProperty("_Color"))
			{
				material.color = snap.Color;
			}
			if (snap.HasBaseColor && material.HasProperty("_BaseColor"))
			{
				material.SetColor("_BaseColor", snap.BaseColor);
			}
			if (snap.HasTintColor && material.HasProperty("_TintColor"))
			{
				material.SetColor("_TintColor", snap.TintColor);
			}
		}

		private static void SetMaterialTransparent(Material material)
		{
			material.SetOverrideTag("RenderType", "Transparent");
			if (material.HasProperty("_Surface"))
			{
				material.SetFloat("_Surface", 1f);
			}
			if (material.HasProperty("_Mode"))
			{
				material.SetFloat("_Mode", 3f);
			}
			if (material.HasProperty("_SrcBlend"))
			{
				material.SetInt("_SrcBlend", 5);
			}
			if (material.HasProperty("_DstBlend"))
			{
				material.SetInt("_DstBlend", 10);
			}
			if (material.HasProperty("_ZWrite"))
			{
				material.SetInt("_ZWrite", 0);
			}
			material.DisableKeyword("_ALPHATEST_ON");
			material.EnableKeyword("_ALPHABLEND_ON");
			material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			material.renderQueue = 3000;
		}

		private static bool IsLikelyCustomCart(PhysGrabCart cart)
		{
			string text = ((Object)cart).name.Replace("(Clone)", "").Trim();
			if (CustomCartNames.Contains(text))
			{
				Logger.LogInfo((object)("[CartDetection] '" + text + "' → CUSTOM (in explicit custom list)"));
				return true;
			}
			if (VanillaCartNames.Count > 0 && !VanillaCartNames.Contains(text))
			{
				Logger.LogInfo((object)("[CartDetection] '" + text + "' → CUSTOM (not in vanilla whitelist)"));
				return true;
			}
			int num = 0;
			try
			{
				MonoBehaviour[] componentsInChildren = ((Component)cart).GetComponentsInChildren<MonoBehaviour>(true);
				MonoBehaviour[] array = componentsInChildren;
				foreach (MonoBehaviour val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						num++;
					}
				}
				if (num > 0)
				{
					Logger.LogInfo((object)$"[CartDetection] '{text}' → CUSTOM (found {num} missing script(s))");
					return true;
				}
			}
			catch
			{
			}
			List<string> list = new List<string>();
			try
			{
				Component[] componentsInChildren2 = ((Component)cart).GetComponentsInChildren<Component>(true);
				Component[] array2 = componentsInChildren2;
				foreach (Component val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)cart))
					{
						Type type = ((object)val2).GetType();
						string text2 = type.Assembly.GetName().Name ?? string.Empty;
						if (!IsVanillaAssemblyName(text2) && !list.Contains(text2))
						{
							list.Add(text2);
						}
					}
				}
				if (list.Count > 0)
				{
					Logger.LogInfo((object)("[CartDetection] '" + text + "' → CUSTOM (non-vanilla assemblies: " + string.Join(", ", list) + ")"));
					return true;
				}
			}
			catch
			{
			}
			Logger.LogInfo((object)("[CartDetection] '" + text + "' → VANILLA (passed all custom checks)"));
			return false;
		}

		private static bool IsVanillaAssemblyName(string assemblyName)
		{
			if (string.IsNullOrEmpty(assemblyName))
			{
				return true;
			}
			if (assemblyName == "Assembly-CSharp")
			{
				return true;
			}
			if (assemblyName.StartsWith("Assembly-CSharp-", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (assemblyName.StartsWith("Unity", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (assemblyName.IndexOf("Photon", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			switch (assemblyName)
			{
			case "TMPro":
				return true;
			default:
				if (!assemblyName.StartsWith("System.", StringComparison.OrdinalIgnoreCase))
				{
					if (assemblyName == "netstandard")
					{
						return true;
					}
					return false;
				}
				goto case "mscorlib";
			case "mscorlib":
			case "System":
				return true;
			}
		}

		private static bool IsBasketLike(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			string text = name.ToLowerInvariant();
			if (!text.Contains("basket") && !text.Contains("wire") && !text.Contains("grid") && !text.Contains("net") && !text.Contains("mesh"))
			{
				return text.Contains("cage");
			}
			return true;
		}

		private static bool IsCutoutLike(Material material, MaterialSnapshot snap)
		{
			if (snap.AlphaTestKeyword)
			{
				return true;
			}
			if (!string.IsNullOrEmpty(snap.RenderTypeTag) && snap.RenderTypeTag.ToLowerInvariant().Contains("cutout"))
			{
				return true;
			}
			if (material.HasProperty("_AlphaClip"))
			{
				try
				{
					if (material.GetFloat("_AlphaClip") > 0.5f)
					{
						return true;
					}
				}
				catch
				{
				}
			}
			if (material.HasProperty("_Cutoff"))
			{
				return true;
			}
			if (snap.HasMode && Mathf.Abs(snap.Mode - 1f) < 0.01f)
			{
				return true;
			}
			return false;
		}

		private static void SetMaterialTransparentPreserveCutout(Material material, MaterialSnapshot snap)
		{
			material.SetOverrideTag("RenderType", "TransparentCutout");
			if (material.HasProperty("_Surface"))
			{
				material.SetFloat("_Surface", 1f);
			}
			if (material.HasProperty("_AlphaClip"))
			{
				material.SetFloat("_AlphaClip", 1f);
			}
			if (material.HasProperty("_Cutoff"))
			{
				float num = 0.5f;
				try
				{
					if (snap.HasCutoff)
					{
						num = snap.Cutoff;
					}
				}
				catch
				{
				}
				material.SetFloat("_Cutoff", num);
			}
			if (material.HasProperty("_Mode"))
			{
				material.SetFloat("_Mode", 3f);
			}
			if (material.HasProperty("_SrcBlend"))
			{
				material.SetInt("_SrcBlend", 5);
			}
			if (material.HasProperty("_DstBlend"))
			{
				material.SetInt("_DstBlend", 10);
			}
			if (material.HasProperty("_ZWrite"))
			{
				material.SetInt("_ZWrite", 0);
			}
			if (snap.AlphaTestKeyword)
			{
				material.EnableKeyword("_ALPHATEST_ON");
			}
			material.EnableKeyword("_ALPHABLEND_ON");
			material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			material.renderQueue = 3000;
		}

		private static void SetMaterialOpaque(Material material)
		{
			material.SetOverrideTag("RenderType", "Opaque");
			if (material.HasProperty("_Surface"))
			{
				material.SetFloat("_Surface", 0f);
			}
			if (material.HasProperty("_Mode"))
			{
				material.SetFloat("_Mode", 0f);
			}
			if (material.HasProperty("_SrcBlend"))
			{
				material.SetInt("_SrcBlend", 1);
			}
			if (material.HasProperty("_DstBlend"))
			{
				material.SetInt("_DstBlend", 0);
			}
			if (material.HasProperty("_ZWrite"))
			{
				material.SetInt("_ZWrite", 1);
			}
			material.DisableKeyword("_ALPHATEST_ON");
			material.DisableKeyword("_ALPHABLEND_ON");
			material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			material.renderQueue = 2000;
		}
	}
}