using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ShootZombies")]
[assembly: AssemblyDescription("Turns PEAK's blowgun into a configurable zombie-survival weapon mode with selectable gun models, lobby weapon grants, an in-game config panel, and host-synced multiplayer settings.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ShootZombies")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("927916ce-8113-4ce1-a65e-d4bd77e780b4")]
[assembly: AssemblyFileVersion("1.3.6.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.6.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ShootZombies
{
	public sealed class AkHeldLegacyVisualMarker : MonoBehaviour
	{
	}
	public sealed class AkInPlaceMarker : MonoBehaviour
	{
		public bool hasBaseRotation;

		public bool hasBaseTransform;

		public bool hasOriginalVisual;

		public Vector3 baseLocalPosition = Vector3.zero;

		public Quaternion baseLocalRotation = Quaternion.identity;

		public Vector3 baseLocalScale = Vector3.one;

		public Mesh originalMesh;

		public Material[] originalMaterials;
	}
	internal static class AkLightweightAssetLoader
	{
		private struct ObjVertexKey : IEquatable<ObjVertexKey>
		{
			public int PositionIndex;

			public int UvIndex;

			public int NormalIndex;

			public bool Equals(ObjVertexKey other)
			{
				if (PositionIndex == other.PositionIndex && UvIndex == other.UvIndex)
				{
					return NormalIndex == other.NormalIndex;
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (!(obj is ObjVertexKey))
				{
					return false;
				}
				return Equals((ObjVertexKey)obj);
			}

			public override int GetHashCode()
			{
				return ((17 * 31 + PositionIndex) * 31 + UvIndex) * 31 + NormalIndex;
			}
		}

		private struct ObjFaceVertex
		{
			public int PositionIndex;

			public int UvIndex;

			public int NormalIndex;
		}

		[CompilerGenerated]
		private sealed class <GetSearchDirectories>d__18 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private HashSet<string> <seen>5__2;

			private IEnumerator<string> <>7__wrap2;

			private string <fullPath>5__4;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetSearchDirectories>d__18(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<seen>5__2 = null;
				<>7__wrap2 = null;
				<fullPath>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<seen>5__2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
						<>7__wrap2 = GetSearchRoots().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
					{
						<>1__state = -3;
						string path = Path.Combine(<fullPath>5__4, "AK_Resources");
						if (Directory.Exists(path))
						{
							string fullPath = GetFullPath(path);
							if (!string.IsNullOrWhiteSpace(fullPath) && <seen>5__2.Add(fullPath))
							{
								<>2__current = fullPath;
								<>1__state = 2;
								return true;
							}
						}
						goto IL_0120;
					}
					case 2:
						{
							<>1__state = -3;
							goto IL_0120;
						}
						IL_0120:
						<fullPath>5__4 = null;
						break;
					}
					while (<>7__wrap2.MoveNext())
					{
						string current = <>7__wrap2.Current;
						if (!string.IsNullOrWhiteSpace(current))
						{
							<fullPath>5__4 = GetFullPath(current);
							if (!string.IsNullOrWhiteSpace(<fullPath>5__4) && Directory.Exists(<fullPath>5__4) && <seen>5__2.Add(<fullPath>5__4))
							{
								<>2__current = <fullPath>5__4;
								<>1__state = 1;
								return true;
							}
						}
					}
					<>m__Finally1();
					<>7__wrap2 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap2 != null)
				{
					<>7__wrap2.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetSearchDirectories>d__18(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetSearchRoots>d__19 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string <text2>5__2;

			private string <text3>5__3;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetSearchRoots>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<text2>5__2 = null;
				<text3>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string location = Assembly.GetExecutingAssembly().Location;
					string value = (string.IsNullOrWhiteSpace(location) ? string.Empty : (Path.GetDirectoryName(location) ?? string.Empty));
					<text2>5__2 = Paths.PluginPath ?? string.Empty;
					<text3>5__3 = (string.IsNullOrWhiteSpace(<text2>5__2) ? string.Empty : (Directory.GetParent(<text2>5__2)?.FullName ?? string.Empty));
					if (!string.IsNullOrWhiteSpace(value))
					{
						<>2__current = value;
						<>1__state = 1;
						return true;
					}
					goto IL_00c1;
				}
				case 1:
					<>1__state = -1;
					goto IL_00c1;
				case 2:
					<>1__state = -1;
					goto IL_00ea;
				case 3:
					<>1__state = -1;
					goto IL_0113;
				case 4:
					{
						<>1__state = -1;
						return false;
					}
					IL_0113:
					<>2__current = Path.Combine(Environment.CurrentDirectory ?? string.Empty, "AK_Resources");
					<>1__state = 4;
					return true;
					IL_00c1:
					if (!string.IsNullOrWhiteSpace(<text2>5__2))
					{
						<>2__current = <text2>5__2;
						<>1__state = 2;
						return true;
					}
					goto IL_00ea;
					IL_00ea:
					if (!string.IsNullOrWhiteSpace(<text3>5__3))
					{
						<>2__current = <text3>5__3;
						<>1__state = 3;
						return true;
					}
					goto IL_0113;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetSearchRoots>d__19(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		private const string ResourceFolderName = "AK_Resources";

		private const string CanonicalModelFileName = "ak_model.obj";

		private const string CanonicalTextureFileName = "ak_texture.png";

		private const string CanonicalIconFileName = "ak_icon.png";

		private static readonly string[] ModelFileNames = new string[3] { "ak_model.obj", "-3728671120793114700_Cube.obj", "Cube.obj" };

		private static readonly string[] TextureFileNames = new string[3] { "ak_texture.png", "AK-47_type_II.png", "ak47.png" };

		private static readonly string[] IconFileNames = new string[3] { "ak_icon.png", "AK-47_type_II_icon.png", "ak47_icon.png" };

		private static readonly Vector3 MeshLocalPosition = new Vector3(0f, 0f, 0.11863899f);

		private static readonly Quaternion MeshLocalRotation = new Quaternion(1.1009293E-08f, -0.70710677f, -0.7071068f, -2.2351747E-08f);

		private static readonly Vector3 MeshLocalScale = new Vector3(0.3060086f, 0.18934934f, 0.18934931f);

		private static readonly Vector3 SpawnLocalPosition = new Vector3(0.002f, 0.036f, 0.5118f);

		private static readonly Quaternion SpawnLocalRotation = Quaternion.identity;

		private static readonly Vector3 SpawnLocalScale = new Vector3(0.7339988f, 0.7339988f, 0.7339988f);

		public static bool TryLoad(out GameObject prefab, out string diagnostic)
		{
			prefab = null;
			diagnostic = string.Empty;
			if (!TryResolveResourcePaths(out var modelPath, out var texturePath, out diagnostic))
			{
				return false;
			}
			if (!TryLoadObjMesh(modelPath, out var mesh, out var summary))
			{
				diagnostic = "OBJ load failed: " + modelPath + " (" + summary + ")";
				return false;
			}
			string summary2;
			Material val = CreateMaterial(LoadTexture(texturePath, out summary2), texturePath);
			if ((Object)(object)val == (Object)null)
			{
				diagnostic = "Material creation failed for texture: " + texturePath;
				return false;
			}
			prefab = BuildPrefab(mesh, val);
			if ((Object)(object)prefab == (Object)null)
			{
				diagnostic = "Prefab build failed";
				return false;
			}
			diagnostic = "model=" + Path.GetFileName(modelPath) + ", texture=" + Path.GetFileName(texturePath) + ", " + summary + ", " + summary2;
			return true;
		}

		public static bool TryLoadIconTexture(out Texture2D texture, out string diagnostic)
		{
			texture = null;
			diagnostic = string.Empty;
			List<string> list = GetSearchDirectories().Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList();
			foreach (string item in list)
			{
				string text = ResolveFirstExistingPath(item, IconFileNames);
				if (!string.IsNullOrWhiteSpace(text))
				{
					texture = LoadTexture(text, out var summary);
					if ((Object)(object)texture != (Object)null)
					{
						diagnostic = "icon=" + Path.GetFileName(text) + ", " + summary;
						return true;
					}
					diagnostic = "icon decode failed: " + text + ", " + summary;
					return false;
				}
			}
			diagnostic = "searched=" + string.Join(" | ", list);
			return false;
		}

		private static bool TryResolveResourcePaths(out string modelPath, out string texturePath, out string diagnostic)
		{
			modelPath = string.Empty;
			texturePath = string.Empty;
			List<string> list = GetSearchDirectories().Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList();
			foreach (string item in list)
			{
				string text = ResolveFirstExistingPath(item, ModelFileNames);
				string text2 = ResolveFirstExistingPath(item, TextureFileNames);
				if (!string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(text2))
				{
					modelPath = text;
					texturePath = text2;
					diagnostic = "resolved at " + item;
					return true;
				}
			}
			diagnostic = "searched=" + string.Join(" | ", list);
			return false;
		}

		[IteratorStateMachine(typeof(<GetSearchDirectories>d__18))]
		private static IEnumerable<string> GetSearchDirectories()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetSearchDirectories>d__18(-2);
		}

		[IteratorStateMachine(typeof(<GetSearchRoots>d__19))]
		private static IEnumerable<string> GetSearchRoots()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetSearchRoots>d__19(-2);
		}

		private static string GetFullPath(string path)
		{
			try
			{
				return Path.GetFullPath(path);
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string ResolveFirstExistingPath(string directory, IEnumerable<string> fileNames)
		{
			if (string.IsNullOrWhiteSpace(directory) || !Directory.Exists(directory))
			{
				return string.Empty;
			}
			foreach (string fileName in fileNames)
			{
				string text = Path.Combine(directory, fileName);
				if (File.Exists(text))
				{
					return text;
				}
			}
			return string.Empty;
		}

		private static bool TryLoadObjMesh(string modelPath, out Mesh mesh, out string summary)
		{
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			mesh = null;
			summary = string.Empty;
			List<Vector3> list = new List<Vector3>(4096);
			List<Vector2> list2 = new List<Vector2>(4096);
			List<Vector3> list3 = new List<Vector3>(4096);
			List<Vector3> list4 = new List<Vector3>(4096);
			List<Vector2> list5 = new List<Vector2>(4096);
			List<Vector3> list6 = new List<Vector3>(4096);
			List<int> list7 = new List<int>(12288);
			Dictionary<ObjVertexKey, int> cache = new Dictionary<ObjVertexKey, int>();
			bool flag = true;
			try
			{
				foreach (string item in File.ReadLines(modelPath))
				{
					if (string.IsNullOrWhiteSpace(item) || item[0] == '#')
					{
						continue;
					}
					if (item.StartsWith("v ", StringComparison.Ordinal))
					{
						if (TryParseVector3(item, out var vector))
						{
							list.Add(vector);
						}
					}
					else if (item.StartsWith("vt ", StringComparison.Ordinal))
					{
						if (TryParseVector2(item, out var vector2))
						{
							list2.Add(vector2);
						}
					}
					else if (item.StartsWith("vn ", StringComparison.Ordinal))
					{
						if (TryParseVector3(item, out var vector3))
						{
							list3.Add(vector3);
						}
					}
					else
					{
						if (!item.StartsWith("f ", StringComparison.Ordinal))
						{
							continue;
						}
						string[] array = item.Substring(2).Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
						if (array.Length < 3)
						{
							continue;
						}
						List<ObjFaceVertex> list8 = new List<ObjFaceVertex>(array.Length);
						string[] array2 = array;
						for (int i = 0; i < array2.Length; i++)
						{
							if (TryParseFaceVertex(array2[i], list.Count, list2.Count, list3.Count, out var vertex))
							{
								list8.Add(vertex);
								if (vertex.NormalIndex < 0)
								{
									flag = false;
								}
							}
						}
						if (list8.Count >= 3)
						{
							for (int j = 1; j < list8.Count - 1; j++)
							{
								AddTriangleVertex(list8[0], list, list2, list3, list4, list5, list6, list7, cache);
								AddTriangleVertex(list8[j], list, list2, list3, list4, list5, list6, list7, cache);
								AddTriangleVertex(list8[j + 1], list, list2, list3, list4, list5, list6, list7, cache);
							}
						}
					}
				}
				if (list4.Count == 0 || list7.Count == 0)
				{
					summary = "no mesh data";
					return false;
				}
				mesh = new Mesh();
				((Object)mesh).name = "AK_RuntimeMesh";
				if (list4.Count > 65535)
				{
					mesh.indexFormat = (IndexFormat)1;
				}
				mesh.SetVertices(list4);
				if (list5.Count == list4.Count)
				{
					mesh.SetUVs(0, list5);
				}
				mesh.subMeshCount = 1;
				mesh.SetTriangles(list7, 0, true);
				if (flag && list6.Count == list4.Count)
				{
					mesh.SetNormals(list6);
				}
				else
				{
					mesh.RecalculateNormals();
				}
				mesh.RecalculateBounds();
				TryRecalculateTangents(mesh);
				summary = "verts=" + list4.Count + ", tris=" + list7.Count / 3;
				return true;
			}
			catch (Exception ex)
			{
				mesh = null;
				summary = ex.GetType().Name + ": " + ex.Message;
				return false;
			}
		}

		private static bool TryParseVector3(string line, out Vector3 vector)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			vector = Vector3.zero;
			string[] array = line.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < 4)
			{
				return false;
			}
			if (float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				vector = new Vector3(result, result2, result3);
				return true;
			}
			return false;
		}

		private static bool TryParseVector2(string line, out Vector2 vector)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			vector = Vector2.zero;
			string[] array = line.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < 3)
			{
				return false;
			}
			if (float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				vector = new Vector2(result, result2);
				return true;
			}
			return false;
		}

		private static bool TryParseFaceVertex(string token, int positionCount, int uvCount, int normalCount, out ObjFaceVertex vertex)
		{
			vertex = default(ObjFaceVertex);
			if (string.IsNullOrWhiteSpace(token))
			{
				return false;
			}
			string[] array = token.Split(new char[1] { '/' });
			if (array.Length == 0)
			{
				return false;
			}
			vertex.PositionIndex = ResolveObjIndex(ParseObjIndex(array[0]), positionCount);
			vertex.UvIndex = ((array.Length >= 2 && !string.IsNullOrWhiteSpace(array[1])) ? ResolveObjIndex(ParseObjIndex(array[1]), uvCount) : (-1));
			vertex.NormalIndex = ((array.Length >= 3 && !string.IsNullOrWhiteSpace(array[2])) ? ResolveObjIndex(ParseObjIndex(array[2]), normalCount) : (-1));
			return vertex.PositionIndex >= 0;
		}

		private static int ParseObjIndex(string value)
		{
			int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
			return result;
		}

		private static int ResolveObjIndex(int rawIndex, int count)
		{
			if (rawIndex > 0)
			{
				return rawIndex - 1;
			}
			if (rawIndex < 0)
			{
				return count + rawIndex;
			}
			return -1;
		}

		private static void AddTriangleVertex(ObjFaceVertex faceVertex, List<Vector3> positions, List<Vector2> uvs, List<Vector3> normals, List<Vector3> outVertices, List<Vector2> outUvs, List<Vector3> outNormals, List<int> outTriangles, Dictionary<ObjVertexKey, int> cache)
		{
			//IL_0058: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			ObjVertexKey key = default(ObjVertexKey);
			key.PositionIndex = faceVertex.PositionIndex;
			key.UvIndex = faceVertex.UvIndex;
			key.NormalIndex = faceVertex.NormalIndex;
			if (!cache.TryGetValue(key, out var value))
			{
				value = (cache[key] = outVertices.Count);
				outVertices.Add(positions[faceVertex.PositionIndex]);
				outUvs.Add((faceVertex.UvIndex >= 0 && faceVertex.UvIndex < uvs.Count) ? uvs[faceVertex.UvIndex] : Vector2.zero);
				outNormals.Add((faceVertex.NormalIndex >= 0 && faceVertex.NormalIndex < normals.Count) ? normals[faceVertex.NormalIndex] : Vector3.zero);
			}
			outTriangles.Add(value);
		}

		private static void TryRecalculateTangents(Mesh mesh)
		{
			if ((Object)(object)mesh == (Object)null)
			{
				return;
			}
			try
			{
				typeof(Mesh).GetMethod("RecalculateTangents", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null)?.Invoke(mesh, null);
			}
			catch
			{
			}
		}

		private static Texture2D LoadTexture(string texturePath, out string summary)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			summary = "texture=missing";
			if (string.IsNullOrWhiteSpace(texturePath) || !File.Exists(texturePath))
			{
				return null;
			}
			try
			{
				byte[] data = File.ReadAllBytes(texturePath);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				((Object)val).name = Path.GetFileNameWithoutExtension(texturePath);
				if (!TryLoadPngIntoTexture(val, data))
				{
					Object.DestroyImmediate((Object)(object)val);
					summary = "texture=decode-failed";
					return null;
				}
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				((Texture)val).anisoLevel = 2;
				summary = "texture=" + ((Texture)val).width + "x" + ((Texture)val).height;
				return val;
			}
			catch (Exception ex)
			{
				summary = "texture-error=" + ex.GetType().Name;
				return null;
			}
		}

		private static bool TryLoadPngIntoTexture(Texture2D texture, byte[] data)
		{
			if ((Object)(object)texture == (Object)null || data == null || data.Length == 0)
			{
				return false;
			}
			try
			{
				MethodInfo method = typeof(Texture2D).GetMethod("LoadImage", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(byte[]) }, null);
				if (method != null)
				{
					if (!(method.Invoke(texture, new object[1] { data }) is bool result))
					{
						return true;
					}
					return result;
				}
			}
			catch
			{
			}
			try
			{
				MethodInfo methodInfo = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule", throwOnError: false)?.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
				{
					typeof(Texture2D),
					typeof(byte[]),
					typeof(bool)
				}, null);
				if (methodInfo != null)
				{
					if (!(methodInfo.Invoke(null, new object[3] { texture, data, false }) is bool result2))
					{
						return true;
					}
					return result2;
				}
			}
			catch
			{
			}
			return false;
		}

		private static Material CreateMaterial(Texture2D texture, string texturePath)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard") ?? Shader.Find("Legacy Shaders/Diffuse");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Material val2 = new Material(val);
			((Object)val2).name = "M_AK_Runtime";
			if (val2.HasProperty("_BaseMap"))
			{
				val2.SetTexture("_BaseMap", (Texture)(object)texture);
			}
			if (val2.HasProperty("_MainTex"))
			{
				val2.SetTexture("_MainTex", (Texture)(object)texture);
			}
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", Color.white);
			}
			if (val2.HasProperty("_Color"))
			{
				val2.SetColor("_Color", Color.white);
			}
			if (val2.HasProperty("_Smoothness"))
			{
				val2.SetFloat("_Smoothness", 0.12f);
			}
			if (val2.HasProperty("_Glossiness"))
			{
				val2.SetFloat("_Glossiness", 0.12f);
			}
			if (val2.HasProperty("_Cull"))
			{
				val2.SetInt("_Cull", 2);
			}
			val2.enableInstancing = true;
			Plugin.LogDiagnosticOnce("ak-light-mat:" + Path.GetFileName(texturePath ?? string.Empty), "Created lightweight AK material with shader=" + (((Object)(object)val != (Object)null) ? ((Object)val).name : "null") + ", texture=" + (((Object)(object)texture != (Object)null) ? (((Texture)texture).width + "x" + ((Texture)texture).height) : "none"));
			return val2;
		}

		private static GameObject BuildPrefab(Mesh mesh, Material material)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mesh == (Object)null || (Object)(object)material == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("AK");
			GameObject val2 = new GameObject("Mesh");
			val2.transform.SetParent(val.transform, false);
			val2.transform.localPosition = MeshLocalPosition;
			val2.transform.localRotation = MeshLocalRotation;
			val2.transform.localScale = MeshLocalScale;
			MeshFilter val3 = val2.AddComponent<MeshFilter>();
			MeshRenderer val4 = val2.AddComponent<MeshRenderer>();
			val3.sharedMesh = mesh;
			((Renderer)val4).sharedMaterials = (Material[])(object)new Material[1] { material };
			((Renderer)val4).enabled = false;
			((Renderer)val4).forceRenderingOff = true;
			((Renderer)val4).shadowCastingMode = (ShadowCastingMode)1;
			((Renderer)val4).receiveShadows = true;
			GameObject val5 = new GameObject("SpawnPos");
			val5.transform.SetParent(val.transform, false);
			val5.transform.localPosition = SpawnLocalPosition;
			val5.transform.localRotation = SpawnLocalRotation;
			val5.transform.localScale = SpawnLocalScale;
			Object.DontDestroyOnLoad((Object)(object)val);
			return val;
		}
	}
	public sealed class AkLocalVisualMarker : MonoBehaviour
	{
	}
	public sealed class AkMuzzleMarker : MonoBehaviour
	{
	}
	public sealed class AkSimpleVisualMarker : MonoBehaviour
	{
	}
	internal static class AkUiPatchHelpers
	{
		private const BindingFlags ReflectionFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static readonly FieldInfo InventoryPrefabField = typeof(InventoryItemUI).GetField("_itemPrefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo InventoryItemDataField = typeof(InventoryItemUI).GetField("_itemData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo ItemDataField = typeof(Item).GetField("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly PropertyInfo ItemDataProperty = typeof(Item).GetProperty("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly PropertyInfo SlotItemProperty = typeof(ItemSlot).GetProperty("item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo SlotItemField = typeof(ItemSlot).GetField("item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo SliceItemSlotField = typeof(BackpackWheelSlice).GetField("itemSlot", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly Dictionary<Type, PropertyInfo> InventoryItemDataItemPropertyCache = new Dictionary<Type, PropertyInfo>();

		private static readonly Dictionary<Type, FieldInfo> InventoryItemDataItemFieldCache = new Dictionary<Type, FieldInfo>();

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

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

		private static readonly Rect FullUvRect = new Rect(0f, 0f, 1f, 1f);

		private static readonly HashSet<InventoryItemUI> TrackedInventoryUis = new HashSet<InventoryItemUI>();

		private static readonly HashSet<BackpackWheelSlice> TrackedSlices = new HashSet<BackpackWheelSlice>();

		private static readonly HashSet<BackpackWheel> TrackedWheels = new HashSet<BackpackWheel>();

		private static readonly List<InventoryItemUI> StaleInventoryUis = new List<InventoryItemUI>();

		private static readonly List<BackpackWheelSlice> StaleSlices = new List<BackpackWheelSlice>();

		private static readonly List<BackpackWheel> StaleWheels = new List<BackpackWheel>();

		internal static void ApplyAkIcon(RawImage image, Item item)
		{
			if (Plugin.IsWeaponFeatureEnabled() && !((Object)(object)image == (Object)null) && ItemPatch.IsBlowgunLike(item))
			{
				ApplyAkIconForce(image);
			}
		}

		internal static void ApplyAkIconForce(RawImage image)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_007b: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)image == (Object)null)
			{
				return;
			}
			Texture2D akIconTexture = Plugin.GetAkIconTexture();
			if (!((Object)(object)akIconTexture == (Object)null))
			{
				Graphic val = (Graphic)image;
				if (!((Object)(object)image.texture == (Object)(object)akIconTexture) || !((Object)(object)val.material == (Object)null) || !(val.color == Color.white) || !(image.uvRect == FullUvRect) || !((Behaviour)image).enabled)
				{
					image.texture = (Texture)akIconTexture;
					val.color = Color.white;
					val.material = null;
					image.uvRect = FullUvRect;
					((Behaviour)image).enabled = true;
				}
			}
		}

		internal static void ApplyAkText(TMP_Text label)
		{
			if (!((Object)(object)label == (Object)null) && !string.Equals(label.text, ItemPatch.DisplayName, StringComparison.Ordinal))
			{
				label.text = ItemPatch.DisplayName;
			}
		}

		internal static void EnsureAkDisplayAndVisual(Item item)
		{
			if (Plugin.IsWeaponFeatureEnabled() && !((Object)(object)item == (Object)null) && ItemPatch.IsBlowgunLike(item))
			{
				ItemPatch.ApplyAkDisplay(item);
			}
		}

		internal static void ApplyAkToInventoryUi(InventoryItemUI ui, Item knownItem = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			if ((Object)ui == (Object)null)
			{
				return;
			}
			TrackInventoryUi(ui);
			Item val = (((Object)(object)knownItem != (Object)null) ? knownItem : ResolveItemFromInventoryUi(ui));
			int instanceID = ((Object)ui).GetInstanceID();
			if (!Plugin.IsWeaponFeatureEnabled())
			{
				return;
			}
			int itemSourceKey = GetItemSourceKey(val);
			if (itemSourceKey != 0 && InventoryUiSourceKeyCache.TryGetValue(instanceID, out var value) && value == itemSourceKey && IsInventoryUiAlreadyShowingAk(ui))
			{
				return;
			}
			if ((Object)(object)val != (Object)null && ItemPatch.IsBlowgunLike(val))
			{
				EnsureAkDisplayAndVisual(val);
				ApplyAkIconForce(ui.icon);
				ApplyAkText((TMP_Text)ui.nameText);
				InventoryUiSourceKeyCache[instanceID] = itemSourceKey;
				return;
			}
			InventoryUiSourceKeyCache[instanceID] = itemSourceKey;
			if ((Object)(object)val != (Object)null)
			{
				RestoreInventoryUi(ui, val);
				return;
			}
			if (itemSourceKey == 0 && IsInventoryUiAlreadyShowingAk(ui))
			{
				ClearInventoryUi(ui);
				return;
			}
			TextMeshProUGUI nameText = ui.nameText;
			string value2 = ((((Object)(object)nameText != (Object)null) ? ((TMP_Text)nameText).text : null) ?? string.Empty).ToLowerInvariant();
			RawImage icon = ui.icon;
			Texture val2 = (((Object)(object)icon != (Object)null) ? icon.texture : null);
			string text = (((Object)(object)val2 != (Object)null) ? ((Object)val2).name : string.Empty).ToLowerInvariant();
			if (ItemPatch.ContainsWeaponKeyword(value2) || text.Contains("dart") || text.Contains("blowgun") || ItemPatch.ContainsWeaponKeyword(text))
			{
				ApplyAkIconForce(ui.icon);
				ApplyAkText((TMP_Text)ui.nameText);
			}
		}

		internal static Item ResolveItemFromInventoryUi(InventoryItemUI ui)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			if ((Object)ui == (Object)null)
			{
				return null;
			}
			try
			{
				object obj = InventoryPrefabField?.GetValue(ui);
				Item val = (Item)((obj is Item) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				object obj2 = InventoryItemDataField?.GetValue(ui);
				if (obj2 != null)
				{
					Item val2 = ResolveItemFromItemData(obj2);
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		internal static Item ResolveItemFromSlot(ItemSlot slot)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			if (slot == null || slot.IsEmpty())
			{
				return null;
			}
			try
			{
				object obj = SlotItemProperty?.GetValue(slot);
				Item val = (Item)((obj is Item) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				object obj2 = SlotItemField?.GetValue(slot);
				Item val2 = (Item)((obj2 is Item) ? obj2 : null);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			catch
			{
			}
			return slot.prefab;
		}

		internal static void ApplyAkToSliceImage(BackpackWheelSlice slice, Item knownItem = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)slice == (Object)null)
			{
				return;
			}
			TrackSlice(slice);
			Item val = (((Object)(object)knownItem != (Object)null) ? knownItem : ResolveItemFromSlice(slice));
			int instanceID = ((Object)slice).GetInstanceID();
			if (!Plugin.IsWeaponFeatureEnabled())
			{
				return;
			}
			int itemSourceKey = GetItemSourceKey(val);
			if (itemSourceKey == 0 || !SliceSourceKeyCache.TryGetValue(instanceID, out var value) || value != itemSourceKey || !IsSliceAlreadyShowingAk(slice))
			{
				if (!((Object)(object)val == (Object)null) && ItemPatch.IsBlowgunLike(val))
				{
					EnsureAkDisplayAndVisual(val);
					ApplyAkIconForce(slice.image);
				}
				else
				{
					RestoreSliceImage(slice, val);
				}
				SliceSourceKeyCache[instanceID] = itemSourceKey;
			}
		}

		internal static void ApplyAkToBackpackWheel(BackpackWheel wheel, Item knownItem = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)wheel == (Object)null)
			{
				return;
			}
			TrackWheel(wheel);
			Item val = knownItem;
			if ((Object)(object)val == (Object)null)
			{
				Character localCharacter = Character.localCharacter;
				object obj;
				if (localCharacter == null)
				{
					obj = null;
				}
				else
				{
					CharacterData data = localCharacter.data;
					obj = ((data != null) ? data.currentItem : null);
				}
				val = (Item)obj;
			}
			Character localCharacter2 = Character.localCharacter;
			if (Plugin.IsWeaponFeatureEnabled())
			{
				if (!((Object)(object)val == (Object)null) && ItemPatch.IsBlowgunLike(val) && ItemPatch.IsLocallyHeldByPlayer(val, localCharacter2))
				{
					ItemPatch.ApplyAkDisplayIfNeeded(val);
					ApplyAkIcon(wheel.currentlyHeldItem, val);
				}
				else
				{
					RestoreBackpackWheel(wheel, ((Object)(object)val != (Object)null && ItemPatch.IsBlowgunLike(val)) ? null : val);
				}
			}
		}

		internal static bool RefreshTrackedUi()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			CleanupStaleTrackedUi();
			bool result = false;
			foreach (InventoryItemUI trackedInventoryUi in TrackedInventoryUis)
			{
				if (!((Object)trackedInventoryUi == (Object)null))
				{
					ApplyAkToInventoryUi(trackedInventoryUi);
					result = true;
				}
			}
			foreach (BackpackWheelSlice trackedSlice in TrackedSlices)
			{
				if (!((Object)trackedSlice == (Object)null))
				{
					ApplyAkToSliceImage(trackedSlice);
					result = true;
				}
			}
			foreach (BackpackWheel trackedWheel in TrackedWheels)
			{
				if (!((Object)trackedWheel == (Object)null))
				{
					ApplyAkToBackpackWheel(trackedWheel);
					result = true;
				}
			}
			return result;
		}

		internal static void ClearInventoryUiCache(InventoryItemUI ui)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if (!((Object)ui == (Object)null))
			{
				InventoryUiSourceKeyCache.Remove(((Object)ui).GetInstanceID());
			}
		}

		internal static void ClearRuntimeCaches()
		{
			InventoryUiSourceKeyCache.Clear();
			SliceSourceKeyCache.Clear();
			TrackedInventoryUis.Clear();
			TrackedSlices.Clear();
			TrackedWheels.Clear();
			StaleInventoryUis.Clear();
			StaleSlices.Clear();
			StaleWheels.Clear();
		}

		private static Item ResolveItemFromItemData(object itemData)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			if (itemData == null)
			{
				return null;
			}
			Type type = itemData.GetType();
			if (!InventoryItemDataItemPropertyCache.TryGetValue(type, out var value))
			{
				value = type.GetProperty("item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				InventoryItemDataItemPropertyCache[type] = value;
				InventoryItemDataItemFieldCache[type] = type.GetField("item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			try
			{
				object obj = value?.GetValue(itemData) ?? InventoryItemDataItemFieldCache[type]?.GetValue(itemData);
				return (Item)((obj is Item) ? obj : null);
			}
			catch
			{
				return null;
			}
		}

		private static int GetItemSourceKey(Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				return ((Object)item).GetInstanceID();
			}
			return 0;
		}

		internal static bool IsInventoryUiAlreadyShowingAk(InventoryItemUI ui)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)ui == (Object)null)
			{
				return false;
			}
			TextMeshProUGUI nameText = ui.nameText;
			if (!string.Equals((nameText != null) ? ((TMP_Text)nameText).text : null, ItemPatch.DisplayName, StringComparison.Ordinal))
			{
				return false;
			}
			Texture2D akIconTexture = Plugin.GetAkIconTexture();
			RawImage icon = ui.icon;
			if ((Object)(object)akIconTexture != (Object)null && !((Object)(object)icon == (Object)null))
			{
				return (Object)(object)icon.texture == (Object)(object)akIconTexture;
			}
			return false;
		}

		private static bool IsSliceAlreadyShowingAk(BackpackWheelSlice slice)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)slice == (Object)null)
			{
				return false;
			}
			Texture2D akIconTexture = Plugin.GetAkIconTexture();
			RawImage image = slice.image;
			if ((Object)(object)akIconTexture != (Object)null && !((Object)(object)image == (Object)null))
			{
				return (Object)(object)image.texture == (Object)(object)akIconTexture;
			}
			return false;
		}

		private static void RestoreInventoryUi(InventoryItemUI ui, Item item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)ui == (Object)null) && !((Object)(object)item == (Object)null))
			{
				Texture val = ResolveDefaultItemIcon(item);
				if (!((Object)(object)ui.icon == (Object)null))
				{
					ui.icon.texture = val;
					((Graphic)ui.icon).color = ResolveInventoryIconColor(ui, Color.white);
					((Graphic)ui.icon).material = null;
					ui.icon.uvRect = FullUvRect;
					((Behaviour)ui.icon).enabled = (Object)(object)val != (Object)null;
				}
				if (!((Object)(object)ui.nameText == (Object)null))
				{
					((TMP_Text)ui.nameText).text = ResolveDefaultItemName(item);
				}
			}
		}

		private static void ClearInventoryUi(InventoryItemUI ui)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if (!((Object)ui == (Object)null))
			{
				if (!((Object)(object)ui.icon == (Object)null))
				{
					ui.icon.texture = null;
					((Behaviour)ui.icon).enabled = false;
				}
				if (!((Object)(object)ui.nameText == (Object)null))
				{
					((TMP_Text)ui.nameText).text = string.Empty;
				}
			}
		}

		private static void RestoreSliceImage(BackpackWheelSlice slice, Item item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)slice == (Object)null) && !((Object)(object)slice.image == (Object)null))
			{
				Texture val = ResolveDefaultItemIcon(item);
				slice.image.texture = val;
				((Graphic)slice.image).color = ResolveSliceIconColor(slice, Color.white);
				((Graphic)slice.image).material = null;
				slice.image.uvRect = FullUvRect;
				((Behaviour)slice.image).enabled = (Object)(object)val != (Object)null;
			}
		}

		private static void RestoreBackpackWheel(BackpackWheel wheel, Item item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)wheel == (Object)null))
			{
				RawImage currentlyHeldItem = wheel.currentlyHeldItem;
				if (!((Object)(object)currentlyHeldItem == (Object)null))
				{
					Texture val2 = (currentlyHeldItem.texture = ResolveDefaultItemIcon(item));
					((Graphic)currentlyHeldItem).color = ResolveItemIconColor(item, Color.white);
					((Graphic)currentlyHeldItem).material = null;
					currentlyHeldItem.uvRect = FullUvRect;
					((Behaviour)currentlyHeldItem).enabled = (Object)(object)val2 != (Object)null;
				}
			}
		}

		private static Texture ResolveDefaultItemIcon(Item item)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null || item.UIData == null)
			{
				return null;
			}
			try
			{
				return (Texture)item.UIData.GetIcon();
			}
			catch
			{
				return (Texture)item.UIData.icon;
			}
		}

		private static Color ResolveInventoryIconColor(InventoryItemUI ui, Color fallback)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)ui == (Object)null)
			{
				return fallback;
			}
			try
			{
				Color color;
				return TryGetCookColor(InventoryItemDataField?.GetValue(ui), out color) ? color : fallback;
			}
			catch
			{
				return fallback;
			}
		}

		private static Color ResolveSliceIconColor(BackpackWheelSlice slice, Color fallback)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			ItemSlot val = ResolveItemSlotFromSlice(slice);
			if (val == null || !TryGetCookColor(val.data, out var color))
			{
				return fallback;
			}
			return color;
		}

		private static Color ResolveItemIconColor(Item item, Color fallback)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return fallback;
			}
			try
			{
				Color color;
				return TryGetCookColor(ItemDataField?.GetValue(item) ?? ItemDataProperty?.GetValue(item), out color) ? color : fallback;
			}
			catch
			{
				return fallback;
			}
		}

		private static bool TryGetCookColor(object itemData, out Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			color = Color.white;
			ItemInstanceData val = (ItemInstanceData)((itemData is ItemInstanceData) ? itemData : null);
			IntItemData val2 = default(IntItemData);
			if (val != null && val.TryGetDataEntry<IntItemData>((DataEntryKey)1, ref val2) && val2 != null && val2.Value > 0)
			{
				color = ItemCooking.GetCookColor(val2.Value);
				return true;
			}
			return false;
		}

		private static string ResolveDefaultItemName(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				string itemName = item.GetItemName((ItemInstanceData)null);
				if (!string.IsNullOrWhiteSpace(itemName))
				{
					return itemName;
				}
			}
			catch
			{
			}
			return item.UIData?.itemName ?? string.Empty;
		}

		internal static Item ResolveItemFromSlice(BackpackWheelSlice slice)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)slice == (Object)null)
			{
				return null;
			}
			try
			{
				PropertyInfo[] properties = ((object)slice).GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (!(propertyInfo == null) && propertyInfo.GetIndexParameters().Length == 0)
					{
						object value = null;
						try
						{
							value = propertyInfo.GetValue(slice);
						}
						catch
						{
						}
						Item val = ExtractItem(value);
						if ((Object)(object)val != (Object)null)
						{
							return val;
						}
					}
				}
				FieldInfo[] fields = ((object)slice).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					object value2 = null;
					try
					{
						value2 = fieldInfo.GetValue(slice);
					}
					catch
					{
					}
					Item val2 = ExtractItem(value2);
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static ItemSlot ResolveItemSlotFromSlice(BackpackWheelSlice slice)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)slice == (Object)null || SliceItemSlotField == null)
			{
				return null;
			}
			try
			{
				object? value = SliceItemSlotField.GetValue(slice);
				return (ItemSlot)((value is ItemSlot) ? value : null);
			}
			catch
			{
				return null;
			}
		}

		private static void TrackInventoryUi(InventoryItemUI ui)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if (!((Object)ui == (Object)null) && !TrackedInventoryUis.Contains(ui))
			{
				TrackedInventoryUis.Add(ui);
			}
		}

		private static void TrackSlice(BackpackWheelSlice slice)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if (!((Object)slice == (Object)null) && !TrackedSlices.Contains(slice))
			{
				TrackedSlices.Add(slice);
			}
		}

		private static void TrackWheel(BackpackWheel wheel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if (!((Object)wheel == (Object)null) && !TrackedWheels.Contains(wheel))
			{
				TrackedWheels.Add(wheel);
			}
		}

		private static void CleanupStaleTrackedUi()
		{
			RemoveDestroyedTrackedObjects<InventoryItemUI>(TrackedInventoryUis, StaleInventoryUis);
			RemoveDestroyedTrackedObjects<BackpackWheelSlice>(TrackedSlices, StaleSlices);
			RemoveDestroyedTrackedObjects<BackpackWheel>(TrackedWheels, StaleWheels);
		}

		private static void RemoveDestroyedTrackedObjects<T>(HashSet<T> source, List<T> staleBuffer) where T : Object
		{
			if (source.Count == 0)
			{
				return;
			}
			staleBuffer.Clear();
			foreach (T item in source)
			{
				if ((Object)(object)item == (Object)null)
				{
					staleBuffer.Add(item);
				}
			}
			for (int i = 0; i < staleBuffer.Count; i++)
			{
				source.Remove(staleBuffer[i]);
			}
			staleBuffer.Clear();
		}

		private static Item ExtractItem(object value)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			Item val = (Item)((value is Item) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			ItemSlot val2 = (ItemSlot)((value is ItemSlot) ? value : null);
			if (val2 != null)
			{
				return ResolveItemFromSlot(val2);
			}
			if (value == null)
			{
				return null;
			}
			Type type = value.GetType();
			if (!(type.FullName ?? string.Empty).StartsWith("System.ValueTuple", StringComparison.Ordinal))
			{
				return null;
			}
			try
			{
				FieldInfo field = type.GetField("Item1");
				FieldInfo? field2 = type.GetField("Item2");
				object obj = field?.GetValue(value);
				object obj2 = field2?.GetValue(value);
				if (obj is BackpackReference)
				{
					BackpackReference backpackRef = (BackpackReference)obj;
					if (obj2 is byte slotIndex)
					{
						return ResolveFromBackpackTuple(backpackRef, slotIndex);
					}
					if (obj2 is int)
					{
						int num = (int)obj2;
						return ResolveFromBackpackTuple(backpackRef, (byte)Mathf.Clamp(num, 0, 255));
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static Item ResolveFromBackpackTuple(BackpackReference backpackRef, byte slotIndex)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((object)backpackRef == null)
				{
					return null;
				}
				object data = ((BackpackReference)(ref backpackRef)).GetData();
				if (data == null)
				{
					return null;
				}
				if (!((data.GetType().GetProperty("itemSlots", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(data) ?? data.GetType().GetField("itemSlots", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(data)) is ItemSlot[] array) || slotIndex >= array.Length)
				{
					return null;
				}
				return ResolveItemFromSlot(array[slotIndex]);
			}
			catch
			{
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(BackpackWheel), "UpdateCookedAmount")]
	public static class BackpackWheelCookColorPatch
	{
		[HarmonyPostfix]
		public static void UpdateCookedAmountPostfix(BackpackWheel __instance, Item item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return;
				}
				object obj;
				if (!((Object)(object)item != (Object)null))
				{
					Character localCharacter = Character.localCharacter;
					if ((Object)(object)localCharacter == (Object)null)
					{
						obj = null;
					}
					else
					{
						CharacterData data = localCharacter.data;
						obj = (((Object)(object)data != (Object)null) ? data.currentItem : null);
					}
				}
				else
				{
					obj = item;
				}
				Item val = (Item)obj;
				if (!((Object)(object)val == (Object)null) && ItemPatch.IsBlowgunLike(val))
				{
					AkUiPatchHelpers.ApplyAkIconForce(__instance.currentlyHeldItem);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheel), "InitWheel")]
	public static class BackpackWheelPatch
	{
		[HarmonyPostfix]
		public static void InitWheelPostfix(BackpackWheel __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					AkUiPatchHelpers.ApplyAkToBackpackWheel(__instance);
					BackpackWheelSlice[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<BackpackWheelSlice>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						AkUiPatchHelpers.ApplyAkToSliceImage(componentsInChildren[i]);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[ShootZombies] BackpackWheelPatch failed: " + ex));
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheelSlice), "SetItemIcon")]
	public static class BackpackWheelSetItemIconPatch
	{
		[HarmonyPostfix]
		public static void SetItemIconPostfix(BackpackWheelSlice __instance, Item iconHolder, ItemInstanceData itemInstanceData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					Item val = (((Object)(object)iconHolder != (Object)null) ? iconHolder : AkUiPatchHelpers.ResolveItemFromSlice(__instance));
					if (!((Object)(object)val == (Object)null) && ItemPatch.IsBlowgunLike(val))
					{
						AkUiPatchHelpers.ApplyAkToSliceImage(__instance, val);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] BackpackWheelSetItemIconPatch failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheelSlice), "SharedInit")]
	public static class BackpackWheelSharedInitPatch
	{
		[HarmonyPostfix]
		public static void SharedInitPostfix(BackpackWheelSlice __instance, BackpackReference bpRef, BackpackWheel wheel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					AkUiPatchHelpers.ApplyAkToSliceImage(__instance);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] BackpackWheelSharedInitPatch failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheelSlice), "UpdateCookedAmount")]
	public static class BackpackWheelSliceCookColorPatch
	{
		[HarmonyPostfix]
		public static void UpdateCookedAmountPostfix(BackpackWheelSlice __instance, Item item, ItemInstanceData itemInstanceData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					Item val = (((Object)(object)item != (Object)null) ? item : AkUiPatchHelpers.ResolveItemFromSlice(__instance));
					if (!((Object)(object)val == (Object)null) && ItemPatch.IsBlowgunLike(val))
					{
						AkUiPatchHelpers.ApplyAkIconForce(__instance.image);
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheelSlice), "InitItemSlot")]
	public static class BackpackWheelSlicePatch
	{
		[HarmonyPostfix]
		public static void InitItemSlotPostfix(BackpackWheelSlice __instance, (BackpackReference, byte) slot, BackpackWheel wheel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					ItemSlot val = ((BackpackReference)(ref slot.Item1)).GetData().itemSlots[slot.Item2];
					if (val != null && !val.IsEmpty() && ItemPatch.IsBlowgunLike(val.prefab))
					{
						Item val2 = AkUiPatchHelpers.ResolveItemFromSlot(val);
						Item val3 = (((Object)(object)val2 != (Object)null) ? val2 : val.prefab);
						ItemPatch.ApplyAkDisplayIfNeeded(val3);
						ItemPatch.ApplyAkDisplayIfNeeded(val.prefab);
						AkUiPatchHelpers.ApplyAkToSliceImage(__instance, val3);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[ShootZombies] BackpackWheelSlicePatch failed: " + ex));
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheelSlice), "InitStashSlot")]
	public static class BackpackWheelStashSlicePatch
	{
		[HarmonyPostfix]
		public static void InitStashSlotPostfix(BackpackWheelSlice __instance, BackpackReference bpRef, BackpackWheel wheel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return;
				}
				Item val = AkUiPatchHelpers.ResolveItemFromSlice(__instance);
				if ((Object)(object)val == (Object)null)
				{
					Character localCharacter = Character.localCharacter;
					object obj;
					if ((Object)(object)localCharacter == (Object)null)
					{
						obj = null;
					}
					else
					{
						CharacterData data = localCharacter.data;
						obj = (((Object)(object)data != (Object)null) ? data.currentItem : null);
					}
					val = (Item)obj;
				}
				if (!((Object)(object)val == (Object)null) && ItemPatch.IsBlowgunLike(val))
				{
					AkUiPatchHelpers.ApplyAkToSliceImage(__instance, val);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[ShootZombies] BackpackWheelStashSlicePatch failed: " + ex));
			}
		}
	}
	[HarmonyPatch]
	public class BlowgunChargeSoundPatch
	{
		private static MethodInfo _targetMethod;

		private static FieldInfo _castProgressField;

		private static float _lastCastProgress;

		private static bool _hasPlayedGunshot;

		private static MethodBase TargetMethod()
		{
			if (_targetMethod == null)
			{
				Type type = typeof(Item).Assembly.GetType("SFX_Instance");
				if (type != null)
				{
					_targetMethod = type.GetMethod("Play", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(Vector3) }, null);
					if (_targetMethod == null)
					{
						_targetMethod = type.GetMethods(BindingFlags.Instance | BindingFlags.Public).FirstOrDefault((MethodInfo m) => m.Name == "Play" && m.GetParameters().Length == 1);
					}
				}
			}
			return _targetMethod;
		}

		private static bool Prefix(object __instance)
		{
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return true;
				}
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter == (Object)null)
				{
					return true;
				}
				if ((Object)(object)localCharacter.player == (Object)null)
				{
					return true;
				}
				CharacterData data = localCharacter.data;
				Item val = (((Object)(object)data != (Object)null) ? data.currentItem : null);
				if ((Object)(object)val == (Object)null || !ItemPatch.IsBlowgunLike(val))
				{
					return true;
				}
				if (_castProgressField == null)
				{
					_castProgressField = ((object)val).GetType().GetField("<castProgress>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (_castProgressField == null)
				{
					return true;
				}
				float num = (float)_castProgressField.GetValue(val);
				bool flag = _lastCastProgress >= 0.99f;
				bool flag2 = num >= 0.99f;
				_lastCastProgress = num;
				if (!flag2)
				{
					_hasPlayedGunshot = false;
					return false;
				}
				if (!flag && flag2 && !_hasPlayedGunshot)
				{
					_hasPlayedGunshot = true;
					return false;
				}
				return false;
			}
			catch (Exception)
			{
			}
			return true;
		}
	}
	[HarmonyPatch]
	public class BlowgunInfiniteUsePatch
	{
		private const int BlowgunItemId = 70;

		private static Type _actionRaycastDartType;

		private static Type _actionConsumeType;

		private static Type _actionConsumeAndSpawnType;

		private static bool _itemDataAccessorsResolved;

		private static MethodInfo _getDataGenericMethod;

		private static Type _optionableIntItemDataType;

		private static FieldInfo _optionableIntHasDataField;

		private static FieldInfo _optionableIntValueField;

		private static MethodBase TargetMethod()
		{
			MethodInfo[] methods = typeof(Item).GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name.Contains("Use") || methodInfo.Name.Contains("Fire") || methodInfo.Name.Contains("Shoot"))
				{
					return methodInfo;
				}
			}
			return null;
		}

		private static void Postfix(Item __instance)
		{
			try
			{
				if (Plugin.IsWeaponFeatureEnabled() && IsBlowgunItem(__instance))
				{
					SetBlowgunUseCount(__instance, 9999);
					NormalizeEnabledBlowgunRuntimeState(__instance);
					Type type = ((object)__instance).GetType();
					float num = Plugin.FireInterval?.Value ?? 0.4f;
					FieldInfo field = type.GetField("usingTimePrimary", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						field.SetValue(__instance, num);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		internal static void RestoreVanillaSingleUseOnAllBlowguns()
		{
			try
			{
				Item[] array = Resources.FindObjectsOfTypeAll<Item>();
				for (int i = 0; i < array.Length; i++)
				{
					RestoreVanillaSingleUse(array[i]);
				}
			}
			catch (Exception)
			{
			}
		}

		internal static void EnsureInfiniteUse(Item item)
		{
			try
			{
				if (Plugin.IsWeaponFeatureEnabled() && IsBlowgunItem(item))
				{
					SetBlowgunUseCount(item, 9999);
					NormalizeEnabledBlowgunRuntimeState(item);
				}
			}
			catch (Exception)
			{
			}
		}

		internal static void RestoreVanillaSingleUse(Item item)
		{
			try
			{
				if (IsBlowgunItem(item))
				{
					SetBlowgunUseCount(item, 1);
					NormalizeRaycastDartComponents(item);
					NormalizeRaycastDartComponents(item.isSecretlyOtherItemPrefab);
					RestoreRaycastDartAction(item);
					RestoreRaycastDartAction(item.isSecretlyOtherItemPrefab);
				}
			}
			catch (Exception)
			{
			}
		}

		internal static bool IsBlowgunItem(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			try
			{
				if (item.itemID == 70)
				{
					return true;
				}
				if ((Object)(object)item.isSecretlyOtherItemPrefab != (Object)null && item.isSecretlyOtherItemPrefab.itemID == 70)
				{
					return true;
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		internal static void NormalizeEnabledBlowgunRuntimeState(Item item)
		{
			try
			{
				if (Plugin.IsWeaponFeatureEnabled() && IsBlowgunItem(item))
				{
					NormalizeRaycastDartComponents(item);
					NormalizeRaycastDartComponents(item.isSecretlyOtherItemPrefab);
					DisableConsumableActions(item);
				}
			}
			catch
			{
			}
		}

		internal static void NormalizeDartRpcComponents(Item item)
		{
			try
			{
				if (!((Object)(object)item == (Object)null) && ItemPatch.IsBlowgunLike(item))
				{
					NormalizeRaycastDartComponents(item);
					NormalizeRaycastDartComponents(item.isSecretlyOtherItemPrefab);
				}
			}
			catch
			{
			}
		}

		private static void NormalizeRaycastDartComponents(Item item)
		{
			try
			{
				if ((Object)(object)item == (Object)null)
				{
					return;
				}
				if (_actionRaycastDartType == null)
				{
					_actionRaycastDartType = typeof(Item).Assembly.GetType("Action_RaycastDart");
				}
				if (_actionRaycastDartType == null)
				{
					return;
				}
				Component[] componentsInChildren = ((Component)item).GetComponentsInChildren(_actionRaycastDartType, true);
				if (componentsInChildren == null || componentsInChildren.Length <= 1)
				{
					return;
				}
				for (int i = 1; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
					}
				}
			}
			catch
			{
			}
		}

		private static void DisableConsumableActions(Item item)
		{
			try
			{
				if (!((Object)(object)item == (Object)null))
				{
					if (_actionConsumeType == null)
					{
						_actionConsumeType = typeof(Item).Assembly.GetType("Action_Consume");
					}
					if (_actionConsumeAndSpawnType == null)
					{
						_actionConsumeAndSpawnType = typeof(Item).Assembly.GetType("Action_ConsumeAndSpawn");
					}
					DestroyActionsByType(item, _actionConsumeType);
					DestroyActionsByType(item, _actionConsumeAndSpawnType);
				}
			}
			catch
			{
			}
		}

		private static void DestroyActionsByType(Item item, Type actionType)
		{
			if ((Object)(object)item == (Object)null || actionType == null)
			{
				return;
			}
			Component[] componentsInChildren = ((Component)item).GetComponentsInChildren(actionType, true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val);
				}
			}
		}

		private static void RestoreRaycastDartAction(Item item)
		{
			try
			{
				if ((Object)(object)item == (Object)null)
				{
					return;
				}
				if (_actionRaycastDartType == null)
				{
					_actionRaycastDartType = typeof(Item).Assembly.GetType("Action_RaycastDart");
				}
				if (!(_actionRaycastDartType == null))
				{
					Component val = ((Component)item).GetComponentInChildren(_actionRaycastDartType, true);
					if ((Object)(object)val == (Object)null)
					{
						val = ((Component)item).GetComponent(_actionRaycastDartType);
					}
					Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.enabled = true;
					}
				}
			}
			catch
			{
			}
		}

		private static void SetBlowgunUseCount(Item item, int value)
		{
			if ((Object)(object)item == (Object)null || !TryResolveItemDataAccessors())
			{
				return;
			}
			MethodInfo methodInfo = _getDataGenericMethod.MakeGenericMethod(_optionableIntItemDataType);
			ParameterInfo[] parameters = methodInfo.GetParameters();
			object[] array = new object[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				if (parameters[i].ParameterType == typeof(DataEntryKey))
				{
					array[i] = (object)(DataEntryKey)2;
				}
			}
			object obj = methodInfo.Invoke(item, array);
			if (obj != null)
			{
				_optionableIntHasDataField?.SetValue(obj, true);
				_optionableIntValueField?.SetValue(obj, value);
			}
		}

		private static bool TryResolveItemDataAccessors()
		{
			if (_itemDataAccessorsResolved)
			{
				if (_getDataGenericMethod != null && _optionableIntItemDataType != null)
				{
					return _optionableIntValueField != null;
				}
				return false;
			}
			_itemDataAccessorsResolved = true;
			MethodInfo[] methods = typeof(Item).GetMethods(BindingFlags.Instance | BindingFlags.Public);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == "GetData" && methodInfo.IsGenericMethod)
				{
					_getDataGenericMethod = methodInfo;
					break;
				}
			}
			Type[] types = typeof(Item).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.Name == "OptionableIntItemData")
				{
					_optionableIntItemDataType = type;
					break;
				}
			}
			if (_optionableIntItemDataType != null)
			{
				_optionableIntHasDataField = _optionableIntItemDataType.GetField("HasData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_optionableIntValueField = _optionableIntItemDataType.GetField("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_getDataGenericMethod != null && _optionableIntItemDataType != null)
			{
				return _optionableIntValueField != null;
			}
			return false;
		}
	}
	[HarmonyPatch]
	public static class BlowgunItemRuntimeNormalizePatch
	{
		[CompilerGenerated]
		private sealed class <TargetMethods>d__1 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private MethodBase <>2__current;

			private int <>l__initialThreadId;

			private MethodInfo[] <>7__wrap1;

			private int <>7__wrap2;

			MethodBase IEnumerator<MethodBase>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <TargetMethods>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_006e;
				}
				<>1__state = -1;
				<>7__wrap1 = typeof(Item).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				<>7__wrap2 = 0;
				goto IL_007c;
				IL_006e:
				<>7__wrap2++;
				goto IL_007c;
				IL_007c:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					MethodInfo methodInfo = <>7__wrap1[<>7__wrap2];
					if (TargetMethodNames.Contains(methodInfo.Name))
					{
						<>2__current = methodInfo;
						<>1__state = 1;
						return true;
					}
					goto IL_006e;
				}
				<>7__wrap1 = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <TargetMethods>d__1(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<MethodBase>)this).GetEnumerator();
			}
		}

		private static readonly HashSet<string> TargetMethodNames = new HashSet<string>(StringComparer.Ordinal) { "Awake", "OnEnable", "Start", "OnInstanceDataSet", "SetState" };

		[IteratorStateMachine(typeof(<TargetMethods>d__1))]
		private static IEnumerable<MethodBase> TargetMethods()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TargetMethods>d__1(-2);
		}

		private static void Postfix(Item __instance)
		{
			BlowgunInfiniteUsePatch.NormalizeDartRpcComponents(__instance);
			if (!Plugin.IsWeaponFeatureEnabled())
			{
				BlowgunInfiniteUsePatch.RestoreVanillaSingleUse(__instance);
				return;
			}
			BlowgunInfiniteUsePatch.EnsureInfiniteUse(__instance);
			Plugin.TryProtectWeaponItemRuntime(__instance);
		}
	}
	[HarmonyPatch(typeof(ItemCooking), "Wreck")]
	public class BlowgunWreckPatch
	{
		private static bool Prefix(ItemCooking __instance)
		{
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return true;
				}
				Item component = ((Component)__instance).GetComponent<Item>();
				if ((Object)(object)component != (Object)null)
				{
					string name = component.GetName();
					if ((name != null && name.Contains("吹箭筒")) || (name != null && name.Contains("Blowgun")) || (name != null && name.Contains("HealingDart")) || (name != null && name.Contains("Dart")))
					{
						return false;
					}
				}
			}
			catch
			{
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class DartImpactPatch
	{
		private static MethodBase _targetMethod;

		public static MethodBase TargetMethod()
		{
			if (_targetMethod != null)
			{
				return _targetMethod;
			}
			try
			{
				MethodInfo methodInfo = typeof(Item).Assembly.GetType("Action_RaycastDart")?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo m)
				{
					if (!string.Equals(m.Name, "RPC_DartImpact", StringComparison.Ordinal))
					{
						return false;
					}
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length != 3 && parameters.Length != 4)
					{
						return false;
					}
					return parameters[0].ParameterType == typeof(int) && parameters[1].ParameterType == typeof(Vector3) && parameters[2].ParameterType == typeof(Vector3);
				});
				if (methodInfo != null)
				{
					_targetMethod = methodInfo;
					return _targetMethod;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[DartImpactPatch] TargetMethod error: " + ex));
			}
			Plugin.Log.LogWarning((object)"[DartImpactPatch] TargetMethod returning null - RPC_DartImpact method not found");
			return null;
		}

		[HarmonyPrefix]
		public static bool DartImpactPrefix(MonoBehaviour __instance, int characterID, Vector3 origin, Vector3 endpoint)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Item componentInParent = ((Component)__instance).GetComponentInParent<Item>();
				if (!Plugin.IsWeaponFeatureEnabled() || (Object)(object)componentInParent == (Object)null || !ItemPatch.IsBlowgunLike(componentInParent))
				{
					return true;
				}
				if (characterID > 0)
				{
					PhotonView val = PhotonView.Find(characterID);
					if ((Object)(object)val != (Object)null)
					{
						Character componentInParent2 = ((Component)val).gameObject.GetComponentInParent<Character>();
						if ((Object)(object)componentInParent2 != (Object)null && (componentInParent2.isZombie || componentInParent2.isBot))
						{
							Plugin.HandleZombieDartImpactVisual((Component)__instance, endpoint);
							Plugin.Instance?.HitZombie(componentInParent2, origin);
							return false;
						}
						if ((Object)(object)componentInParent2 != (Object)null && !componentInParent2.isZombie && !componentInParent2.isBot)
						{
							return false;
						}
					}
				}
				Plugin.HandleZombieDartImpactVisual((Component)__instance, endpoint);
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[DartImpactPatch] Error: " + ex));
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class LocalDartImpactPatch
	{
		private static MethodBase _targetMethod;

		public static MethodBase TargetMethod()
		{
			if (_targetMethod != null)
			{
				return _targetMethod;
			}
			try
			{
				MethodInfo methodInfo = typeof(Item).Assembly.GetType("Action_RaycastDart")?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => string.Equals(m.Name, "DartImpact", StringComparison.Ordinal) && m.GetParameters().Length == 3 && m.GetParameters()[0].ParameterType == typeof(Character) && m.GetParameters()[1].ParameterType == typeof(Vector3) && m.GetParameters()[2].ParameterType == typeof(Vector3));
				if (methodInfo != null)
				{
					_targetMethod = methodInfo;
					return _targetMethod;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[LocalDartImpactPatch] TargetMethod error: " + ex));
			}
			Plugin.Log.LogWarning((object)"[LocalDartImpactPatch] TargetMethod returning null - DartImpact method not found");
			return null;
		}

		[HarmonyPrefix]
		public static bool DartImpactPrefix(MonoBehaviour __instance, Character hitCharacter, Vector3 origin, Vector3 endpoint)
		{
			//IL_0031: 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_003c: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0068: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			try
			{
				Item componentInParent = ((Component)__instance).GetComponentInParent<Item>();
				if (!Plugin.IsWeaponFeatureEnabled() || (Object)(object)componentInParent == (Object)null || !ItemPatch.IsBlowgunLike(componentInParent))
				{
					return true;
				}
				if ((Object)(object)hitCharacter == (Object)null)
				{
					Plugin.HandleZombieDartImpactVisual((Component)__instance, endpoint);
					return false;
				}
				if (hitCharacter.isZombie || hitCharacter.isBot)
				{
					Plugin.HandleZombieDartImpactVisual((Component)__instance, endpoint);
					Plugin.Instance?.HitZombie(hitCharacter, origin);
					return false;
				}
				Plugin.HandleZombieDartImpactVisual((Component)__instance, endpoint);
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[LocalDartImpactPatch] Error: " + ex));
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class DisableZombieSleepPatch
	{
		private const float DefaultTargetSearchInterval = 10f;

		private const float DefaultSamePlayerBiteCooldown = 5f;

		private const float DefaultPostBiteRecoveryTime = 3f;

		private const int LungeRecoveryState = 5;

		private const float PostBiteRecoverySyncThreshold = 0.45999998f;

		internal const float PostBiteRecoveryFallWindow = 0.45f;

		private const float CloseRangeLungeDistanceScale = 0.35f;

		private const float CloseRangeLungeDistanceMin = 2.75f;

		private const float CloseRangeLungeDistanceMax = 4.25f;

		private const float MinimumChaseBeforeLunge = 0.65f;

		private const float MaximumLungeVerticalDelta = 2.25f;

		private static readonly MethodInfo CharacterFallMethod = AccessTools.Method(typeof(Character), "Fall", new Type[2]
		{
			typeof(float),
			typeof(float)
		}, (Type[])null);

		private static readonly MethodInfo StartChasingMethod = AccessTools.Method(typeof(MushroomZombie), "StartChasing", Type.EmptyTypes, (Type[])null);

		private static readonly MethodInfo StartLungingMethod = AccessTools.Method(typeof(MushroomZombie), "StartLunging", Type.EmptyTypes, (Type[])null);

		private static readonly MethodInfo CanSeeTargetMethod = AccessTools.Method(typeof(MushroomZombie), "CanSeeTarget", new Type[1] { typeof(Character) }, (Type[])null);

		private static readonly FieldInfo LungeRecoveryTimerField = AccessTools.Field(typeof(MushroomZombie), "timeSpentRecoveringFromLunge");

		private static readonly FieldInfo TimeSpentChasingField = AccessTools.Field(typeof(MushroomZombie), "timeSpentChasing");

		private static readonly Dictionary<int, float> PostBiteRecoveryUntilByZombieViewId = new Dictionary<int, float>();

		private static bool UseVanillaBehavior()
		{
			return Plugin.IsVanillaZombieBehaviorDifficultyRuntime();
		}

		private static float GetTargetSearchInterval()
		{
			return Plugin.GetZombieTargetSearchIntervalRuntime();
		}

		private static float GetSamePlayerBiteCooldown()
		{
			return Plugin.GetZombieSamePlayerBiteCooldownRuntime();
		}

		private static float GetPostBiteRecoveryTime()
		{
			return Plugin.GetZombieBiteRecoveryTimeRuntime();
		}

		private static int GetZombieViewId(MushroomZombie zombie)
		{
			if ((Object)(object)zombie == (Object)null || (Object)(object)((MonoBehaviourPun)zombie).photonView == (Object)null)
			{
				return -1;
			}
			return ((MonoBehaviourPun)zombie).photonView.ViewID;
		}

		private static void ResetLungeRecoveryTimer(MushroomZombie zombie)
		{
			if ((Object)(object)zombie != (Object)null && LungeRecoveryTimerField != null)
			{
				LungeRecoveryTimerField.SetValue(zombie, 0f);
			}
		}

		private static void ClearPostBiteRecoveryOverride(MushroomZombie zombie)
		{
			int zombieViewId = GetZombieViewId(zombie);
			if (zombieViewId >= 0)
			{
				PostBiteRecoveryUntilByZombieViewId.Remove(zombieViewId);
			}
			ResetLungeRecoveryTimer(zombie);
		}

		private static void SetPostBiteRecoveryOverride(MushroomZombie zombie, float duration)
		{
			int zombieViewId = GetZombieViewId(zombie);
			if (zombieViewId >= 0)
			{
				ResetLungeRecoveryTimer(zombie);
				if (duration <= 0f)
				{
					PostBiteRecoveryUntilByZombieViewId.Remove(zombieViewId);
				}
				else
				{
					PostBiteRecoveryUntilByZombieViewId[zombieViewId] = Time.time + duration;
				}
			}
		}

		private static bool TryGetPostBiteRecoveryOverride(MushroomZombie zombie, out float recoverAtTime)
		{
			recoverAtTime = 0f;
			int zombieViewId = GetZombieViewId(zombie);
			if (zombieViewId >= 0)
			{
				return PostBiteRecoveryUntilByZombieViewId.TryGetValue(zombieViewId, out recoverAtTime);
			}
			return false;
		}

		private static float GetCloseRangeLungeDistance(MushroomZombie zombie)
		{
			if ((Object)(object)zombie == (Object)null)
			{
				return 2.75f;
			}
			return Mathf.Clamp(zombie.zombieLungeDistance * 0.35f, 2.75f, 4.25f);
		}

		private static float GetTimeSpentChasing(MushroomZombie zombie)
		{
			if ((Object)(object)zombie == (Object)null || TimeSpentChasingField == null)
			{
				return 0f;
			}
			object value = TimeSpentChasingField.GetValue(zombie);
			if (value is float)
			{
				return (float)value;
			}
			return 0f;
		}

		private static bool CanSeeTarget(MushroomZombie zombie, Character target)
		{
			if ((Object)(object)zombie == (Object)null || (Object)(object)target == (Object)null || CanSeeTargetMethod == null)
			{
				return false;
			}
			object obj = CanSeeTargetMethod.Invoke(zombie, new object[1] { target });
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		internal static void ResetRuntimeState()
		{
			PostBiteRecoveryUntilByZombieViewId.Clear();
		}

		[HarmonyPatch(typeof(MushroomZombie), "Start")]
		[HarmonyPostfix]
		private static void MushroomZombieStartPostfix(MushroomZombie __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				ZombieSpawner.InitializeSpawnedZombieRuntime(((Component)__instance).gameObject);
			}
		}

		[HarmonyPatch(typeof(MushroomZombie), "TryLookForTarget")]
		[HarmonyPrefix]
		private static bool TryLookForTargetPrefix(MushroomZombie __instance)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)((MonoBehaviourPun)__instance).photonView == (Object)null || !((MonoBehaviourPun)__instance).photonView.IsMine)
			{
				return true;
			}
			float targetSearchInterval = GetTargetSearchInterval();
			if (__instance.sinceLookForTarget < targetSearchInterval)
			{
				return false;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				__instance.sinceLookForTarget = 0f;
				return false;
			}
			Character val = null;
			float num = float.MaxValue;
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (!((Object)(object)allCharacter == (Object)null) && !((Object)(object)allCharacter == (Object)(object)component) && !allCharacter.isBot && !allCharacter.isZombie && !((Object)(object)allCharacter.data == (Object)null) && !allCharacter.data.dead && !allCharacter.data.fullyPassedOut)
				{
					float num2 = Vector3.Distance(allCharacter.Center, component.Center);
					if ((Object)(object)val == (Object)null || num2 < num)
					{
						val = allCharacter;
						num = num2;
					}
				}
			}
			int num3 = (((Object)(object)val == (Object)null) ? (-1) : ((MonoBehaviourPun)val).photonView.ViewID);
			((MonoBehaviourPun)__instance).photonView.RPC("RPCA_SetCurrentTarget", (RpcTarget)0, new object[2] { num3, 0f });
			__instance.sinceLookForTarget = 0f;
			return false;
		}

		[HarmonyPatch(typeof(MushroomZombie), "TryLunge")]
		[HarmonyPrefix]
		private static bool TryLungePrefix(MushroomZombie __instance)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_008c: 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)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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)
			if (UseVanillaBehavior())
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null || StartLungingMethod == null)
			{
				return true;
			}
			Character currentTarget = __instance.currentTarget;
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component == (Object)null || (Object)(object)currentTarget == (Object)null)
			{
				return false;
			}
			if ((int)__instance.currentState != 3 || !component.data.isGrounded || !component.input.sprintIsPressed || !CanSeeTarget(__instance, currentTarget))
			{
				return false;
			}
			if (GetTimeSpentChasing(__instance) < Mathf.Max(__instance.chaseTimeBeforeSprint, 0.65f))
			{
				return false;
			}
			Vector3 center = component.Center;
			Vector3 center2 = currentTarget.Center;
			center.y = 0f;
			center2.y = 0f;
			float num = Vector3.Distance(center, center2);
			float num2 = Mathf.Abs(currentTarget.Center.y - component.Center.y);
			if (num > GetCloseRangeLungeDistance(__instance) || num2 > 2.25f)
			{
				return false;
			}
			StartLungingMethod.Invoke(__instance, null);
			return false;
		}

		[HarmonyPatch(typeof(MushroomZombie), "OnBitCharacter")]
		[HarmonyPostfix]
		private static void OnBitCharacterPostfix(MushroomZombie __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)((MonoBehaviourPun)__instance).photonView == (Object)null))
			{
				Character component = ((Component)__instance).GetComponent<Character>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)((MonoBehaviourPun)component).photonView == (Object)null))
				{
					float postBiteRecoveryTime = GetPostBiteRecoveryTime();
					SetPostBiteRecoveryOverride(__instance, postBiteRecoveryTime);
					float num = Mathf.Min(0.45f, postBiteRecoveryTime);
					component.data.fallSeconds = num;
					((MonoBehaviourPun)component).photonView.RPC("RPCA_Fall", (RpcTarget)0, new object[1] { num });
					((MonoBehaviourPun)__instance).photonView.RPC("RPC_SyncState", (RpcTarget)0, new object[4]
					{
						5,
						false,
						num,
						component.data.passedOut
					});
				}
			}
		}

		[HarmonyPatch(typeof(MushroomZombie), "RPC_SyncState")]
		[HarmonyPostfix]
		private static void RpcSyncStatePostfix(MushroomZombie __instance, int state, bool isSprinting, float fallSeconds, bool passedOut)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			if (state == 5)
			{
				if (fallSeconds <= 0.45999998f)
				{
					SetPostBiteRecoveryOverride(__instance, GetPostBiteRecoveryTime());
				}
				else
				{
					ClearPostBiteRecoveryOverride(__instance);
				}
			}
			else
			{
				ClearPostBiteRecoveryOverride(__instance);
			}
		}

		[HarmonyPatch(typeof(MushroomZombie), "DoLungeRecovery")]
		[HarmonyPrefix]
		private static bool DoLungeRecoveryPrefix(MushroomZombie __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			if (!TryGetPostBiteRecoveryOverride(__instance, out var recoverAtTime))
			{
				return true;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				ClearPostBiteRecoveryOverride(__instance);
				return true;
			}
			if (component.data.fallSeconds > 0f || component.data.passedOut || component.data.fullyPassedOut)
			{
				return false;
			}
			if (Time.time < recoverAtTime)
			{
				return false;
			}
			ClearPostBiteRecoveryOverride(__instance);
			if (StartChasingMethod == null)
			{
				return true;
			}
			StartChasingMethod.Invoke(__instance, null);
			return false;
		}

		[HarmonyPatch(typeof(MushroomZombieBiteCollider), "OnTriggerEnter")]
		[HarmonyPrefix]
		private static bool BiteColliderPrefix(MushroomZombieBiteCollider __instance, Collider other)
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			if (UseVanillaBehavior())
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.parentZombie == (Object)null)
			{
				return false;
			}
			float samePlayerBiteCooldown = GetSamePlayerBiteCooldown();
			Character val = default(Character);
			if (Time.time - __instance.lastBitLocalCharacter < samePlayerBiteCooldown || !CharacterRagdoll.TryGetCharacterFromCollider(other, ref val) || !val.IsLocal)
			{
				return false;
			}
			__instance.lastBitLocalCharacter = Time.time;
			if (val.data.isSkeleton)
			{
				val.refs.afflictions.AddStatus((STATUSTYPE)0, __instance.parentZombie.biteInitialInjury / 8f * 2f, false, true, true);
			}
			else
			{
				val.refs.afflictions.AddStatus((STATUSTYPE)0, __instance.parentZombie.biteInitialInjury, false, true, true);
			}
			val.refs.afflictions.AddStatus((STATUSTYPE)10, __instance.parentZombie.biteInitialSpores, false, true, true);
			Affliction_ZombieBite val2 = new Affliction_ZombieBite(__instance.parentZombie.totalBiteSporesTime, __instance.parentZombie.biteDelayBeforeSpores, __instance.parentZombie.biteSporesPerSecond);
			val.refs.afflictions.AddAffliction((Affliction)(object)val2, false);
			CharacterFallMethod?.Invoke(val, new object[2]
			{
				__instance.parentZombie.biteStunTime,
				0f
			});
			__instance.parentZombie.OnBitCharacter(val);
			return false;
		}
	}
	[HarmonyPatch(typeof(UI_UseItemProgress), "UpdateFillAmount")]
	public static class HideUseItemProgressPatch
	{
		private static bool Prefix(UI_UseItemProgress __instance, ref bool __result)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return true;
				}
				Character localCharacter = Character.localCharacter;
				object obj;
				if ((Object)(object)localCharacter == (Object)null)
				{
					obj = null;
				}
				else
				{
					CharacterData data = localCharacter.data;
					obj = (((Object)(object)data != (Object)null) ? data.currentItem : null);
				}
				if (BlowgunInfiniteUsePatch.IsBlowgunItem((Item)obj))
				{
					if ((Object)(object)__instance.fill != (Object)null)
					{
						__instance.fill.fillAmount = 0f;
					}
					__result = false;
					return false;
				}
			}
			catch
			{
			}
			return true;
		}

		internal static void RestoreVanillaUseProgressOnAllUi()
		{
			try
			{
				UI_UseItemProgress[] array = Object.FindObjectsByType<UI_UseItemProgress>((FindObjectsSortMode)0);
				for (int i = 0; i < array.Length; i++)
				{
					RestoreVanillaUseProgressUi(array[i]);
				}
			}
			catch
			{
			}
		}

		private static void RestoreVanillaUseProgressUi(UI_UseItemProgress ui)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)ui == (Object)null)
			{
				return;
			}
			try
			{
				Character localCharacter = Character.localCharacter;
				object obj;
				if (localCharacter == null)
				{
					obj = null;
				}
				else
				{
					CharacterData data = localCharacter.data;
					obj = ((data != null) ? data.currentItem : null);
				}
				Item val = (Item)obj;
				float num = (((Object)(object)val != (Object)null) ? val.progress : 0f);
				bool flag = num > 0f;
				if ((Object)(object)ui.fill != (Object)null)
				{
					ui.fill.fillAmount = (flag ? num : 0f);
					((Behaviour)ui.fill).enabled = true;
				}
				if ((Object)(object)ui.empty != (Object)null)
				{
					((Behaviour)ui.empty).enabled = true;
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(InventoryItemUI), "UpdateCookedAmount")]
	public static class InventoryItemUiCookColorPatch
	{
		[HarmonyPostfix]
		public static void UpdateCookedAmountPostfix(InventoryItemUI __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					AkUiPatchHelpers.ApplyAkToInventoryUi(__instance);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(InventoryItemUI), "UpdateNameText")]
	public static class InventoryItemUiNamePatch
	{
		[HarmonyPostfix]
		public static void UpdateNameTextPostfix(InventoryItemUI __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					AkUiPatchHelpers.ApplyAkToInventoryUi(__instance);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] InventoryItemUiNamePatch failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(InventoryItemUI), "SetItem")]
	public static class InventoryItemUiPatch
	{
		private readonly struct SetItemState : IEquatable<SetItemState>
		{
			private readonly int _prefabInstanceId;

			private readonly int _prefabItemId;

			private readonly int _resolvedItemInstanceId;

			private readonly int _itemDataIdentity;

			private readonly string _displayName;

			private readonly bool _isBlowgunLike;

			public SetItemState(ItemSlot slot, Item resolvedItem, bool isBlowgunLike)
			{
				Item val = slot?.prefab;
				_prefabInstanceId = (((Object)(object)val != (Object)null) ? ((Object)val).GetInstanceID() : 0);
				_prefabItemId = (((Object)(object)val != (Object)null) ? val.itemID : 0);
				_resolvedItemInstanceId = (((Object)(object)resolvedItem != (Object)null) ? ((Object)resolvedItem).GetInstanceID() : 0);
				_itemDataIdentity = ((slot?.data != null) ? RuntimeHelpers.GetHashCode(slot.data) : 0);
				_displayName = ItemPatch.DisplayName ?? string.Empty;
				_isBlowgunLike = isBlowgunLike;
			}

			public bool Equals(SetItemState other)
			{
				if (_prefabInstanceId == other._prefabInstanceId && _prefabItemId == other._prefabItemId && _resolvedItemInstanceId == other._resolvedItemInstanceId && _itemDataIdentity == other._itemDataIdentity && string.Equals(_displayName, other._displayName, StringComparison.Ordinal))
				{
					return _isBlowgunLike == other._isBlowgunLike;
				}
				return false;
			}
		}

		private static readonly Dictionary<int, SetItemState> LastStateByUiId = new Dictionary<int, SetItemState>();

		[HarmonyPostfix]
		public static void SetItemPostfix(InventoryItemUI __instance, ItemSlot slot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)__instance == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)__instance).GetInstanceID();
			if (!Plugin.IsWeaponFeatureEnabled())
			{
				LastStateByUiId.Remove(instanceID);
				AkUiPatchHelpers.ClearInventoryUiCache(__instance);
				return;
			}
			if (slot == null || slot.IsEmpty())
			{
				LastStateByUiId.Remove(instanceID);
				AkUiPatchHelpers.ClearInventoryUiCache(__instance);
				return;
			}
			try
			{
				Item val = AkUiPatchHelpers.ResolveItemFromSlot(slot);
				Item val2 = (((Object)(object)val != (Object)null) ? val : slot.prefab);
				bool flag = ItemPatch.IsBlowgunLike(val2);
				SetItemState setItemState = new SetItemState(slot, val2, flag);
				if (LastStateByUiId.TryGetValue(instanceID, out var value) && value.Equals(setItemState) && (!flag || AkUiPatchHelpers.IsInventoryUiAlreadyShowingAk(__instance)))
				{
					return;
				}
				LastStateByUiId[instanceID] = setItemState;
				if (flag)
				{
					ItemPatch.ApplyAkDisplayIfNeeded(val2);
					if ((Object)(object)slot.prefab != (Object)null)
					{
						ItemPatch.ApplyAkDisplayIfNeeded(slot.prefab);
					}
					AkUiPatchHelpers.ApplyAkToInventoryUi(__instance, val2);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[ShootZombies] InventoryItemUiPatch failed: " + ex));
			}
		}

		internal static void ClearCaches()
		{
			LastStateByUiId.Clear();
		}
	}
	[HarmonyPatch]
	public static class ItemPatch
	{
		private struct SourceVisualCandidate
		{
			public Mesh Mesh;

			public Material[] Materials;

			public Transform Transform;

			public int VertexCount;

			public int Score;

			public string Path;

			public string MeshName;
		}

		[CompilerGenerated]
		private sealed class <EnumerateOriginalItemColliders>d__167 : IEnumerable<Collider>, IEnumerable, IEnumerator<Collider>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Collider <>2__current;

			private int <>l__initialThreadId;

			private Item item;

			public Item <>3__item;

			private Collider[] <>7__wrap1;

			private int <>7__wrap2;

			Collider IEnumerator<Collider>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnumerateOriginalItemColliders>d__167(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_007a;
				}
				<>1__state = -1;
				if ((Object)(object)item == (Object)null)
				{
					return false;
				}
				Collider[] componentsInChildren = ((Component)item).GetComponentsInChildren<Collider>(true);
				<>7__wrap1 = componentsInChildren;
				<>7__wrap2 = 0;
				goto IL_0088;
				IL_007a:
				<>7__wrap2++;
				goto IL_0088;
				IL_0088:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					Collider val = <>7__wrap1[<>7__wrap2];
					if (!((Object)(object)val == (Object)null) && !IsCustomWeaponCollider(val))
					{
						<>2__current = val;
						<>1__state = 1;
						return true;
					}
					goto IL_007a;
				}
				<>7__wrap1 = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Collider> IEnumerable<Collider>.GetEnumerator()
			{
				<EnumerateOriginalItemColliders>d__167 <EnumerateOriginalItemColliders>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateOriginalItemColliders>d__ = this;
				}
				else
				{
					<EnumerateOriginalItemColliders>d__ = new <EnumerateOriginalItemColliders>d__167(0);
				}
				<EnumerateOriginalItemColliders>d__.item = <>3__item;
				return <EnumerateOriginalItemColliders>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Collider>)this).GetEnumerator();
			}
		}

		private const string LocalVisualName = "AK_VisualRoot";

		private const string VisualCloneName = "AK_LocalVisualClone";

		private const string SimpleVisualName = "AK47Model";

		private const string MuzzleMarkerName = "AK_MuzzleMarker";

		private const string WorldColliderName = "AK_WorldCollider";

		private const string HeldLegacyVisualName = "AK47_HeldLegacyModel";

		private const string InPlaceVisualRootName = "AK_InPlaceVisualRoot";

		private const string HeldDebugSphereName = "AK_HeldDebugSphere";

		private static readonly Quaternion HeldLegacyRotationOffset = Quaternion.identity;

		private static readonly Vector3 HeldLegacyPositionOffset = new Vector3(-0.01f, 0.01f, 0f);

		private static readonly Quaternion InPlaceYawOffset = Quaternion.Euler(0f, 0f, 0f);

		private static readonly string[] SelectableWeaponKeywords = new string[4] { "ak47", "mpx", "hk416", "hk417" };

		private const float RuntimeVisualBaseScaleMultiplier = 1.275f;

		private static readonly string[] ItemKeywords = new string[5] { "healingdart", "blowgun", "dart", "吹箭筒", "ak47" };

		private static readonly string[] ExcludedVisualKeywords = new string[9] { "hand", "arm", "finger", "collider", "trigger", "vfx", "effect", "spawn", "holiday" };

		private static readonly Dictionary<int, Renderer[]> HiddenRendererCache = new Dictionary<int, Renderer[]>();

		private static readonly HashSet<int> InPlaceSwappedItemIds = new HashSet<int>();

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

		private static readonly Dictionary<int, Character> PendingSetStateHolderByItemId = new Dictionary<int, Character>();

		private const bool UseDebugAnchorSphereVisual = false;

		private static Mesh _debugCubeMesh;

		private static Material[] _debugCubeMaterials;

		private static Mesh _debugSphereMesh;

		private static Material[] _debugSphereMaterials;

		private static Material[] _meshOnlyTestMaterials;

		private static Material[] _cachedDirectAkSharedMaterials;

		private static int _cachedDirectAkSharedMaterialsHash;

		private static string _cachedCombinedWeaponSelection = string.Empty;

		private const bool PreferInPlaceMeshSwap = true;

		private const bool PreferLegacyHeldVisualForLocalPlayer = false;

		private const bool EnableHeldDebugSphereVisual = false;

		private static readonly string[] MainRendererFieldNames = new string[6] { "<mainRenderer>k__BackingField", "mainRenderer", "_mainRenderer", "<MainRenderer>k__BackingField", "MainRenderer", "_MainRenderer" };

		private static readonly string[] MainRendererPropertyNames = new string[2] { "mainRenderer", "MainRenderer" };

		private static readonly string[] AddtlRendererFieldNames = new string[6] { "<addtlRenderers>k__BackingField", "addtlRenderers", "_addtlRenderers", "<AddtlRenderers>k__BackingField", "AddtlRenderers", "_AddtlRenderers" };

		internal static string DisplayName => Plugin.GetCurrentWeaponDisplayName();

		private static Quaternion GetDirectAkRotationOverride()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.GetDirectAkRotationOverride();
		}

		private static float GetDirectAkScaleMultiplier(string selection = null)
		{
			return Plugin.GetEffectiveWeaponModelScale(string.IsNullOrWhiteSpace(selection) ? Plugin.GetCurrentWeaponSelection() : selection);
		}

		private static Vector3 GetDirectAkPositionOverride(string selection = null)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.GetDirectAkPositionOverride(string.IsNullOrWhiteSpace(selection) ? Plugin.GetCurrentWeaponSelection() : selection);
		}

		private static string DescribeItemForDiagnostics(Item item)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected I4, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return "item=null";
			}
			string text = ((((Object)((Component)item).gameObject).name ?? string.Empty) + "/" + (((Object)((Component)item).transform).name ?? string.Empty)).Trim(new char[1] { '/' });
			string text2 = (((Object)(object)item.holderCharacter != (Object)null) ? ((Object)item.holderCharacter).name : null) ?? "null";
			string text3 = item.UIData?.itemName ?? "null";
			return $"name={text}, itemID={item.itemID}, state={(int)item.itemState}, holder={text2}, uiName={text3}";
		}

		private static string DescribeRendererCandidatesForDiagnostics(Item item, int maxEntries = 6)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return "no-item";
			}
			List<string> list = new List<string>();
			Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Mesh rendererMesh = GetRendererMesh(val);
					string item2 = string.Format("{0}|renderer={1}|mesh={2}|verts={3}", GetTransformPath(((Component)val).transform), ((Object)val).name, ((Object)rendererMesh != (Object)null) ? ((Object)rendererMesh).name : "null", ((Object)rendererMesh != (Object)null) ? rendererMesh.vertexCount : 0);
					list.Add(item2);
					if (list.Count >= maxEntries)
					{
						break;
					}
				}
			}
			if (list.Count == 0)
			{
				return "no-renderers";
			}
			return string.Join(" || ", list);
		}

		[HarmonyPatch(typeof(Item), "OnDestroy")]
		[HarmonyPrefix]
		public static void ItemOnDestroyPrefix(Item __instance)
		{
			CleanupItem(__instance);
		}

		[HarmonyPatch(typeof(Item), "OnEnable")]
		[HarmonyPostfix]
		public static void ItemOnEnablePostfix(Item __instance)
		{
			TryRefreshItem(__instance, forceRefresh: false);
		}

		[HarmonyPatch(typeof(Item), "Start")]
		[HarmonyPostfix]
		public static void ItemStartPostfix(Item __instance)
		{
			TryRefreshItem(__instance, forceRefresh: false);
		}

		[HarmonyPatch(typeof(Item), "SetState")]
		[HarmonyPrefix]
		public static void ItemSetStatePrefix(Item __instance)
		{
			CachePendingSetStateContext(__instance);
		}

		[HarmonyPatch(typeof(Item), "SetState")]
		[HarmonyPostfix]
		public static void ItemSetStatePostfix(Item __instance)
		{
			NotifyDroppedWeaponIfNeeded(__instance);
			TryRefreshItem(__instance, forceRefresh: false);
			try
			{
				ItemUIDataPatch.ForceRefreshVisibleUi();
			}
			catch
			{
			}
		}

		private static void CachePendingSetStateContext(Item item)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected I4, but got Unknown
			if (!((Object)(object)item == (Object)null))
			{
				int instanceID = ((Object)item).GetInstanceID();
				PendingSetStateValueByItemId[instanceID] = (int)item.itemState;
				Character itemHolderCharacter = GetItemHolderCharacter(item);
				if ((Object)(object)itemHolderCharacter == (Object)null)
				{
					PendingSetStateHolderByItemId.Remove(instanceID);
				}
				else
				{
					PendingSetStateHolderByItemId[instanceID] = itemHolderCharacter;
				}
			}
		}

		private static void NotifyDroppedWeaponIfNeeded(Item item)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null || !IsBlowgunLike(item))
			{
				return;
			}
			int instanceID = ((Object)item).GetInstanceID();
			Character value = null;
			PendingSetStateValueByItemId.TryGetValue(instanceID, out var value2);
			PendingSetStateHolderByItemId.TryGetValue(instanceID, out value);
			PendingSetStateValueByItemId.Remove(instanceID);
			PendingSetStateHolderByItemId.Remove(instanceID);
			if (value2 == 1 && !((Object)(object)value == (Object)null) && !value.isBot && !value.isZombie)
			{
				Character itemHolderCharacter = GetItemHolderCharacter(item);
				if ((int)item.itemState != 1 && ((Object)(object)itemHolderCharacter == (Object)null || !((Object)(object)itemHolderCharacter == (Object)(object)value) || IsDroppedWorldItem(item)))
				{
					Plugin.NotifyWeaponDropped(value);
				}
			}
		}

		private static Character GetItemHolderCharacter(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			if (!((Object)(object)item.trueHolderCharacter != (Object)null))
			{
				return item.holderCharacter;
			}
			return item.trueHolderCharacter;
		}

		[HarmonyPatch(typeof(Item), "GetName")]
		[HarmonyPostfix]
		public static void GetNamePostfix(Item __instance, ref string __result)
		{
			if (Plugin.IsWeaponFeatureEnabled() && IsBlowgunLike(__instance, __result))
			{
				__result = Plugin.GetItemWeaponDisplayName(__instance);
			}
		}

		[HarmonyPatch(typeof(Item), "GetItemName")]
		[HarmonyPostfix]
		public static void GetItemNamePostfix(Item __instance, ref string __result)
		{
			if (Plugin.IsWeaponFeatureEnabled() && IsBlowgunLike(__instance, __result))
			{
				__result = Plugin.GetItemWeaponDisplayName(__instance);
			}
		}

		public static int EnsureAkVisualOnAllItems(bool forceRefresh = false)
		{
			int num = 0;
			Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				if (EnsureAkVisual(array[i], forceRefresh))
				{
					num++;
				}
			}
			return num;
		}

		public static bool EnsureAkMeshSwap(Item item, bool forceRefreshMarker = false)
		{
			return EnsureAkVisual(item, forceRefreshMarker);
		}

		public static bool EnsureAkVisual(Item item, bool forceRefreshMarker = false)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			if (!ShouldProcessRuntimeItem(item))
			{
				return false;
			}
			if (!Plugin.IsWeaponFeatureEnabled())
			{
				return false;
			}
			if (!IsBlowgunLike(item))
			{
				RestoreOriginalVisual(item);
				CleanupSimpleAkVisual(item);
				DestroyLegacyHeldVisual(item, restoreRenderers: true);
				return false;
			}
			BlowgunInfiniteUsePatch.EnsureInfiniteUse(item);
			ApplyAkDisplay(item);
			Transform val = ResolveTargetVisualRoot(item);
			bool flag = HasReplacementVisualSource(item);
			if ((Object)(object)val == (Object)null || !flag)
			{
				Plugin.LogDiagnosticOnce("ak-ensure-abort:" + ((Object)item).GetInstanceID(), $"EnsureAkVisual aborted: {DescribeItemForDiagnostics(item)}, targetRoot={GetTransformPath(val)}, hasReplacementSource={flag}, prefab={Plugin.DescribeAkVisualPrefabForDiagnostics(Plugin.GetWeaponSelectionForItem(item))}");
				RestoreOriginalVisual(item);
				CleanupSimpleAkVisual(item);
				DestroyLegacyHeldVisual(item, restoreRenderers: true);
				return false;
			}
			if (forceRefreshMarker)
			{
				RestoreOriginalVisual(item);
				CleanupSimpleAkVisual(item);
			}
			DestroyLegacyHeldVisual(item, restoreRenderers: false);
			RestoreInPlaceVisual(item);
			InPlaceSwappedItemIds.Remove(((Object)item).GetInstanceID());
			if (ShouldUseSeparateLocalFirstPersonVisual(item))
			{
				AkLocalVisualMarker componentInChildren = ((Component)item).GetComponentInChildren<AkLocalVisualMarker>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Object.Destroy((Object)((Component)componentInChildren).gameObject);
				}
				CleanupSimpleAkVisual(item);
				HideOriginalRenderers(item, val);
				SyncWeaponColliderState(item, null);
				return true;
			}
			Transform orCreateSimpleAkVisual = GetOrCreateSimpleAkVisual(item, val, forceRefreshMarker);
			if ((Object)(object)orCreateSimpleAkVisual == (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-ensure-create-fail:" + ((Object)item).GetInstanceID(), "GetOrCreateSimpleAkVisual failed: " + DescribeItemForDiagnostics(item) + ", targetRoot=" + GetTransformPath(val) + ", prefab=" + Plugin.DescribeAkVisualPrefabForDiagnostics(Plugin.GetWeaponSelectionForItem(item)));
				RestoreOriginalVisual(item);
				return false;
			}
			if (ShouldShowSimpleAkVisual(item))
			{
				HideOriginalRenderers(item, val);
				SetCustomVisualRenderersVisible(orCreateSimpleAkVisual, visible: true);
				SyncWeaponColliderState(item, null);
			}
			else
			{
				SetCustomVisualRenderersVisible(orCreateSimpleAkVisual, visible: false);
				RestoreOriginalVisual(item);
			}
			InPlaceSwappedItemIds.Remove(((Object)item).GetInstanceID());
			return true;
		}

		public static void ApplyAkDisplay(Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				Plugin.TryProtectWeaponItemRuntime(item);
				ApplyUiData(item, item.UIData);
				if ((Object)(object)item.isSecretlyOtherItemPrefab != (Object)null)
				{
					ApplyUiData(item, item.isSecretlyOtherItemPrefab.UIData);
				}
			}
		}

		internal static void ApplyAkDisplayIfNeeded(Item item)
		{
			if (Plugin.IsWeaponFeatureEnabled() && !((Object)(object)item == (Object)null) && IsBlowgunLike(item))
			{
				ApplyAkDisplay(item);
			}
		}

		public static bool IsBlowgunLike(Item item, string knownDisplayName = null)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)item).GetComponentInChildren<AkLocalVisualMarker>(true) != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)item).GetComponentInChildren<AkInPlaceMarker>(true) != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)item).GetComponentInChildren<AkHeldLegacyVisualMarker>(true) != (Object)null)
			{
				return true;
			}
			if (BlowgunInfiniteUsePatch.IsBlowgunItem(item))
			{
				return true;
			}
			if (!ContainsKeyword(knownDisplayName) && !ContainsKeyword(((Object)((Component)item).gameObject).name) && !ContainsKeyword(item.UIData?.itemName))
			{
				return ContainsKeyword(item.isSecretlyOtherItemPrefab?.UIData?.itemName);
			}
			return true;
		}

		internal static bool ContainsWeaponKeyword(string value)
		{
			return ContainsKeyword(value);
		}

		public static Transform TryGetMuzzleMarker(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			AkMuzzleMarker componentInChildren = ((Component)item).GetComponentInChildren<AkMuzzleMarker>(true);
			if (!((Object)(object)componentInChildren != (Object)null))
			{
				return null;
			}
			return ((Component)componentInChildren).transform;
		}

		internal static Transform ResolveTargetVisualRootForItem(Item item)
		{
			return ResolveTargetVisualRoot(item);
		}

		internal static bool IsLocallyHeldByPlayer(Item item, Character character = null)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if ((int)item.itemState != 1)
			{
				return false;
			}
			character = (((Object)(object)character != (Object)null) ? character : Character.localCharacter);
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)item.holderCharacter == (Object)(object)character))
			{
				return (Object)(object)item.trueHolderCharacter == (Object)(object)character;
			}
			return true;
		}

		private static bool ShouldUseSeparateLocalFirstPersonVisual(Item item)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Invalid comparison between Unknown and I4
			if (!Plugin.IsLocalWeaponVisualFollowerEnabled())
			{
				return false;
			}
			if (IsLocallyHeldByPlayer(item))
			{
				return true;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || !IsBlowgunLike(item))
			{
				return false;
			}
			if ((Object)(object)item.holderCharacter == (Object)(object)localCharacter || (Object)(object)item.trueHolderCharacter == (Object)(object)localCharacter)
			{
				return (int)item.itemState == 1;
			}
			CharacterData data = localCharacter.data;
			if ((Object)(object)((data != null) ? data.currentItem : null) == (Object)(object)item && (int)item.itemState == 1)
			{
				return true;
			}
			return false;
		}

		internal static bool HasLegacyHeldVisual(Item item)
		{
			if ((Object)(object)item != (Object)null)
			{
				return (Object)(object)((Component)item).GetComponentInChildren<AkHeldLegacyVisualMarker>(true) != (Object)null;
			}
			return false;
		}

		private static bool ShouldProcessRuntimeItem(Item item)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			GameObject gameObject = ((Component)item).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return false;
			}
			if ((((Object)gameObject).hideFlags & 0x34) != 0)
			{
				return false;
			}
			Scene scene = gameObject.scene;
			if (((Scene)(ref scene)).IsValid())
			{
				return ((Scene)(ref scene)).isLoaded;
			}
			return false;
		}

		private static bool ShouldShowSimpleAkVisual(Item item)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if (ShouldUseSeparateLocalFirstPersonVisual(item))
			{
				return false;
			}
			if ((int)item.itemState == 1)
			{
				return true;
			}
			return (Object)(object)(((Object)(object)item.trueHolderCharacter != (Object)null) ? item.trueHolderCharacter : item.holderCharacter) == (Object)null;
		}

		private static bool ShouldUseInPlaceWeaponVisual(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			return !IsDroppedWorldItem(item);
		}

		private static bool IsDroppedWorldItem(Item item)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if (ShouldUseSeparateLocalFirstPersonVisual(item) || (int)item.itemState == 1)
			{
				return false;
			}
			return (Object)(object)(((Object)(object)item.trueHolderCharacter != (Object)null) ? item.trueHolderCharacter : item.holderCharacter) == (Object)null;
		}

		private static void SetCustomVisualRenderersVisible(Transform root, bool visible)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.enabled = visible;
					val.forceRenderingOff = !visible;
					val.allowOcclusionWhenDynamic = false;
				}
			}
		}

		internal static void NormalizeVisualScaleAgainstReference(Transform visualRoot, Transform referenceRoot, string context)
		{
			//IL_0015: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)visualRoot == (Object)null || !TryGetCombinedRenderableBounds(visualRoot, out var bounds))
			{
				return;
			}
			float boundsLongestSize = GetBoundsLongestSize(bounds);
			if (!IsFiniteFloat(boundsLongestSize) || boundsLongestSize < 0.0005f)
			{
				return;
			}
			Bounds bounds2;
			bool num = TryGetReferenceRenderableBounds(referenceRoot, visualRoot, out bounds2);
			float num2 = (num ? GetBoundsLongestSize(bounds2) : 0f);
			float num3 = 0f;
			string text = "none";
			if (num && IsFiniteFloat(num2) && num2 > 0.02f && boundsLongestSize < num2 * 0.22f)
			{
				num3 = num2 * 0.92f;
				text = "reference";
			}
			else if (boundsLongestSize < 0.04f)
			{
				num3 = 0.42f;
				text = "fallback";
			}
			if (!IsFiniteFloat(num3) || num3 <= boundsLongestSize)
			{
				return;
			}
			float num4 = Mathf.Clamp(num3 / boundsLongestSize, 1f, 256f);
			if (!IsFiniteFloat(num4) || num4 <= 1.05f)
			{
				return;
			}
			Vector3 localScale = visualRoot.localScale;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(Mathf.Abs(localScale.x * num4), Mathf.Abs(localScale.y * num4), Mathf.Abs(localScale.z * num4));
			if (IsValidNormalizedScale(val))
			{
				visualRoot.localScale = val;
				float num5 = num3;
				if (TryGetCombinedRenderableBounds(visualRoot, out var bounds3))
				{
					num5 = GetBoundsLongestSize(bounds3);
				}
				Plugin.LogDiagnosticOnce("ak-visual-scale:" + context + ":" + ((Object)visualRoot).GetInstanceID(), $"Normalized weapon visual scale: context={context}, visual={GetTransformPath(visualRoot)}, reference={GetTransformPath(referenceRoot)}, oldSize={boundsLongestSize:0.####}, referenceSize={num2:0.####}, targetSize={num3:0.####}, newSize={num5:0.####}, scaleRatio={num4:0.###}, reason={text}, newLocalScale={visualRoot.localScale}");
			}
		}

		private static bool TryGetReferenceRenderableBounds(Transform referenceRoot, Transform visualRoot, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			if ((Object)(object)referenceRoot == (Object)null)
			{
				return false;
			}
			if (TryGetOriginalWeaponRenderableBounds(referenceRoot, out bounds))
			{
				return true;
			}
			return TryGetCombinedRenderableBounds(referenceRoot, out bounds, visualRoot);
		}

		private static bool TryGetOriginalWeaponRenderableBounds(Transform targetVisualRoot, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			if ((Object)(object)targetVisualRoot == (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren = ((Component)targetVisualRoot).GetComponentsInChildren<Renderer>(true);
			bool flag = false;
			Renderer[] array = componentsInChildren;
			foreach (Renderer renderer in array)
			{
				if (IsOriginalWeaponRenderer(renderer, targetVisualRoot) && TryGetRendererWorldBounds(renderer, out var bounds2))
				{
					if (!flag)
					{
						bounds = bounds2;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(bounds2);
					}
				}
			}
			return flag;
		}

		private static bool TryGetCombinedRenderableBounds(Transform root, out Bounds bounds, Transform excludedSubtree = null)
		{
			//IL_0001: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			if ((Object)(object)root == (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			bool flag = false;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null || !IsMeshBackedRenderer(val))
				{
					continue;
				}
				Transform transform = ((Component)val).transform;
				if ((!((Object)(object)excludedSubtree != (Object)null) || (!((Object)(object)transform == (Object)(object)excludedSubtree) && !transform.IsChildOf(excludedSubtree))) && TryGetRendererWorldBounds(val, out var bounds2))
				{
					if (!flag)
					{
						bounds = bounds2;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(bounds2);
					}
				}
			}
			return flag;
		}

		private static bool TryGetRendererWorldBounds(Renderer renderer, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			Mesh rendererMesh = GetRendererMesh(renderer);
			if ((Object)rendererMesh == (Object)null)
			{
				return false;
			}
			return TryTransformBounds(rendererMesh.bounds, ((Component)renderer).transform.localToWorldMatrix, out bounds);
		}

		private static bool TryTransformBounds(Bounds sourceBounds, Matrix4x4 matrix, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00de: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: 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_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: 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_01b8: 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)
			bounds = default(Bounds);
			Vector3 center = ((Bounds)(ref sourceBounds)).center;
			Vector3 extents = ((Bounds)(ref sourceBounds)).extents;
			Vector3 val = ((Matrix4x4)(ref matrix)).MultiplyPoint3x4(center + new Vector3(0f - extents.x, 0f - extents.y, 0f - extents.z));
			if (!IsFiniteVector3(val))
			{
				return false;
			}
			bounds = new Bounds(val, Vector3.zero);
			Vector3[] array = (Vector3[])(object)new Vector3[7]
			{
				center + new Vector3(0f - extents.x, 0f - extents.y, extents.z),
				center + new Vector3(0f - extents.x, extents.y, 0f - extents.z),
				center + new Vector3(0f - extents.x, extents.y, extents.z),
				center + new Vector3(extents.x, 0f - extents.y, 0f - extents.z),
				center + new Vector3(extents.x, 0f - extents.y, extents.z),
				center + new Vector3(extents.x, extents.y, 0f - extents.z),
				center + new Vector3(extents.x, extents.y, extents.z)
			};
			for (int i = 0; i < array.Length; i++)
			{
				Vector3 val2 = ((Matrix4x4)(ref matrix)).MultiplyPoint3x4(array[i]);
				if (!IsFiniteVector3(val2))
				{
					return false;
				}
				((Bounds)(ref bounds)).Encapsulate(val2);
			}
			return true;
		}

		private static float GetBoundsLongestSize(Bounds bounds)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Vector3 size = ((Bounds)(ref bounds)).size;
			return Mathf.Max(new float[3] { size.x, size.y, size.z });
		}

		private static bool IsFiniteVector3(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (IsFiniteFloat(value.x) && IsFiniteFloat(value.y))
			{
				return IsFiniteFloat(value.z);
			}
			return false;
		}

		private static bool IsValidNormalizedScale(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0033: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFiniteVector3(value))
			{
				return false;
			}
			if (value.x < 0.0001f || value.y < 0.0001f || value.z < 0.0001f)
			{
				return false;
			}
			if (value.x > 256f || value.y > 256f || value.z > 256f)
			{
				return false;
			}
			return true;
		}

		internal static bool TryResolveBaseAkVisual(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			//IL_0007: 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)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0023: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			mesh = null;
			materials = null;
			localScale = Vector3.one;
			localRotation = Quaternion.identity;
			localPosition = Vector3.zero;
			debugInfo = "unresolved";
			if (!TryGetBestSourceVisual(out var best) || (Object)(object)best.Mesh == (Object)null)
			{
				return false;
			}
			mesh = best.Mesh;
			materials = best.Materials;
			if ((Object)(object)best.Transform != (Object)null)
			{
				TryGetTransformPoseRelativeToAkRoot(best.Transform, out var localPosition2, out var localRotation2, out var localScale2);
				localScale = SanitizeLocalScale(localScale2, Vector3.one);
				localRotation = SanitizeLocalRotation(localRotation2);
				localPosition = SanitizeLocalPosition(localPosition2, Vector3.zero);
			}
			debugInfo = $"path={best.Path}, mesh={best.MeshName}, verts={best.VertexCount}, score={best.Score}, subMeshes={Mathf.Max(best.Mesh.subMeshCount, 1)}, mats={((best.Materials != null) ? best.Materials.Length : 0)}, pos={localPosition}, rot={((Quaternion)(ref localRotation)).eulerAngles}, scale={localScale}";
			return true;
		}

		private static bool HasReplacementVisualSource(Item item)
		{
			return Plugin.HasAkVisualPrefab(Plugin.GetWeaponSelectionForItem(item));
		}

		private static bool TryResolveBundleMeshOnlyVisual(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			//IL_0007: 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)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			mesh = null;
			materials = null;
			localScale = Vector3.one;
			localRotation = Quaternion.identity;
			localPosition = Vector3.zero;
			debugInfo = "bundle-mesh-only-unresolved";
			GameObject akVisualPrefab = Plugin.GetAkVisualPrefab();
			if ((Object)(object)akVisualPrefab == (Object)null)
			{
				return false;
			}
			Transform val = akVisualPrefab.transform.Find("AK/Mesh") ?? akVisualPrefab.transform.Find("Mesh");
			if ((Object)(object)val == (Object)null && TryGetBestSourceVisual(out var best))
			{
				val = best.Transform;
				mesh = best.Mesh;
				debugInfo = "bundle-mesh-only fallback path=" + best.Path;
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if ((Object)(object)mesh == (Object)null)
			{
				MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
				mesh = (((Object)(object)component != (Object)null) ? component.sharedMesh : null);
			}
			if ((Object)(object)mesh == (Object)null)
			{
				return false;
			}
			MeshRenderer component2 = ((Component)val).GetComponent<MeshRenderer>();
			TryGetTransformPoseRelativeToAkRoot(val, out localPosition, out localRotation, out localScale);
			localScale = SanitizeLocalScale(localScale, Vector3.one);
			localRotation = SanitizeLocalRotation(localRotation);
			localPosition = SanitizeLocalPosition(localPosition, Vector3.zero);
			Material[] array = (((Object)(object)component2 != (Object)null) ? ((Renderer)component2).sharedMaterials : null);
			bool flag = array != null && array.Length != 0 && array.Any((Material material) => (Object)(object)material != (Object)null);
			materials = GetMeshOnlyTestMaterials(Mathf.Max(mesh.subMeshCount, 1));
			debugInfo = $"bundle-mesh-only path={GetTransformPath(val)}, mesh={((Object)mesh).name}, verts={mesh.vertexCount}, subMeshes={Mathf.Max(mesh.subMeshCount, 1)}, sourceMats={(flag ? array.Length : 0)}, runtimeMats=test/{materials.Length}, pos={localPosition}, rot={((Quaternion)(ref localRotation)).eulerAngles}, scale={localScale}";
			return true;
		}

		private static Material[] GetMeshOnlyTestMaterials(int subMeshCount)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			subMeshCount = Mathf.Max(subMeshCount, 1);
			if (_meshOnlyTestMaterials == null || _meshOnlyTestMaterials.Length != subMeshCount || _meshOnlyTestMaterials.Any((Material material) => (Object)(object)material == (Object)null))
			{
				Material[] array = (Material[])(object)new Material[subMeshCount];
				for (int i = 0; i < subMeshCount; i++)
				{
					Material val = CreateRuntimeMaterial(null, null);
					ApplyColor(val, new Color(0.82f, 0.82f, 0.82f, 1f));
					NormalizeMaterialForVisibility(val);
					array[i] = val;
				}
				_meshOnlyTestMaterials = array;
			}
			return _meshOnlyTestMaterials;
		}

		private static bool TryResolveDebugCubeVisual(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//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_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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			mesh = GetDebugCubeMesh();
			materials = GetDebugCubeMaterials();
			localScale = Vector3.one * 0.25f;
			localRotation = Quaternion.identity;
			localPosition = Vector3.zero;
			debugInfo = "debug-cube";
			if ((Object)(object)mesh != (Object)null && materials != null)
			{
				return materials.Length != 0;
			}
			return false;
		}

		private static Mesh GetDebugCubeMesh()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if ((Object)(object)_debugCubeMesh != (Object)null)
			{
				return _debugCubeMesh;
			}
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
			try
			{
				MeshFilter component = val.GetComponent<MeshFilter>();
				if ((Object)(object)component != (Object)null)
				{
					_debugCubeMesh = component.sharedMesh;
				}
			}
			finally
			{
				Object.Destroy((Object)val);
			}
			return _debugCubeMesh;
		}

		private static Material[] GetDebugCubeMaterials()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (_debugCubeMaterials != null && _debugCubeMaterials.Length != 0 && _debugCubeMaterials.All((Material material) => (Object)(object)material != (Object)null))
			{
				return _debugCubeMaterials;
			}
			Material val = CreateRuntimeMaterial(null, null);
			ApplyColor(val, new Color(1f, 0.25f, 0.05f, 1f));
			if (val.HasProperty("_EmissionColor"))
			{
				val.EnableKeyword("_EMISSION");
				val.SetColor("_EmissionColor", new Color(0.35f, 0.08f, 0.02f, 1f));
			}
			NormalizeMaterialForVisibility(val);
			_debugCubeMaterials = (Material[])(object)new Material[1] { val };
			return _debugCubeMaterials;
		}

		private static bool TryResolveDebugSphereVisual(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//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_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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			mesh = GetDebugSphereMesh();
			materials = GetDebugSphereMaterials();
			localScale = Vector3.one * 0.08f;
			localRotation = Quaternion.identity;
			localPosition = Vector3.zero;
			debugInfo = "debug-anchor-sphere";
			if ((Object)(object)mesh != (Object)null && materials != null)
			{
				return materials.Length != 0;
			}
			return false;
		}

		private static Mesh GetDebugSphereMesh()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if ((Object)(object)_debugSphereMesh != (Object)null)
			{
				return _debugSphereMesh;
			}
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
			try
			{
				MeshFilter component = val.GetComponent<MeshFilter>();
				if ((Object)(object)component != (Object)null)
				{
					_debugSphereMesh = component.sharedMesh;
				}
			}
			finally
			{
				Object.Destroy((Object)val);
			}
			return _debugSphereMesh;
		}

		private static Material[] GetDebugSphereMaterials()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (_debugSphereMaterials != null && _debugSphereMaterials.Length != 0 && _debugSphereMaterials.All((Material material) => (Object)(object)material != (Object)null))
			{
				return _debugSphereMaterials;
			}
			Material val = CreateRuntimeMaterial(null, null);
			ApplyColor(val, new Color(1f, 0.08f, 0.08f, 1f));
			if (val.HasProperty("_EmissionColor"))
			{
				val.EnableKeyword("_EMISSION");
				val.SetColor("_EmissionColor", new Color(0.55f, 0.02f, 0.02f, 1f));
			}
			NormalizeMaterialForVisibility(val);
			_debugSphereMaterials = (Material[])(object)new Material[1] { val };
			return _debugSphereMaterials;
		}

		private static void EnsureHeldDebugSphere(Transform visualRoot)
		{
		}

		private static void CleanupHeldDebugSphere(Transform visualRoot)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (!((Object)(object)visualRoot == (Object)null))
			{
				Transform val = visualRoot.Find("AK_HeldDebugSphere");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)((Component)val).gameObject);
				}
			}
		}

		private static Vector3 ResolveHeldDebugSphereLocalPosition(Transform visualRoot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)visualRoot == (Object)null || !TryGetCombinedRenderableBounds(visualRoot, out var bounds))
			{
				return Vector3.zero;
			}
			return SanitizeLocalPosition(visualRoot.InverseTransformPoint(((Bounds)(ref bounds)).center), Vector3.zero);
		}

		private static Vector3 ResolveHeldDebugSphereLocalScale(Transform visualRoot, float desiredWorldDiameter)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)visualRoot == (Object)null)
			{
				return Vector3.one * desiredWorldDiameter;
			}
			Vector3 lossyScale = visualRoot.lossyScale;
			return SanitizeLocalScale(new Vector3(desiredWorldDiameter / Mathf.Max(Mathf.Abs(lossyScale.x), 0.0001f), desiredWorldDiameter / Mathf.Max(Mathf.Abs(lossyScale.y), 0.0001f), desiredWorldDiameter / Mathf.Max(Mathf.Abs(lossyScale.z), 0.0001f)), Vector3.one * desiredWorldDiameter);
		}

		internal static bool TryResolvePreferredAkVisual(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 directAkPositionOverride = GetDirectAkPositionOverride();
			if (!TryResolveBaseAkVisual(out mesh, out materials, out var localScale2, out var localRotation2, out var localPosition2, out debugInfo))
			{
				localScale = Vector3.one * 1.6f;
				localRotation = HeldLegacyRotationOffset;
				localPosition = directAkPositionOverride;
				return false;
			}
			localScale = SanitizeLocalScale(Vector3.Scale(localScale2, Vector3.one * 1.6f), Vector3.one * 1.6f);
			localRotation = SanitizeLocalRotation(localRotation2 * HeldLegacyRotationOffset);
			localPosition = SanitizeLocalPosition(localPosition2 + directAkPositionOverride, directAkPositionOverride);
			debugInfo += $", heldPos={localPosition}, heldRot={((Quaternion)(ref localRotation)).eulerAngles}, heldScale={localScale}";
			return true;
		}

		private static bool TryResolveDirectAkVisual(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 directAkPositionOverride = GetDirectAkPositionOverride();
			mesh = null;
			materials = null;
			localScale = Vector3.one;
			localRotation = HeldLegacyRotationOffset;
			localPosition = directAkPositionOverride;
			debugInfo = "direct-ak-unresolved";
			GameObject akVisualPrefab = Plugin.GetAkVisualPrefab();
			if ((Object)(object)akVisualPrefab == (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-direct-prefab-null", "TryResolveDirectAkVisual aborted because AK visual prefab is null");
				return false;
			}
			Transform val = akVisualPrefab.transform.Find("AK/Mesh") ?? akVisualPrefab.transform.Find("Mesh");
			bool flag = (Object)(object)val != (Object)null && ShouldRejectDirectAkSource(val);
			MeshFilter val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<MeshFilter>() : null);
			MeshRenderer val3 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<MeshRenderer>() : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val2.sharedMesh == (Object)null || ShouldRejectDirectAkSource(val))
			{
				val2 = null;
				val3 = null;
				MeshFilter[] componentsInChildren = akVisualPrefab.GetComponentsInChildren<MeshFilter>(true);
				int num = int.MinValue;
				MeshFilter[] array = componentsInChildren;
				foreach (MeshFilter val4 in array)
				{
					if ((Object)(object)val4 == (Object)null || (Object)(object)val4.sharedMesh == (Object)null)
					{
						continue;
					}
					MeshRenderer component = ((Component)val4).GetComponent<MeshRenderer>();
					if (!((Object)(object)component == (Object)null) && !ShouldRejectDirectAkSource(((Component)val4).transform))
					{
						int num2 = val4.sharedMesh.vertexCount;
						string text = GetTransformPath(((Component)val4).transform).ToLowerInvariant();
						if (text.Contains("/ak/"))
						{
							num2 += 4000;
						}
						if (text.EndsWith("/mesh"))
						{
							num2 += 6000;
						}
						if (text.Contains("cube"))
						{
							num2 += 2500;
						}
						if (num2 > num)
						{
							num = num2;
							val2 = val4;
							val3 = component;
						}
					}
				}
			}
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val2.sharedMesh == (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-direct-fail:" + ((Object)akVisualPrefab).GetInstanceID(), $"TryResolveDirectAkVisual failed: preferredNode={GetTransformPath(val)}, preferredRejected={flag}, prefab={Plugin.DescribeAkVisualPrefabForDiagnostics()}");
				return false;
			}
			mesh = val2.sharedMesh;
			materials = NormalizeMaterialArray(((Renderer)val3).sharedMaterials, Mathf.Max(mesh.subMeshCount, 1));
			localScale = Vector3.one * GetDirectAkScaleMultiplier();
			localRotation = GetDirectAkRotationOverride();
			localPosition = directAkPositionOverride;
			object[] array2 = new object[7]
			{
				GetTransformPath(((Component)val2).transform),
				((Object)mesh).name,
				mesh.vertexCount,
				null,
				null,
				null,
				null
			};
			Material[] array3 = materials;
			array2[3] = ((array3 != null) ? array3.Length : 0);
			array2[4] = localPosition;
			array2[5] = ((Quaternion)(ref localRotation)).eulerAngles;
			array2[6] = localScale;
			debugInfo = string.Format("direct path={0}, mesh={1}, verts={2}, mats={3}, pos={4}, rot={5}, scale={6}", array2);
			Plugin.LogDiagnosticOnce("ak-direct-success:" + GetTransformPath(((Component)val2).transform), $"TryResolveDirectAkVisual selected source={GetTransformPath(((Component)val2).transform)}, mesh={((Object)mesh).name}, verts={mesh.vertexCount}, mats={((materials != null) ? materials.Length : 0)}, heldPos={localPosition}, heldRot={((Quaternion)(ref localRotation)).eulerAngles}, heldScale={localScale}");
			return true;
		}

		private static bool TryResolveSimpleVisualSource(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (TryResolveBaseAkVisual(out mesh, out materials, out var localScale2, out var localRotation2, out var localPosition2, out var debugInfo2) && (Object)(object)mesh != (Object)null)
			{
				localScale = SanitizeLocalScale(localScale2, Vector3.one);
				localRotation = SanitizeLocalRotation(localRotation2);
				localPosition = SanitizeLocalPosition(localPosition2, Vector3.zero);
				debugInfo = "simple-base->" + debugInfo2;
				return true;
			}
			if (TryResolveDirectAkVisual(out mesh, out materials, out var localScale3, out var _, out var _, out var debugInfo3) && (Object)(object)mesh != (Object)null)
			{
				localScale = SanitizeLocalScale(localScale3, Vector3.one);
				localRotation = Quaternion.identity;
				localPosition = Vector3.zero;
				debugInfo = "simple-direct-fallback->" + debugInfo3 + ", forcedPos=(0.00, 0.00, 0.00), forcedRot=(0.00, 0.00, 0.00)";
				return true;
			}
			localScale = Vector3.one;
			localRotation = Quaternion.identity;
			localPosition = Vector3.zero;
			debugInfo = "simple-unresolved";
			return false;
		}

		private static bool ShouldUseHeldSimpleVisualPose(Item item)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if ((int)item.itemState == 1)
			{
				return true;
			}
			if ((Object)(object)item.holderCharacter == (Object)null)
			{
				return (Object)(object)item.trueHolderCharacter != (Object)null;
			}
			return true;
		}

		private static bool TryResolveRuntimeSimpleVisualSource(Item item, out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			if (ShouldUseHeldSimpleVisualPose(item) && TryResolvePreferredAkVisual(out mesh, out materials, out localScale, out localRotation, out localPosition, out var debugInfo2) && (Object)(object)mesh != (Object)null)
			{
				debugInfo = "simple-held->" + debugInfo2;
				return true;
			}
			return TryResolveSimpleVisualSource(out mesh, out materials, out localScale, out localRotation, out localPosition, out debugInfo);
		}

		private static bool ShouldRejectDirectAkSource(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return true;
			}
			string text = GetTransformPath(transform).ToLowerInvariant();
			if (!text.Contains("/hand") && !text.Contains("/arm") && !text.Contains("finger") && !text.Contains("holiday") && !text.Contains("vfx") && !text.Contains("effect") && !text.Contains("spawn"))
			{
				return text.Contains("muzzle");
			}
			return true;
		}

		private static Material[] BuildDirectAkMaterials(Material[] sourceMaterials, int subMeshCount)
		{
			subMeshCount = Mathf.Max(subMeshCount, 1);
			Material[] array = NormalizeMaterialArray(sourceMaterials, subMeshCount);
			Material[] array2 = (Material[])(object)new Material[subMeshCount];
			Material val = ((IEnumerable<Material>)array).FirstOrDefault((Func<Material, bool>)((Material material) => (Object)(object)material != (Object)null));
			for (int i = 0; i < subMeshCount; i++)
			{
				Material val2 = ((i < array.Length) ? array[i] : null);
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val;
				}
				array2[i] = CreateDirectVisibleMaterial(val2);
				NormalizeMaterialForVisibility(array2[i]);
			}
			return array2;
		}

		private static Material CreateDirectVisibleMaterial(Material source)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			Shader val = ResolvePreferredVisibleShader();
			Material val2 = new Material(((Object)(object)val != (Object)null) ? val : ResolveFallbackShader());
			if ((Object)(object)source != (Object)null)
			{
				CopySourceMaterialProperties(source, val2, preserveDestinationColor: false);
				NormalizeMaterial(val2, source);
			}
			else
			{
				NormalizeMaterial(val2, null);
			}
			return val2;
		}

		internal static bool TryResolveHeldPoseRelativeToBase(out Vector3 localPosition, out Quaternion localRotation, out Vector3 localScale)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			Vector3 directAkPositionOverride = GetDirectAkPositionOverride();
			localPosition = Vector3.zero;
			localRotation = Quaternion.identity;
			localScale = Vector3.one;
			if (!TryResolveBaseAkVisual(out var mesh, out var materials, out var localScale2, out var localRotation2, out var localPosition2, out var debugInfo))
			{
				return false;
			}
			if (!TryResolvePreferredAkVisual(out mesh, out materials, out var localScale3, out var localRotation3, out var localPosition3, out debugInfo))
			{
				return false;
			}
			Matrix4x4 val = Matrix4x4.TRS(localPosition2, localRotation2, localScale2);
			DecomposeMatrix(((Matrix4x4)(ref val)).inverse * Matrix4x4.TRS(localPosition3, localRotation3, localScale3), out localPosition, out localRotation, out localScale);
			localPosition = SanitizeLocalPosition(localPosition, directAkPositionOverride);
			localRotation = SanitizeLocalRotation(localRotation);
			localScale = SanitizeLocalScale(localScale, Vector3.one * 1.6f);
			return true;
		}

		internal static Material[] BuildAkVisibleMaterials(Material[] preferredMaterials, int subMeshCount)
		{
			return BuildVisibleMaterials(preferredMaterials, null, subMeshCount);
		}

		private static int ComputeMaterialArrayHash(Material[] materials, int subMeshCount)
		{
			int num = subMeshCount;
			Material[] array = NormalizeMaterialArray(materials, subMeshCount);
			for (int i = 0; i < array.Length; i++)
			{
				num = num * 31 + (((Object)(object)array[i] != (Object)null) ? ((Object)array[i]).GetInstanceID() : 0);
			}
			return num;
		}

		private static Material[] GetSharedDirectAkMaterials(Material[] sourceMaterials, int subMeshCount)
		{
			int num = ComputeMaterialArrayHash(sourceMaterials, subMeshCount);
			if (_cachedDirectAkSharedMaterials == null || _cachedDirectAkSharedMaterials.Length != subMeshCount || _cachedDirectAkSharedMaterialsHash != num || _cachedDirectAkSharedMaterials.Any((Material material) => (Object)(object)material == (Object)null))
			{
				_cachedDirectAkSharedMaterials = BuildDirectAkMaterials(sourceMaterials, subMeshCount);
				_cachedDirectAkSharedMaterialsHash = num;
			}
			if (_cachedDirectAkSharedMaterials == null)
			{
				return Array.Empty<Material>();
			}
			return _cachedDirectAkSharedMaterials.ToArray();
		}

		internal static void NormalizeAkRenderer(Renderer renderer)
		{
			NormalizeRendererMaterials(renderer);
		}

		private static void ConfigureRuntimeWeaponRenderer(Renderer renderer)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				renderer.allowOcclusionWhenDynamic = false;
				renderer.shadowCastingMode = (ShadowCastingMode)0;
				renderer.receiveShadows = false;
				renderer.lightProbeUsage = (LightProbeUsage)0;
				renderer.reflectionProbeUsage = (ReflectionProbeUsage)0;
			}
		}

		internal static Transform CreatePreparedAkClone(Item item, Transform parent, Transform targetVisualRoot, string cloneName)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00e4: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)parent == (Object)null)
			{
				return null;
			}
			GameObject val = (((Object)(object)item != (Object)null) ? Plugin.GetAkVisualPrefab(Plugin.GetWeaponSelectionForItem(item)) : Plugin.GetAkVisualPrefab());
			if (!((Object)(object)val == (Object)null))
			{
				GameObject obj = Object.Instantiate<GameObject>(val, parent, false);
				((Object)obj).name = cloneName;
				StripNonVisualComponents(obj);
				PrepareRenderers(obj, targetVisualRoot);
				ApplyConfiguredPrefabRootPose(obj.transform);
				NormalizeVisualScaleAgainstReference(obj.transform, targetVisualRoot, cloneName);
				ApplyConfiguredWorldVisualScale(obj.transform, ((Object)(object)item != (Object)null) ? Plugin.GetWeaponSelectionForItem(item) : null);
				SetLayerRecursively(obj.transform, ((Component)parent).gameObject.layer);
				SetHierarchyActive(obj.transform, active: true);
				return obj.transform;
			}
			if (TryResolvePreferredAkVisual(out var mesh, out var materials, out var localScale, out var localRotation, out var localPosition, out var _) && (Object)(object)mesh != (Object)null)
			{
				GameObject val2 = new GameObject(cloneName);
				val2.transform.SetParent(parent, false);
				val2.transform.localPosition = localPosition;
				val2.transform.localRotation = localRotation;
				val2.transform.localScale = localScale;
				MeshFilter val3 = val2.AddComponent<MeshFilter>();
				MeshRenderer obj2 = val2.AddComponent<MeshRenderer>();
				val3.sharedMesh = mesh;
				((Renderer)obj2).sharedMaterials = GetSharedDirectAkMaterials(materials, Mathf.Max(mesh.subMeshCount, 1));
				NormalizeAkRenderer((Renderer)obj2);
				NormalizeVisualScaleAgainstReference(val2.transform, targetVisualRoot, cloneName + "-mesh");
				ApplyConfiguredWorldVisualScale(val2.transform, ((Object)(object)item != (Object)null) ? Plugin.GetWeaponSelectionForItem(item) : null);
				SetLayerRecursively(val2.transform, ((Component)parent).gameObject.layer);
				return val2.transform;
			}
			return null;
		}

		internal static Transform CreatePreparedAkClone(Transform parent, Transform targetVisualRoot, string cloneName)
		{
			return CreatePreparedAkClone(null, parent, targetVisualRoot, cloneName);
		}

		private static void ApplyConfiguredPrefabRootPose(Transform cloneRoot)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cloneRoot == (Object)null))
			{
				cloneRoot.localPosition = GetDirectAkPositionOverride();
				cloneRoot.localRotation = GetDirectAkRotationOverride();
				cloneRoot.localScale = Vector3.one;
			}
		}

		private static void ApplyConfiguredWorldVisualScale(Transform cloneRoot, string selection = null)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cloneRoot == (Object)null))
			{
				float num = Mathf.Max(GetDirectAkScaleMultiplier(selection) * 1.275f, 0.001f);
				cloneRoot.localScale = Vector3.Scale(cloneRoot.localScale, Vector3.one * num);
			}
		}

		private static void SetHierarchyActive(Transform root, bool active)
		{
			//IL_0030: 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_0040: Expected O, but got Unknown
			//IL_0040: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			((Component)root).gameObject.SetActive(active);
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)val == (Object)root))
				{
					((Component)val).gameObject.SetActive(active);
				}
			}
		}

		internal static void PrepareAkVisualRenderers(GameObject root, Transform targetVisualRoot)
		{
			PrepareRenderers(root, targetVisualRoot);
		}

		private static void TryRefreshItem(Item item, bool forceRefresh)
		{
			if (!ShouldProcessRuntimeItem(item) || !Plugin.IsWeaponFeatureEnabled() || !IsBlowgunLike(item))
			{
				return;
			}
			try
			{
				EnsureAkVisual(item, forceRefresh);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[ShootZombies] ItemPatch refresh failed: " + ex));
			}
		}

		private static void ApplyUiData(Item item, ItemUIData uiData)
		{
			if (uiData == null)
			{
				return;
			}
			Plugin.CaptureWeaponItemUiDisplayState(uiData);
			string weaponSelectionForItem = Plugin.GetWeaponSelectionForItem(item);
			uiData.itemName = Plugin.GetWeaponDisplayName(weaponSelectionForItem);
			Texture2D akIconTexture = Plugin.GetAkIconTexture(weaponSelectionForItem);
			if ((Object)(object)akIconTexture != (Object)null)
			{
				uiData.icon = akIconTexture;
				if (uiData.hasAltIcon)
				{
					uiData.altIcon = akIconTexture;
				}
			}
			Plugin.ApplyWeaponItemInteractionRestrictions(uiData);
		}

		private static Transform ResolveTargetVisualRoot(Item item)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			if ((int)item.itemState == 1)
			{
				Transform transform = ((Component)item).transform;
				Plugin.LogDiagnosticOnce("ak-target-root:" + ((Object)item).GetInstanceID(), "ResolveTargetVisualRoot using held item root: " + DescribeItemForDiagnostics(item) + ", root=" + GetTransformPath(transform));
				return transform;
			}
			if (IsDroppedWorldItem(item))
			{
				Transform transform2 = ((Component)item).transform;
				Plugin.LogDiagnosticOnce("ak-target-root:" + ((Object)item).GetInstanceID(), "ResolveTargetVisualRoot using dropped item root: " + DescribeItemForDiagnostics(item) + ", root=" + GetTransformPath(transform2));
				return transform2;
			}
			Transform val = ((Component)item).transform.Find("Blowgun");
			if ((Object)(object)val != (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-target-root:" + ((Object)item).GetInstanceID(), "ResolveTargetVisualRoot via Find(\"Blowgun\"): " + DescribeItemForDiagnostics(item) + ", root=" + GetTransformPath(val));
				return val;
			}
			Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				if (IsRenderableWeaponPiece(val2))
				{
					Plugin.LogDiagnosticOnce("ak-target-root:" + ((Object)item).GetInstanceID(), "ResolveTargetVisualRoot via renderer scan: " + DescribeItemForDiagnostics(item) + ", root=" + GetTransformPath(((Component)val2).transform) + ", rendererCandidates=" + DescribeRendererCandidatesForDiagnostics(item));
					return ((Component)val2).transform;
				}
			}
			Plugin.LogDiagnosticOnce("ak-target-root:" + ((Object)item).GetInstanceID(), "ResolveTargetVisualRoot fell back to item root: " + DescribeItemForDiagnostics(item) + ", root=" + GetTransformPath(((Component)item).transform) + ", rendererCandidates=" + DescribeRendererCandidatesForDiagnostics(item));
			return ((Component)item).transform;
		}

		private static Transform ResolveHeldLegacyParent(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			Transform val = ((Component)item).transform.Find("Blowgun");
			if ((Object)(object)val != (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-held-parent:" + ((Object)item).GetInstanceID(), "ResolveHeldLegacyParent via Find(\"Blowgun\"): " + DescribeItemForDiagnostics(item) + ", parent=" + GetTransformPath(val) + ", itemRoot=" + GetTransformPath(((Component)item).transform));
				return val;
			}
			Transform val2 = ResolveTargetVisualRoot(item);
			if ((Object)(object)val2 != (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-held-parent:" + ((Object)item).GetInstanceID(), "ResolveHeldLegacyParent fallback to target root: " + DescribeItemForDiagnostics(item) + ", parent=" + GetTransformPath(val2) + ", itemRoot=" + GetTransformPath(((Component)item).transform));
				return val2;
			}
			Plugin.LogDiagnosticOnce("ak-held-parent:" + ((Object)item).GetInstanceID(), "ResolveHeldLegacyParent fell back to item root: " + DescribeItemForDiagnostics(item) + ", parent=" + GetTransformPath(((Component)item).transform));
			return ((Component)item).transform;
		}

		private static bool IsRenderableWeaponPiece(Renderer renderer)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			string text = ((((Object)renderer).name ?? string.Empty) + "/" + (((Object)((Component)renderer).transform).name ?? string.Empty)).ToLowerInvariant();
			string[] excludedVisualKeywords = ExcludedVisualKeywords;
			foreach (string value in excludedVisualKeywords)
			{
				if (text.Contains(value))
				{
					return false;
				}
			}
			Mesh rendererMesh = GetRendererMesh(renderer);
			if ((Object)rendererMesh != (Object)null)
			{
				return rendererMesh.vertexCount > 24;
			}
			return false;
		}

		private static bool IsMeshBackedRenderer(Renderer renderer)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return (Object)GetRendererMesh(renderer) != (Object)null;
		}

		private static bool HasAnyPreferredRenderer(Renderer[] renderers)
		{
			if (renderers == null)
			{
				return false;
			}
			for (int i = 0; i < renderers.Length; i++)
			{
				if (IsRenderableWeaponPiece(renderers[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static Transform GetOrCreateLocalVisualRoot(Transform itemRoot, Transform targetVisualRoot)
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			AkLocalVisualMarker componentInChildren = ((Component)itemRoot).GetComponentInChildren<AkLocalVisualMarker>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Transform transform = ((Component)componentInChildren).transform;
				SyncVisualRootToTarget(transform, targetVisualRoot);
				return transform;
			}
			GameObject val = new GameObject("AK_VisualRoot");
			val.transform.SetParent(itemRoot, false);
			val.AddComponent<AkLocalVisualMarker>();
			SyncVisualRootToTarget(val.transform, targetVisualRoot);
			SetLayerRecursively(val.transform, ((Component)itemRoot).gameObject.layer);
			return val.transform;
		}

		private static void RefreshLocalVisual(Transform localVisualRoot, Transform targetVisualRoot, Item item, bool forceRefresh)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			if (!((Object)(object)localVisualRoot == (Object)null))
			{
				SyncVisualRootToTarget(localVisualRoot, targetVisualRoot);
				Transform val = localVisualRoot.Find("AK_LocalVisualClone");
				if (forceRefresh && (Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)((Component)val).gameObject);
					val = null;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = BuildVisualClone(item, localVisualRoot, targetVisualRoot);
				}
				EnsureVisualRenderersActive(val, visible: true);
				Transform val2 = (((Object)(object)targetVisualRoot != (Object)null) ? targetVisualRoot : (((Object)localVisualRoot.parent != (Object)null) ? localVisualRoot.parent : localVisualRoot));
				int layer = (IsLocallyHeldByPlayer(item) ? ResolveBestVisibleLayerForLocalHeldItem(item, val2) : ResolveReferenceLayer(item, val2));
				SetLayerRecursively(localVisualRoot, layer);
				Renderer val3 = SelectPreferredRenderer(((Component)val).GetComponentsInChildren<Renderer>(true), val);
				if ((Object)(object)val3 != (Object)null)
				{
					EnsureMuzzleMarkerForItem(item, val3);
				}
				EnsureMuzzleMarker(localVisualRoot, val);
			}
		}

		private static void BindVisualCloneToItem(Item item, Transform visualRoot)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null || (Object)(object)visualRoot == (Object)null)
			{
				return;
			}
			MeshRenderer[] array = (from r in ((Component)visualRoot).GetComponentsInChildren<MeshRenderer>(true)
				where (Object)(object)r != (Object)null && (Object)(object)GetRendererMesh((Renderer)r) != (Object)null
				select r).ToArray();
			SkinnedMeshRenderer[] array2 = (from r in ((Component)visualRoot).GetComponentsInChildren<SkinnedMeshRenderer>(true)
				where (Object)(object)r != (Object)null && (Object)(object)r.sharedMesh != (Object)null
				select r).ToArray();
			if ((array == null || array.Length == 0) && (array2 == null || array2.Length == 0))
			{
				return;
			}
			foreach (Renderer item2 in array.Cast<Renderer>().Concat((IEnumerable<Renderer>)(object)array2))
			{
				item2.enabled = true;
				item2.forceRenderingOff = false;
				item2.allowOcclusionWhenDynamic = false;
				SkinnedMeshRenderer val = (SkinnedMeshRenderer)((item2 is SkinnedMeshRenderer) ? item2 : null);
				if ((Object)(object)val != (Object)null)
				{
					val.updateWhenOffscreen = true;
				}
			}
			BindItemRendererFields(item, array, array2);
			Renderer val2 = SelectPreferredRenderer(array.Cast<Renderer>().Concat((IEnumerable<Renderer>)(object)array2), visualRoot);
			if ((Object)(object)val2 != (Object)null)
			{
				EnsureMuzzleMarkerForItem(item, val2);
			}
		}

		private static Transform BuildVisualClone(Item item, Transform localVisualRoot, Transform targetVisualRoot)
		{
			return CreatePreparedAkClone(item, localVisualRoot, targetVisualRoot, "AK_LocalVisualClone");
		}

		internal static void StripNonVisualComponents(GameObject root)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			foreach (Component item in root.GetComponentsInChildren<Component>(true).Reverse())
			{
				if (!((Object)item == (Object)null) && !(item is Transform) && !(item is MeshFilter) && !(item is MeshRenderer) && !(item is SkinnedMeshRenderer))
				{
					Object.Destroy((Object)item);
				}
			}
		}

		private static void PrepareRenderers(GameObject root, Transform targetVisualRoot)
		{
			Material[] fallbackMaterials = ResolveTemplateMaterials(targetVisualRoot).ToArray();
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			bool flag = HasAnyPreferredRenderer(componentsInChildren);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!IsRenderableWeaponPiece(val) && (flag || !IsMeshBackedRenderer(val)))
				{
					val.enabled = false;
					continue;
				}
				val.enabled = true;
				val.forceRenderingOff = false;
				ConfigureRuntimeWeaponRenderer(val);
				Material[] sharedMaterials = val.sharedMaterials;
				Mesh rendererMesh = GetRendererMesh(val);
				int subMeshCount = Math.Max(((Object)(object)rendererMesh != (Object)null) ? rendererMesh.subMeshCount : 0, 1);
				val.sharedMaterials = BuildVisibleMaterials(sharedMaterials, fallbackMaterials, subMeshCount);
				NormalizeRendererMaterials(val);
			}
		}

		private static void EnsureVisualRenderersActive(Transform visualClone, bool visible)
		{
			if ((Object)(object)visualClone == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)visualClone).GetComponentsInChildren<Renderer>(true);
			bool flag = HasAnyPreferredRenderer(componentsInChildren);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (!IsRenderableWeaponPiece(val) && (flag || !IsMeshBackedRenderer(val)))
					{
						val.enabled = false;
						continue;
					}
					val.enabled = visible;
					val.forceRenderingOff = !visible;
					val.allowOcclusionWhenDynamic = false;
				}
			}
		}

		private static Transform FindBestAnchor(Transform root)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			bool flag = HasAnyPreferredRenderer(componentsInChildren);
			Renderer val = null;
			int num = int.MinValue;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val2 in array)
			{
				if (!IsRenderableWeaponPiece(val2) && (flag || !IsMeshBackedRenderer(val2)))
				{
					continue;
				}
				Mesh rendererMesh = GetRendererMesh(val2);
				if (!((Object)rendererMesh == (Object)null))
				{
					int num2 = ScoreRenderer(val2, rendererMesh);
					if (num2 > num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).transform;
		}

		private static int ScoreRenderer(Renderer renderer, Mesh mesh)
		{
			int num = mesh.vertexCount;
			string text = ((((Object)renderer).name ?? string.Empty) + "/" + (((Object)((Component)renderer).transform).name ?? string.Empty)).ToLowerInvariant();
			if (text.Contains("ak") || text.Contains("gun") || text.Contains("rifle") || text.Contains("weapon"))
			{
				num += 2000;
			}
			if (text.Contains("body") || text.Contains("mesh"))
			{
				num += 1000;
			}
			if (renderer is SkinnedMeshRenderer)
			{
				num -= 500;
			}
			return num;
		}

		private static void AlignCloneToAnchor(Transform cloneRoot, Transform anchor)
		{
			//IL_0006: 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)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Matrix4x4 val = cloneRoot.parent.worldToLocalMatrix * anchor.localToWorldMatrix;
			DecomposeMatrix(Matrix4x4.TRS(new Vector3(-0.01f, -0.01f, 0f), Quaternion.Euler(0f, 0f, -12f), Vector3.one * 1.6f) * ((Matrix4x4)(ref val)).inverse, out var position, out var rotation, out var scale);
			cloneRoot.localPosition = position;
			cloneRoot.localRotation = rotation;
			cloneRoot.localScale = scale;
		}

		private static void EnsureMuzzleMarker(Transform localVisualRoot, Transform visualClone)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_008a: 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)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)localVisualRoot == (Object)null))
			{
				Transform val = localVisualRoot.Find("AK_MuzzleMarker");
				if ((Object)(object)val == (Object)null)
				{
					GameObject val2 = new GameObject("AK_MuzzleMarker");
					val2.transform.SetParent(localVisualRoot, false);
					val2.AddComponent<AkMuzzleMarker>();
					val = val2.transform;
				}
				Renderer val3 = FindBestMuzzleRenderer(visualClone);
				if ((Object)(object)val3 == (Object)null)
				{
					val.localPosition = Vector3.forward * 0.6f;
					val.localRotation = Quaternion.identity;
					return;
				}
				Bounds bounds = val3.bounds;
				Vector3 position = ((Bounds)(ref bounds)).center + ((Component)val3).transform.forward * Mathf.Max(((Bounds)(ref bounds)).extents.z, 0.06f);
				val.position = position;
				val.rotation = ((Component)val3).transform.rotation;
			}
		}

		private static Renderer FindBestMuzzleRenderer(Transform visualClone)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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)
			if ((Object)(object)visualClone == (Object)null)
			{
				return null;
			}
			Renderer[] componentsInChildren = ((Component)visualClone).GetComponentsInChildren<Renderer>(true);
			bool flag = HasAnyPreferredRenderer(componentsInChildren);
			Renderer result = null;
			float num = float.MinValue;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				bool flag2 = IsRenderableWeaponPiece(val) || (!flag && IsMeshBackedRenderer(val));
				if (val.enabled && flag2)
				{
					Bounds bounds = val.bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					float num2 = ((Vector3)(ref size)).magnitude + ((Bounds)(ref bounds)).center.z;
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static Material CreateRuntimeMaterial(Material source, Material template)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			Material val = null;
			bool num = (Object)(object)template != (Object)null && (Object)(object)template.shader != (Object)null && template.shader.isSupported && !string.IsNullOrWhiteSpace(((Object)template.shader).name) && ((Object)template.shader).name.StartsWith("W/", StringComparison.OrdinalIgnoreCase);
			bool flag = (Object)(object)source == (Object)null || (Object)(object)source.shader == (Object)null || !source.shader.isSupported || string.IsNullOrWhiteSpace(((Object)source.shader).name) || string.Equals(((Object)source.shader).name, "Standard", StringComparison.OrdinalIgnoreCase) || string.Equals(((Object)source.shader).name, "Standard (Specular setup)", StringComparison.OrdinalIgnoreCase) || string.Equals(((Object)source.shader).name, "Standard (Roughness setup)", StringComparison.OrdinalIgnoreCase);
			if (num && flag)
			{
				val = new Material(template);
				CopySourceMaterialProperties(((Object)(object)source != (Object)null) ? source : template, val, preserveDestinationColor: false);
				NormalizeMaterial(val, template);
				return val;
			}
			if ((Object)(object)source != (Object)null)
			{
				val = new Material(source);
				CopySourceMaterialProperties(source, val, preserveDestinationColor: false);
				NormalizeMaterial(val, source);
				return val;
			}
			if ((Object)(object)template != (Object)null && !HasUsableTexture(source))
			{
				val = new Material(template);
				CopySourceMaterialProperties(((Object)(object)source != (Object)null) ? source : template, val, preserveDestinationColor: false);
			}
			else if ((Object)(object)template != (Object)null)
			{
				val = new Material(template);
				CopySourceMaterialProperties(template, val, preserveDestinationColor: false);
			}
			else
			{
				val = new Material(ResolveFallbackShader());
			}
			NormalizeMaterial(val, ((Object)(object)template != (Object)null) ? template : source);
			return val;
		}

		private static Shader ResolveFallbackShader()
		{
			return Shader.Find("Unlit/Texture") ?? Shader.Find("W/Peak_Standard") ?? Shader.Find("Standard") ?? Shader.Find("Legacy Shaders/Diffuse") ?? Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Sprites/Default") ?? Shader.Find("Hidden/InternalErrorShader");
		}

		private static void NormalizeMaterial(Material material, Material referenceMaterial)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)material == (Object)null))
			{
				Shader shader = ResolveFallbackShader();
				string value = (((Object)(object)material.shader != (Object)null) ? ((Object)material.shader).name : string.Empty);
				if (((Object)(object)material.shader == (Object)null || !material.shader.isSupported || string.IsNullOrWhiteSpace(value)) && (Object)(object)referenceMaterial != (Object)null && (Object)(object)referenceMaterial.shader != (Object)null && referenceMaterial.shader.isSupported && !string.IsNullOrWhiteSpace(((Object)referenceMaterial.shader).name))
				{
					material.shader = referenceMaterial.shader;
				}
				if ((Object)(object)material.shader == (Object)null || !material.shader.isSupported)
				{
					material.shader = shader;
				}
				Color color = ResolveMaterialColor(material);
				color.a = 1f;
				ApplyColor(material, color);
				if (material.HasProperty("_BaseColor"))
				{
					Color color2 = material.GetColor("_BaseColor");
					color2.a = 1f;
					color2.r = Mathf.Max(color2.r, 0.82f);
					color2.g = Mathf.Max(color2.g, 0.82f);
					color2.b = Mathf.Max(color2.b, 0.82f);
					material.SetColor("_BaseColor", color2);
				}
				if (material.HasProperty("_Color"))
				{
					Color color3 = material.color;
					color3.a = 1f;
					color3.r = Mathf.Max(color3.r, 0.82f);
					color3.g = Mathf.Max(color3.g, 0.82f);
					color3.b = Mathf.Max(color3.b, 0.82f);
					material.color = color3;
				}
				if (material.HasProperty("_EmissionColor"))
				{
					material.EnableKeyword("_EMISSION");
					material.SetColor("_EmissionColor", new Color(0.08f, 0.08f, 0.08f, 1f));
				}
				if (material.HasProperty("_Surface"))
				{
					material.SetFloat("_Surface", 0f);
				}
				if (material.HasProperty("_AlphaClip"))
				{
					material.SetFloat("_AlphaClip", 0f);
				}
				if (material.HasProperty("_Cutoff"))
				{
					material.SetFloat("_Cutoff", 0f);
				}
				if (material.HasProperty("_Cull"))
				{
					material.SetInt("_Cull", 0);
				}
				material.renderQueue = (((Object)(object)referenceMaterial != (Object)null) ? referenceMaterial.renderQueue : (-1));
			}
		}

		private static List<Material> ResolveTemplateMaterials(Transform targetVisualRoot)
		{
			List<Material> list = new List<Material>();
			if ((Object)(object)targetVisualRoot == (Object)null)
			{
				return list;
			}
			Renderer[] componentsInChildren = ((Component)targetVisualRoot).GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!IsOriginalWeaponRenderer(val, targetVisualRoot))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null)
				{
					continue;
				}
				Material[] array2 = sharedMaterials;
				foreach (Material val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						list.Add(val2);
					}
				}
			}
			if (list.Count == 0)
			{
				Item componentInParent = ((Component)targetVisualRoot).GetComponentInParent<Item>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					AddTemplateMaterials(componentInParent.mainRenderer, list);
					Renderer[] addtlRenderers = componentInParent.addtlRenderers;
					if (addtlRenderers == null)
					{
						return list;
					}
					componentsInChildren = addtlRenderers;
					for (int k = 0; k < componentsInChildren.Length; k++)
					{
						AddTemplateMaterials(componentsInChildren[k], list);
					}
				}
			}
			return list;
		}

		private static void AddTemplateMaterials(Renderer renderer, List<Material> output)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return;
			}
			Material[] sharedMaterials = renderer.sharedMaterials;
			if (sharedMaterials == null)
			{
				return;
			}
			Material[] array = sharedMaterials;
			foreach (Material val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					output.Add(val);
				}
			}
		}

		private static void CopySourceMaterialProperties(Material source, Material destination, bool preserveDestinationColor)
		{
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || (Object)(object)destination == (Object)null)
			{
				return;
			}
			Texture val = ResolvePrimaryTexture(source);
			if ((Object)(object)val != (Object)null)
			{
				bool flag = false;
				if (destination.HasProperty("_MainTex"))
				{
					destination.SetTexture("_MainTex", val);
					CopyTextureScaleAndOffset(source, destination, "_MainTex", "_MainTex");
					flag = true;
				}
				if (destination.HasProperty("_BaseMap"))
				{
					destination.SetTexture("_BaseMap", val);
					CopyTextureScaleAndOffset(source, destination, "_BaseMap", "_BaseMap");
					flag = true;
				}
				if (!flag)
				{
					AssignPrimaryTextureToDestination(source, destination, val);
				}
			}
			CopyTextureByAlias(source, destination, "_BaseMap", "_MainTex");
			CopyTextureByAlias(source, destination, "_MainTex", "_BaseMap");
			CopyTextureByAlias(source, destination, "_BumpMap", "_NormalMap");
			CopyTextureByAlias(source, destination, "_NormalMap", "_BumpMap");
			CopyTextureByAlias(source, destination, "_MetallicGlossMap", "_MetallicTex");
			CopyTextureByAlias(source, destination, "_MetallicTex", "_MetallicGlossMap");
			CopyTextureIfPresent(source, destination, "_BumpMap");
			CopyTextureIfPresent(source, destination, "_NormalMap");
			CopyTextureIfPresent(source, destination, "_EmissionMap");
			CopyTextureIfPresent(source, destination, "_MetallicGlossMap");
			CopyTextureIfPresent(source, destination, "_OcclusionMap");
			string[] texturePropertyNames = source.GetTexturePropertyNames();
			if (texturePropertyNames != null)
			{
				string[] array = texturePropertyNames;
				foreach (string propertyName in array)
				{
					CopyTextureIfPresent(source, destination, propertyName);
				}
			}
			if (!preserveDestinationColor)
			{
				Color color = ResolveMaterialColor(source);
				color.a = 1f;
				ApplyColor(destination, color);
			}
			else
			{
				Color color2 = ResolveMaterialColor(destination);
				color2.a = 1f;
				ApplyColor(destination, color2);
			}
			CopyColorIfPresent(source, destination, "_EmissionColor");
			CopyFloatIfPresent(source, destination, "_Metallic");
			CopyFloatIfPresent(source, destination, "_Smoothness");
			CopyFloatIfPresent(source, destination, "_Glossiness");
			CopyFloatIfPresent(source, destination, "_BumpScale");
			CopyFloatIfPresent(source, destination, "_Cutoff");
			if (source.IsKeywordEnabled("_EMISSION"))
			{
				destination.EnableKeyword("_EMISSION");
			}
		}

		private static void CopyTextureIfPresent(Material source, Material destination, string propertyName)
		{
			if (source.HasProperty(propertyName) && destination.HasProperty(propertyName))
			{
				Texture texture = source.GetTexture(propertyName);
				if ((Object)(object)texture != (Object)null)
				{
					destination.SetTexture(propertyName, texture);
					CopyTextureScaleAndOffset(source, destination, propertyName, propertyName);
				}
			}
		}

		private static void CopyTextureByAlias(Material source, Material destination, string sourceProperty, string destinationProperty)
		{
			if (source.HasProperty(sourceProperty) && destination.HasProperty(destinationProperty))
			{
				Texture texture = source.GetTexture(sourceProperty);
				if (!((Object)(object)texture == (Object)null))
				{
					destination.SetTexture(destinationProperty, texture);
					CopyTextureScaleAndOffset(source, destination, sourceProperty, destinationProperty);
				}
			}
		}

		private static void AssignPrimaryTextureToDestination(Material source, Material destination, Texture texture)
		{
			if ((Object)(object)texture == (Object)null || (Object)(object)destination == (Object)null)
			{
				return;
			}
			string[] texturePropertyNames = destination.GetTexturePropertyNames();
			if (texturePropertyNames == null || texturePropertyNames.Length == 0)
			{
				return;
			}
			string text = texturePropertyNames.FirstOrDefault((string name) => !string.IsNullOrEmpty(name) && (name.IndexOf("base", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("albedo", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("diff", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("main", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("color", StringComparison.OrdinalIgnoreCase) >= 0));
			if (string.IsNullOrEmpty(text))
			{
				text = texturePropertyNames.FirstOrDefault((string name) => !string.IsNullOrEmpty(name) && name.IndexOf("normal", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("bump", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("metal", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("occlusion", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("emission", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("detail", StringComparison.OrdinalIgnoreCase) < 0) ?? texturePropertyNames[0];
			}
			if (string.IsNullOrEmpty(text) || !destination.HasProperty(text))
			{
				return;
			}
			destination.SetTexture(text, texture);
			if ((Object)(object)source != (Object)null)
			{
				string text2 = ((source.HasProperty(text) && (Object)(object)source.GetTexture(text) != (Object)null) ? text : ResolveSourceScaleProperty(source));
				if (!string.IsNullOrEmpty(text2))
				{
					CopyTextureScaleAndOffset(source, destination, text2, text);
				}
			}
		}

		private static string ResolveSourceScaleProperty(Material source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			string[] array = new string[3] { "_BaseMap", "_MainTex", "_AlbedoMap" };
			foreach (string text in array)
			{
				if (source.HasProperty(text) && (Object)(object)source.GetTexture(text) != (Object)null)
				{
					return text;
				}
			}
			return null;
		}

		private static void CopyTextureScaleAndOffset(Material source, Material destination, string sourceProperty, string destinationProperty)
		{
			//IL_0016: 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)
			if (source.HasProperty(sourceProperty) && destination.HasProperty(destinationProperty))
			{
				destination.SetTextureScale(destinationProperty, source.GetTextureScale(sourceProperty));
				destination.SetTextureOffset(destinationProperty, source.GetTextureOffset(sourceProperty));
			}
		}

		private static Texture ResolvePrimaryTexture(Material material)
		{
			if ((Object)(object)material == (Object)null)
			{
				return null;
			}
			string[] array = new string[6] { "_BaseMap", "_MainTex", "_BaseColorMap", "_AlbedoMap", "_Albedo", "_DiffuseMap" };
			foreach (string text in array)
			{
				if (material.HasProperty(text))
				{
					Texture texture = material.GetTexture(text);
					if ((Object)(object)texture != (Object)null)
					{
						return texture;
					}
				}
			}
			string[] texturePropertyNames = material.GetTexturePropertyNames();
			if (texturePropertyNames == null)
			{
				return null;
			}
			array = texturePropertyNames;
			foreach (string text2 in array)
			{
				if (material.HasProperty(text2))
				{
					Texture texture2 = material.GetTexture(text2);
					if ((Object)(object)texture2 != (Object)null)
					{
						return texture2;
					}
				}
			}
			return null;
		}

		private static bool HasUsableTexture(Material material)
		{
			if ((Object)(object)material != (Object)null)
			{
				return (Object)(object)ResolvePrimaryTexture(material) != (Object)null;
			}
			return false;
		}

		private static bool HasUsableTexture(Material[] materials)
		{
			if (materials == null || materials.Length == 0)
			{
				return false;
			}
			foreach (Material val in materials)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)ResolvePrimaryTexture(val) != (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		private static void CopyFloatIfPresent(Material source, Material destination, string propertyName)
		{
			if (source.HasProperty(propertyName) && destination.HasProperty(propertyName))
			{
				destination.SetFloat(propertyName, source.GetFloat(propertyName));
			}
		}

		private static void CopyColorIfPresent(Material source, Material destination, string propertyName)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (source.HasProperty(propertyName) && destination.HasProperty(propertyName))
			{
				destination.SetColor(propertyName, source.GetColor(propertyName));
			}
		}

		private static Color ResolveMaterialColor(Material material)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)material == (Object)null)
			{
				return Color.white;
			}
			if (material.HasProperty("_BaseColor"))
			{
				return material.GetColor("_BaseColor");
			}
			if (material.HasProperty("_Color"))
			{
				return material.GetColor("_Color");
			}
			return Color.white;
		}

		private static void ApplyColor(Material material, Color color)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)material == (Object)null))
			{
				if (material.HasProperty("_BaseColor"))
				{
					material.SetColor("_BaseColor", color);
				}
				if (material.HasProperty("_Color"))
				{
					material.SetColor("_Color", color);
				}
			}
		}

		private static void HideOriginalRenderers(Item item, Transform targetVisualRoot)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)targetVisualRoot == (Object)null)
			{
				return;
			}
			List<Renderer> list = new List<Renderer>();
			Renderer[] componentsInChildren = ((Component)targetVisualRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && IsOriginalWeaponRenderer(val, targetVisualRoot))
				{
					val.enabled = false;
					val.forceRenderingOff = true;
					list.Add(val);
				}
			}
			HiddenRendererCache[((Object)item).GetInstanceID()] = list.ToArray();
			Plugin.LogDiagnosticOnce("ak-hide-original:" + ((Object)item).GetInstanceID(), $"HideOriginalRenderers processed {DescribeItemForDiagnostics(item)}, targetRoot={GetTransformPath(targetVisualRoot)}, hiddenCount={list.Count}, hidden={DescribeRendererCollectionForDiagnostics(list)}");
		}

		private static bool IsOriginalWeaponRenderer(Renderer renderer, Transform targetVisualRoot)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)renderer).GetComponentInParent<AkLocalVisualMarker>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)renderer).GetComponentInParent<AkSimpleVisualMarker>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)renderer).GetComponentInParent<AkHeldLegacyVisualMarker>() != (Object)null)
			{
				return false;
			}
			if (HasNamedAncestor(((Component)renderer).transform, "AK_InPlaceVisualRoot"))
			{
				return false;
			}
			if (!((Component)renderer).transform.IsChildOf(targetVisualRoot))
			{
				return false;
			}
			string text = ((((Object)renderer).name ?? string.Empty) + "/" + (((Object)((Component)renderer).transform).name ?? string.Empty)).ToLowerInvariant();
			if (!text.Contains("hand") && !text.Contains("arm"))
			{
				return !text.Contains("finger");
			}
			return false;
		}

		private static void RestoreOriginalVisual(Item item)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			RestoreInPlaceVisual(item);
			AkLocalVisualMarker componentInChildren = ((Component)item).GetComponentInChildren<AkLocalVisualMarker>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Object.Destroy((Object)((Component)componentInChildren).gameObject);
			}
			if (HiddenRendererCache.TryGetValue(((Object)item).GetInstanceID(), out var value))
			{
				Renderer[] array = value;
				foreach (Renderer val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						val.enabled = true;
						val.forceRenderingOff = false;
						val.allowOcclusionWhenDynamic = false;
					}
				}
			}
			HiddenRendererCache.Remove(((Object)item).GetInstanceID());
			CleanupAllWeaponWorldColliders(item);
			SetOriginalItemCollidersEnabled(item, enabled: true);
		}

		private static void CleanupItem(Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				RestoreInPlaceVisual(item);
				CleanupSimpleAkVisual(item);
				DestroyLegacyHeldVisual(item, restoreRenderers: false);
				CleanupAllWeaponWorldColliders(item);
				SetOriginalItemCollidersEnabled(item, enabled: true);
				InPlaceSwappedItemIds.Remove(((Object)item).GetInstanceID());
				HiddenRendererCache.Remove(((Object)item).GetInstanceID());
				PendingSetStateValueByItemId.Remove(((Object)item).GetInstanceID());
				PendingSetStateHolderByItemId.Remove(((Object)item).GetInstanceID());
			}
		}

		private static void RestoreInPlaceVisual(Item item)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0087: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)item).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && string.Equals(((Object)val).name, "AK_InPlaceVisualRoot", StringComparison.Ordinal))
				{
					Object.Destroy((Object)((Component)val).gameObject);
				}
			}
			AkInPlaceMarker[] componentsInChildren2 = ((Component)item).GetComponentsInChildren<AkInPlaceMarker>(true);
			foreach (AkInPlaceMarker akInPlaceMarker in componentsInChildren2)
			{
				if ((Object)(object)akInPlaceMarker == (Object)null)
				{
					continue;
				}
				Transform transform = ((Component)akInPlaceMarker).transform;
				if (akInPlaceMarker.hasBaseTransform)
				{
					transform.localPosition = akInPlaceMarker.baseLocalPosition;
					transform.localRotation = akInPlaceMarker.baseLocalRotation;
					transform.localScale = akInPlaceMarker.baseLocalScale;
				}
				MeshFilter component = ((Component)akInPlaceMarker).GetComponent<MeshFilter>();
				if ((Object)(object)component != (Object)null && akInPlaceMarker.hasOriginalVisual)
				{
					component.sharedMesh = akInPlaceMarker.originalMesh;
				}
				MeshRenderer component2 = ((Component)akInPlaceMarker).GetComponent<MeshRenderer>();
				if ((Object)(object)component2 != (Object)null)
				{
					if (akInPlaceMarker.hasOriginalVisual)
					{
						((Renderer)component2).sharedMaterials = akInPlaceMarker.originalMaterials ?? Array.Empty<Material>();
					}
					((Renderer)component2).enabled = true;
					((Renderer)component2).forceRenderingOff = false;
					((Renderer)component2).allowOcclusionWhenDynamic = false;
				}
				Object.Destroy((Object)akInPlaceMarker);
			}
			InPlaceSwappedItemIds.Remove(((Object)item).GetInstanceID());
		}

		private static void CleanupSimpleAkVisual(Item item)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (!((Object)(object)item == (Object)null))
			{
				Transform val = FindSimpleAkVisualRoot(item);
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)((Component)val).gameObject);
				}
			}
		}

		private static Transform FindSimpleAkVisualRoot(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			AkSimpleVisualMarker componentInChildren = ((Component)item).GetComponentInChildren<AkSimpleVisualMarker>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return ((Component)componentInChildren).transform;
			}
			return ((IEnumerable<Transform>)((Component)item).GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform t) => (Object)(object)t != (Object)null && string.Equals(((Object)t).name, "AK47Model", StringComparison.Ordinal)));
		}

		private static Transform TryCreatePreparedSimpleAkVisual(Item item, Transform targetVisualRoot)
		{
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			Transform val = targetVisualRoot;
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)item).transform;
			}
			Transform val2 = CreatePreparedAkClone(item, val, targetVisualRoot, "AK47Model");
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			if ((Object)(object)((Component)val2).GetComponent<AkSimpleVisualMarker>() == (Object)null)
			{
				((Component)val2).gameObject.AddComponent<AkSimpleVisualMarker>();
			}
			EnsureVisualRenderersActive(val2, visible: true);
			return val2;
		}

		private static bool ShouldPreferBakedSimpleVisual(Item item)
		{
			return (Object)(object)item != (Object)null;
		}

		private static bool ShouldIncludeBakedSimpleSourceRenderer(Renderer sourceRenderer)
		{
			if ((Object)(object)sourceRenderer == (Object)null || !IsMeshBackedRenderer(sourceRenderer))
			{
				return false;
			}
			if ((Object)(object)GetRendererMesh(sourceRenderer) == (Object)null)
			{
				return false;
			}
			if (ShouldRejectDirectAkSource(((Component)sourceRenderer).transform))
			{
				return false;
			}
			string text = ((((Object)sourceRenderer).name ?? string.Empty) + "/" + GetTransformPath(((Component)sourceRenderer).transform)).ToLowerInvariant();
			if (ExcludedVisualKeywords.Any((string keyword) => !string.IsNullOrWhiteSpace(keyword) && text.Contains(keyword)))
			{
				return false;
			}
			return true;
		}

		private static Transform TryCreateBakedSimpleAkVisual(Item item, Transform targetVisualRoot)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Expected O, but got Unknown
			//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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: 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_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_0137: 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)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			string weaponSelectionForItem = Plugin.GetWeaponSelectionForItem(item);
			GameObject akVisualPrefab = Plugin.GetAkVisualPrefab(weaponSelectionForItem);
			if ((Object)(object)akVisualPrefab == (Object)null)
			{
				return null;
			}
			Transform val = targetVisualRoot;
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)item).transform;
			}
			GameObject val2 = new GameObject("AK47Model");
			val2.transform.SetParent(val, false);
			val2.transform.localPosition = GetDirectAkPositionOverride(weaponSelectionForItem);
			val2.transform.localRotation = GetDirectAkRotationOverride();
			val2.transform.localScale = Vector3.one;
			val2.AddComponent<AkSimpleVisualMarker>();
			Material[] fallbackMaterials = ResolveTemplateMaterials(val).ToArray();
			int num = 0;
			Renderer[] componentsInChildren = akVisualPrefab.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val3 in componentsInChildren)
			{
				if (!ShouldIncludeBakedSimpleSourceRenderer(val3))
				{
					continue;
				}
				Mesh rendererMesh = GetRendererMesh(val3);
				if (!((Object)(object)rendererMesh == (Object)null) && rendererMesh.vertexCount > 0)
				{
					GameObject val4 = new GameObject(string.IsNullOrWhiteSpace(((Object)val3).name) ? ("AK47MeshPart_" + num) : ((Object)val3).name);
					val4.transform.SetParent(val2.transform, false);
					if (!TryGetTransformPoseRelativeToAkRoot(((Component)val3).transform, out var localPosition, out var localRotation, out var localScale))
					{
						localPosition = ((Component)val3).transform.localPosition;
						localRotation = ((Component)val3).transform.localRotation;
						localScale = ((Component)val3).transform.localScale;
					}
					val4.transform.localPosition = SanitizeLocalPosition(localPosition, Vector3.zero);
					val4.transform.localRotation = SanitizeLocalRotation(localRotation);
					val4.transform.localScale = SanitizeLocalScale(localScale, Vector3.one);
					MeshFilter val5 = val4.AddComponent<MeshFilter>();
					MeshRenderer obj = val4.AddComponent<MeshRenderer>();
					val5.sharedMesh = rendererMesh;
					((Renderer)obj).sharedMaterials = BuildVisibleMaterials(val3.sharedMaterials, fallbackMaterials, Math.Max(rendererMesh.subMeshCount, 1));
					ConfigureRuntimeWeaponRenderer((Renderer)obj);
					NormalizeRendererMaterials((Renderer)obj);
					((Renderer)obj).enabled = true;
					((Renderer)obj).forceRenderingOff = false;
					num++;
				}
			}
			if (num == 0)
			{
				Object.Destroy((Object)val2);
				return null;
			}
			NormalizeVisualScaleAgainstReference(val2.transform, val, "AK47Model-baked");
			ApplyConfiguredWorldVisualScale(val2.transform, weaponSelectionForItem);
			SetLayerRecursively(val2.transform, ((Component)val).gameObject.layer);
			SetHierarchyActive(val2.transform, active: true);
			EnsureVisualRenderersActive(val2.transform, visible: true);
			Plugin.LogDiagnosticOnce("ak-simple-baked-create-success:" + ((Object)item).GetInstanceID(), "Created baked simple replacement visual: " + DescribeItemForDiagnostics(item) + ", parent=" + GetTransformPath(val) + ", visual=" + GetTransformPath(val2.transform) + ", renderers=" + DescribeRendererCollectionForDiagnostics(((Component)val2.transform).GetComponentsInChildren<Renderer>(true)) + ", bounds=" + DescribeBoundsForDiagnostics(val2.transform) + ", selection=" + weaponSelectionForItem + ", prefab=" + Plugin.DescribeAkVisualPrefabForDiagnostics(weaponSelectionForItem));
			return val2.transform;
		}

		private static Transform GetOrCreateSimpleAkVisual(Item item, Transform targetVisualRoot, bool forceRefreshMarker)
		{
			//IL_0030: 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_0040: Expected O, but got Unknown
			//IL_0040: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Expected O, but got Unknown
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			Transform val = FindSimpleAkVisualRoot(item);
			if ((Object)(object)val != (Object)null && (Object)(object)targetVisualRoot != (Object)null && (Object)val.parent != (Object)targetVisualRoot)
			{
				Plugin.LogDiagnosticOnce("ak-simple-recreate-parent:" + ((Object)item).GetInstanceID() + ":" + ((Object)val).GetInstanceID(), "Recreating simple visual because parent changed: " + DescribeItemForDiagnostics(item) + ", existingParent=" + GetTransformPath(val.parent) + ", targetParent=" + GetTransformPath(targetVisualRoot) + ", existingRenderers=" + DescribeRendererCollectionForDiagnostics(((Component)val).GetComponentsInChildren<Renderer>(true)));
				Object.Destroy((Object)((Component)val).gameObject);
				val = null;
				forceRefreshMarker = true;
			}
			if ((Object)(object)val != (Object)null && !forceRefreshMarker && HasReplacementVisualSource(item) && CountMeshBackedRenderers(val) == 0)
			{
				Plugin.LogDiagnosticOnce("ak-simple-recreate-empty:" + ((Object)item).GetInstanceID() + ":" + ((Object)val).GetInstanceID(), "Recreating simple visual because it has no mesh-backed renderers: " + DescribeItemForDiagnostics(item) + ", visual=" + GetTransformPath(val) + ", renderers=" + DescribeRendererCollectionForDiagnostics(((Component)val).GetComponentsInChildren<Renderer>(true)));
				Object.Destroy((Object)((Component)val).gameObject);
				val = null;
				forceRefreshMarker = true;
			}
			if (forceRefreshMarker && (Object)(object)val != (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-simple-force-refresh:" + ((Object)item).GetInstanceID() + ":" + ((Object)val).GetInstanceID(), "Destroying simple visual for force refresh: " + DescribeItemForDiagnostics(item) + ", visual=" + GetTransformPath(val) + ", renderers=" + DescribeRendererCollectionForDiagnostics(((Component)val).GetComponentsInChildren<Renderer>(true)));
				Object.Destroy((Object)((Component)val).gameObject);
				val = null;
			}
			if ((Object)(object)val != (Object)null && !forceRefreshMarker)
			{
				Plugin.LogDiagnosticOnce("ak-simple-reuse:" + ((Object)item).GetInstanceID() + ":" + ((Object)val).GetInstanceID(), "Reusing existing simple visual: " + DescribeItemForDiagnostics(item) + ", visual=" + GetTransformPath(val) + ", parent=" + GetTransformPath(val.parent) + ", bounds=" + DescribeBoundsForDiagnostics(val) + ", renderers=" + DescribeRendererCollectionForDiagnostics(((Component)val).GetComponentsInChildren<Renderer>(true)));
			}
			if ((Object)(object)val == (Object)null)
			{
				bool flag = false;
				Transform val2 = targetVisualRoot;
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)item).transform;
				}
				if (!flag)
				{
					val = TryCreatePreparedSimpleAkVisual(item, val2);
				}
				if ((Object)(object)val == (Object)null)
				{
					string debugInfo = string.Empty;
					Mesh mesh = null;
					Material[] materials = null;
					Vector3 localScale = Vector3.one;
					Quaternion localRotation = Quaternion.identity;
					Vector3 localPosition = Vector3.zero;
					if (!flag || !TryResolveDebugSphereVisual(out mesh, out materials, out localScale, out localRotation, out localPosition, out debugInfo) || (Object)(object)mesh == (Object)null)
					{
						Plugin.LogDiagnosticOnce("ak-simple-create-fail:" + ((Object)item).GetInstanceID(), $"Simple visual creation failed: {DescribeItemForDiagnostics(item)}, targetRoot={GetTransformPath(targetVisualRoot)}, debugMode={flag}, debugInfo={debugInfo}, selection={Plugin.GetWeaponSelectionForItem(item)}, prefab={Plugin.DescribeAkVisualPrefabForDiagnostics(Plugin.GetWeaponSelectionForItem(item))}");
						return null;
					}
					GameObject val3 = new GameObject("AK47Model");
					val3.transform.SetParent(val2, false);
					val3.transform.localPosition = localPosition;
					val3.transform.localRotation = localRotation;
					val3.transform.localScale = localScale;
					val3.AddComponent<AkSimpleVisualMarker>();
					MeshFilter val4 = val3.AddComponent<MeshFilter>();
					MeshRenderer obj = val3.AddComponent<MeshRenderer>();
					val4.sharedMesh = mesh;
					((Renderer)obj).sharedMaterials = BuildVisibleMaterials(subMeshCount: Mathf.Max(mesh.subMeshCount, 1), preferredMaterials: materials, fallbackMaterials: ResolveTemplateMaterials(val2).ToArray());
					((Renderer)obj).enabled = true;
					((Renderer)obj).forceRenderingOff = false;
					ConfigureRuntimeWeaponRenderer((Renderer)obj);
					NormalizeVisualScaleAgainstReference(val3.transform, val2, "AK47Model-direct");
					ApplyConfiguredWorldVisualScale(val3.transform, Plugin.GetWeaponSelectionForItem(item));
					SetLayerRecursively(layer: IsLocallyHeldByPlayer(item) ? ResolveBestVisibleLayerForLocalHeldItem(item, val2) : ResolveReferenceLayer(item, val2), root: val3.transform);
					val = val3.transform;
					Plugin.LogDiagnosticOnce("ak-simple-create-success:" + ((Object)item).GetInstanceID(), $"Created simple debug visual: {DescribeItemForDiagnostics(item)}, parent={GetTransformPath(val2)}, visual={GetTransformPath(val)}, debugInfo={debugInfo}, mesh={((Object)mesh).name}, pos={localPosition}, rot={((Quaternion)(ref localRotation)).eulerAngles}, scale={localScale}");
				}
				else if (!flag)
				{
					Plugin.LogDiagnosticOnce("ak-simple-create-clone-success:" + ((Object)item).GetInstanceID(), "Created simple replacement visual from selected prefab clone: " + DescribeItemForDiagnostics(item) + ", parent=" + GetTransformPath(val2) + ", visual=" + GetTransformPath(val) + ", selection=" + Plugin.GetWeaponSelectionForItem(item) + ", prefab=" + Plugin.DescribeAkVisualPrefabForDiagnostics(Plugin.GetWeaponSelectionForItem(item)));
				}
			}
			Renderer val5 = SelectPreferredRenderer(((Component)val).GetComponentsInChildren<Renderer>(true), val);
			if ((Object)(object)val5 == (Object)null)
			{
				bool flag2 = ShouldShowSimpleAkVisual(item);
				SetCustomVisualRenderersVisible(val, flag2);
				SyncWeaponColliderState(item, null);
				LogWorldVisualState(item, val, flag2 ? "simple-no-preferred-renderer-visible" : "simple-no-preferred-renderer-hidden", targetVisualRoot);
				return val;
			}
			bool flag3 = ShouldShowSimpleAkVisual(item);
			SetCustomVisualRenderersVisible(val, flag3);
			if (!flag3)
			{
				SyncWeaponColliderState(item, null);
				LogWorldVisualState(item, val, "simple-hidden", targetVisualRoot);
				return val;
			}
			val5.enabled = true;
			val5.forceRenderingOff = false;
			val5.allowOcclusionWhenDynamic = false;
			int layer2 = (IsLocallyHeldByPlayer(item) ? ResolveBestVisibleLayerForLocalHeldItem(item, targetVisualRoot) : ResolveReferenceLayer(item, targetVisualRoot));
			SetLayerRecursively(val, layer2);
			EnsureMuzzleMarkerForItem(item, val5);
			SyncWeaponColliderState(item, null);
			LogWorldVisualState(item, val, "simple-final", targetVisualRoot);
			return val;
		}

		private static bool ShouldUseWorldWeaponCollider(Item item)
		{
			return IsDroppedWorldItem(item);
		}

		private static void SyncWeaponColliderState(Item item, Transform weaponVisualRoot)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected I4, but got Unknown
			if (!((Object)(object)item == (Object)null))
			{
				CleanupAllWeaponWorldColliders(item);
				SetOriginalItemCollidersEnabled(item, enabled: true);
				Plugin.LogDiagnosticOnce("ak-collider-state:" + ((Object)item).GetInstanceID() + ":" + (int)item.itemState + ":original-only", "Synced weapon collider state: " + DescribeItemForDiagnostics(item) + ", requestedCustom=False, usingCustom=False, mode=original-item, visualRoot=" + GetTransformPath(weaponVisualRoot));
			}
		}

		private static bool EnsureWorldWeaponCollider(Item item, Transform visualRoot)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_00fa: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || (Object)(object)visualRoot == (Object)null)
			{
				return false;
			}
			if (!ShouldUseWorldWeaponCollider(item))
			{
				CleanupAllWeaponWorldColliders(item);
				return false;
			}
			Transform transform = ((Component)item).transform;
			if ((Object)(object)transform == (Object)null)
			{
				return false;
			}
			if (!TryGetCombinedRenderableBounds(visualRoot, out var bounds) || !TryTransformWorldBoundsToLocalBounds(transform, bounds, out var localBounds))
			{
				Plugin.LogDiagnosticOnce("ak-world-collider-fail:" + ((Object)item).GetInstanceID(), $"Failed to build world collider from render bounds, keeping original colliders: {DescribeItemForDiagnostics(item)}, visualRoot={GetTransformPath(visualRoot)}, boundsValid={TryGetCombinedRenderableBounds(visualRoot, out var _)}");
				return false;
			}
			Transform val = ((IEnumerable<Transform>)((Component)item).GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform t) => (Object)(object)t != (Object)null && string.Equals(((Object)t).name, "AK_WorldCollider", StringComparison.Ordinal)));
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("AK_WorldCollider");
				val2.transform.SetParent(transform, false);
				val = val2.transform;
			}
			else if ((Object)val.parent != (Object)transform)
			{
				val.SetParent(transform, false);
			}
			val.localRotation = Quaternion.identity;
			val.localScale = Vector3.one;
			val.localPosition = ((Bounds)(ref localBounds)).center;
			BoxCollider val3 = ((Component)val).GetComponent<BoxCollider>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ((Component)val).gameObject.AddComponent<BoxCollider>();
			}
			((Collider)val3).isTrigger = false;
			((Collider)val3).enabled = true;
			val3.center = Vector3.zero;
			val3.size = new Vector3(Mathf.Max(((Bounds)(ref localBounds)).size.x, 0.18f), Mathf.Max(((Bounds)(ref localBounds)).size.y, 0.18f), Mathf.Max(((Bounds)(ref localBounds)).size.z, 0.6f));
			Plugin.LogDiagnosticOnce("ak-world-collider:" + ((Object)item).GetInstanceID() + ":" + ((Object)visualRoot).GetInstanceID(), $"Configured world collider: {DescribeItemForDiagnostics(item)}, visualRoot={GetTransformPath(visualRoot)}, collider={GetTransformPath(val)}, parentScale={transform.lossyScale}, localCenter={val.localPosition}, localSize={val3.size}, trigger={((Collider)val3).isTrigger}, bounds={DescribeBoundsForDiagnostics(visualRoot)}");
			return true;
		}

		private static void CleanupWorldWeaponCollider(Transform visualRoot)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (!((Object)(object)visualRoot == (Object)null))
			{
				Transform val = visualRoot.Find("AK_WorldCollider");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)((Component)val).gameObject);
				}
			}
		}

		private static void CleanupAllWeaponWorldColliders(Item item)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)item).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && string.Equals(((Object)val).name, "AK_WorldCollider", StringComparison.Ordinal))
				{
					Object.Destroy((Object)((Component)val).gameObject);
				}
			}
		}

		private static void SetOriginalItemCollidersEnabled(Item item, bool enabled)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			foreach (Collider item2 in EnumerateOriginalItemColliders(item))
			{
				if (!((Object)(object)item2 == (Object)null))
				{
					item2.enabled = enabled;
				}
			}
		}

		[IteratorStateMachine(typeof(<EnumerateOriginalItemColliders>d__167))]
		private static IEnumerable<Collider> EnumerateOriginalItemColliders(Item item)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateOriginalItemColliders>d__167(-2)
			{
				<>3__item = item
			};
		}

		private static bool IsCustomWeaponCollider(Collider collider)
		{
			if ((Object)(object)collider == (Object)null)
			{
				return false;
			}
			if (string.Equals(((Object)collider).name, "AK_WorldCollider", StringComparison.Ordinal))
			{
				return true;
			}
			Transform transform = ((Component)collider).transform;
			if ((Object)(object)((Component)collider).GetComponentInParent<AkSimpleVisualMarker>(true) != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)collider).GetComponentInParent<AkLocalVisualMarker>(true) != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)collider).GetComponentInParent<AkHeldLegacyVisualMarker>(true) != (Object)null)
			{
				return true;
			}
			if (HasNamedAncestor(transform, "AK_InPlaceVisualRoot"))
			{
				return true;
			}
			return string.Equals(((Object)transform).name, "AK_WorldCollider", StringComparison.Ordinal);
		}

		private static bool TryTransformWorldBoundsToLocalBounds(Transform localRoot, Bounds worldBounds, out Bounds localBounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: 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)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			localBounds = default(Bounds);
			if ((Object)(object)localRoot == (Object)null)
			{
				return false;
			}
			Matrix4x4 worldToLocalMatrix = localRoot.worldToLocalMatrix;
			Vector3 center = ((Bounds)(ref worldBounds)).center;
			Vector3 extents = ((Bounds)(ref worldBounds)).extents;
			Vector3[] obj = new Vector3[8]
			{
				center + new Vector3(0f - extents.x, 0f - extents.y, 0f - extents.z),
				center + new Vector3(0f - extents.x, 0f - extents.y, extents.z),
				center + new Vector3(0f - extents.x, extents.y, 0f - extents.z),
				center + new Vector3(0f - extents.x, extents.y, extents.z),
				center + new Vector3(extents.x, 0f - extents.y, 0f - extents.z),
				center + new Vector3(extents.x, 0f - extents.y, extents.z),
				center + new Vector3(extents.x, extents.y, 0f - extents.z),
				center + new Vector3(extents.x, extents.y, extents.z)
			};
			bool flag = false;
			Vector3[] array = (Vector3[])(object)obj;
			foreach (Vector3 val in array)
			{
				Vector3 val2 = ((Matrix4x4)(ref worldToLocalMatrix)).MultiplyPoint3x4(val);
				if (IsFiniteVector3(val2))
				{
					if (!flag)
					{
						localBounds = new Bounds(val2, Vector3.zero);
						flag = true;
					}
					else
					{
						((Bounds)(ref localBounds)).Encapsulate(val2);
					}
				}
			}
			return flag;
		}

		private static int CountMeshBackedRenderers(Transform root)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return 0;
			}
			int num = 0;
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && (Object)GetRendererMesh(val) != (Object)null)
				{
					num++;
				}
			}
			return num;
		}

		private static void DisableNonVisualComponents(GameObject root)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)val == (Object)null || val is Transform || val is MeshFilter || val is Renderer)
				{
					continue;
				}
				Behaviour val2 = (Behaviour)((val is Behaviour) ? val : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.enabled = false;
					continue;
				}
				Collider val3 = (Collider)((val is Collider) ? val : null);
				if ((Object)(object)val3 != (Object)null)
				{
					val3.enabled = false;
					continue;
				}
				Rigidbody val4 = (Rigidbody)((val is Rigidbody) ? val : null);
				if ((Object)(object)val4 != (Object)null)
				{
					val4.isKinematic = true;
					val4.detectCollisions = false;
				}
			}
		}

		private static void PreparePrefabCloneRenderers(GameObject root, Transform targetVisualRoot)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				bool flag2 = (val.enabled = IsCloneWeaponRenderer(val));
				bool flag3 = flag2;
				val.forceRenderingOff = !flag3;
				ConfigureRuntimeWeaponRenderer(val);
				if (flag3)
				{
					SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.updateWhenOffscreen = true;
					}
					Material[] sharedMaterials = val.sharedMaterials;
					Mesh rendererMesh = GetRendererMesh(val);
					int subMeshCount = Math.Max(((Object)(object)rendererMesh != (Object)null) ? rendererMesh.subMeshCount : 0, 1);
					val.sharedMaterials = BuildVisibleMaterials(sharedMaterials, ResolveTemplateMaterials(targetVisualRoot).ToArray(), subMeshCount);
				}
			}
		}

		private static bool IsCloneWeaponRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null || !IsMeshBackedRenderer(renderer))
			{
				return false;
			}
			string text = GetTransformPath(((Component)renderer).transform).ToLowerInvariant();
			if (text.Contains("/hand") || text.Contains("/arm") || text.Contains("finger") || text.Contains("holiday") || text.Contains("vfx") || text.Contains("effect") || text.Contains("spawn") || text.Contains("muzzle"))
			{
				return false;
			}
			return true;
		}

		private static bool TryApplyInPlaceWeaponVisual(Item item, Transform targetVisualRoot, bool forceRefreshMarker)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected I4, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected I4, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			DestroyLegacyHeldVisual(item, restoreRenderers: true);
			CleanupSimpleAkVisual(item);
			if (forceRefreshMarker || (Object)(object)FindInPlaceVisualRoot(item, targetVisualRoot) == (Object)null)
			{
				RestoreOriginalVisual(item);
			}
			if (!TryReplaceMeshOnExistingAnchor(item, targetVisualRoot, forceRefreshMarker, out var modelRoot, out var preferredRenderer))
			{
				return false;
			}
			if ((Object)(object)modelRoot == (Object)null || (Object)(object)preferredRenderer == (Object)null)
			{
				return false;
			}
			DisableSiblingWeaponRenderers(((Component)item).transform, modelRoot);
			if ((int)item.itemState == 1)
			{
				EnsureHeldVisibility(item, modelRoot, "in-place");
				EnsureHeldDebugSphere(modelRoot);
			}
			else
			{
				CleanupHeldDebugSphere(modelRoot);
				int layer = ResolveReferenceLayer(item, modelRoot);
				SetLayerRecursively(modelRoot, layer);
				SyncWeaponColliderState(item, modelRoot);
				LogWorldVisualState(item, modelRoot, "in-place-final", ((Component)item).transform);
			}
			InPlaceSwappedItemIds.Add(((Object)item).GetInstanceID());
			Plugin.LogDiagnosticOnce("ak-inplace-route:" + ((Object)item).GetInstanceID() + ":" + (int)item.itemState, $"Applied in-place weapon visual: {DescribeItemForDiagnostics(item)}, modelRoot={GetTransformPath(modelRoot)}, renderer={GetTransformPath(((Component)preferredRenderer).transform)}, state={(int)item.itemState}");
			return true;
		}

		private static Transform ResolveInPlaceVisualParent(Item item, Transform anchor)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)item != (Object)null)
			{
				return ((Component)item).transform;
			}
			if ((Object)(object)anchor != (Object)null)
			{
				if (!((Object)anchor.parent != (Object)null))
				{
					return anchor;
				}
				return anchor.parent;
			}
			return null;
		}

		private static Transform FindInPlaceVisualRoot(Item item, Transform anchor)
		{
			if ((Object)(object)item != (Object)null)
			{
				Transform[] componentsInChildren = ((Component)item).GetComponentsInChildren<Transform>(true);
				foreach (Transform val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null) && string.Equals(((Object)val).name, "AK_InPlaceVisualRoot", StringComparison.Ordinal))
					{
						return val;
					}
				}
			}
			if ((Object)(object)anchor == (Object)null)
			{
				return null;
			}
			return anchor.Find("AK_InPlaceVisualRoot");
		}

		private static void ApplyConfiguredInPlaceRootPose(Transform visualRoot)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)visualRoot == (Object)null))
			{
				visualRoot.localPosition = GetDirectAkPositionOverride();
				visualRoot.localRotation = GetDirectAkRotationOverride();
				visualRoot.localScale = Vector3.one;
			}
		}

		private static void SyncInPlaceVisualRootToAnchor(Transform visualRoot, Transform stableParent, Transform anchor)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0029: Expected O, but got Unknown
			//IL_004d: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)visualRoot == (Object)null))
			{
				if ((Object)(object)stableParent != (Object)null && (Object)visualRoot.parent != (Object)stableParent)
				{
					visualRoot.SetParent(stableParent, false);
				}
				if ((Object)(object)stableParent == (Object)null || (Object)(object)anchor == (Object)null)
				{
					ApplyConfiguredInPlaceRootPose(visualRoot);
					return;
				}
				DecomposeMatrix(stableParent.worldToLocalMatrix * anchor.localToWorldMatrix * Matrix4x4.TRS(GetDirectAkPositionOverride(), GetDirectAkRotationOverride(), Vector3.one), out var position, out var rotation, out var scale);
				visualRoot.localPosition = SanitizeLocalPosition(position, Vector3.zero);
				visualRoot.localRotation = SanitizeLocalRotation(rotation);
				visualRoot.localScale = SanitizeLocalScale(scale, Vector3.one);
			}
		}

		private static bool TryCreateOrRefreshInPlaceVisualRoot(Item item, Transform anchor, bool forceRefreshMarker, out Transform modelRoot, out Renderer preferredRenderer)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_0198: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected I4, but got Unknown
			modelRoot = null;
			preferredRenderer = null;
			if ((Object)(object)item == (Object)null || (Object)(object)anchor == (Object)null || !HasReplacementVisualSource(item))
			{
				return false;
			}
			GameObject akVisualPrefab = Plugin.GetAkVisualPrefab();
			if ((Object)(object)akVisualPrefab == (Object)null)
			{
				return false;
			}
			Transform val = ResolveInPlaceVisualParent(item, anchor);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Transform val2 = FindInPlaceVisualRoot(item, anchor);
			bool flag = forceRefreshMarker;
			if ((Object)(object)val2 != (Object)null && CountMeshBackedRenderers(val2) == 0)
			{
				Object.Destroy((Object)((Component)val2).gameObject);
				val2 = null;
				flag = true;
			}
			if (flag && (Object)(object)val2 != (Object)null)
			{
				Object.Destroy((Object)((Component)val2).gameObject);
				val2 = null;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				GameObject val3 = Object.Instantiate<GameObject>(akVisualPrefab);
				if ((Object)(object)val3 == (Object)null)
				{
					return false;
				}
				val3.transform.SetParent(val, false);
				val3.SetActive(true);
				((Object)val3).name = "AK_InPlaceVisualRoot";
				StripNonVisualComponents(val3);
				PrepareRenderers(val3, anchor);
				val2 = val3.transform;
				Plugin.LogDiagnosticOnce("ak-inplace-create:" + ((Object)item).GetInstanceID() + ":" + (int)item.itemState, "Created in-place visual root: " + DescribeItemForDiagnostics(item) + ", anchor=" + GetTransformPath(anchor) + ", parent=" + GetTransformPath(val) + ", root=" + GetTransformPath(val2) + ", prefab=" + Plugin.DescribeAkVisualPrefabForDiagnostics());
			}
			else if ((Object)val2.parent != (Object)val)
			{
				val2.SetParent(val, false);
			}
			SetHierarchyActive(val2, active: true);
			SyncInPlaceVisualRootToAnchor(val2, val, anchor);
			NormalizeVisualScaleAgainstReference(val2, anchor, "in-place-root");
			ApplyConfiguredWorldVisualScale(val2, Plugin.GetWeaponSelectionForItem(item));
			SetLayerRecursively(val2, ((Component)val).gameObject.layer);
			SetHierarchyActive(val2, active: true);
			EnsureVisualRenderersActive(val2, visible: true);
			preferredRenderer = SelectPreferredRenderer(((Component)val2).GetComponentsInChildren<Renderer>(true), val2);
			if ((Object)(object)preferredRenderer == (Object)null)
			{
				return false;
			}
			EnsureMuzzleMarkerForItem(item, preferredRenderer);
			modelRoot = val2;
			return true;
		}

		private static bool TryReplaceMeshOnExistingAnchor(Item item, Transform targetVisualRoot, bool forceRefreshMarker, out Transform modelRoot, out Renderer preferredRenderer)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected I4, but got Unknown
			modelRoot = targetVisualRoot;
			preferredRenderer = null;
			if ((Object)(object)item == (Object)null || !HasReplacementVisualSource(item))
			{
				return false;
			}
			if (!TryResolveTargetMeshAnchor(item, targetVisualRoot, out var anchor, out var meshFilter, out var meshRenderer))
			{
				return false;
			}
			if ((Object)(object)anchor == (Object)null || (Object)(object)meshFilter == (Object)null || (Object)(object)meshRenderer == (Object)null)
			{
				return false;
			}
			AkInPlaceMarker akInPlaceMarker = ((Component)anchor).GetComponent<AkInPlaceMarker>();
			if ((Object)(object)akInPlaceMarker == (Object)null)
			{
				akInPlaceMarker = ((Component)anchor).gameObject.AddComponent<AkInPlaceMarker>();
			}
			if (!akInPlaceMarker.hasBaseTransform)
			{
				akInPlaceMarker.baseLocalPosition = anchor.localPosition;
				akInPlaceMarker.baseLocalRotation = anchor.localRotation;
				akInPlaceMarker.baseLocalScale = anchor.localScale;
				akInPlaceMarker.hasBaseTransform = true;
				akInPlaceMarker.hasBaseRotation = true;
			}
			if (!akInPlaceMarker.hasOriginalVisual)
			{
				akInPlaceMarker.originalMesh = meshFilter.sharedMesh;
				akInPlaceMarker.originalMaterials = (((Renderer)meshRenderer).sharedMaterials ?? Array.Empty<Material>()).ToArray();
				akInPlaceMarker.hasOriginalVisual = true;
			}
			anchor.localPosition = akInPlaceMarker.baseLocalPosition;
			anchor.localRotation = akInPlaceMarker.baseLocalRotation;
			anchor.localScale = akInPlaceMarker.baseLocalScale;
			((Component)anchor).gameObject.SetActive(true);
			if (!TryCreateOrRefreshInPlaceVisualRoot(item, anchor, forceRefreshMarker, out modelRoot, out preferredRenderer))
			{
				return false;
			}
			Plugin.LogDiagnosticOnce("ak-inplace-swap:" + ((Object)item).GetInstanceID() + ":" + (int)item.itemState, "Applied in-place hierarchy visual: " + DescribeItemForDiagnostics(item) + ", anchor=" + GetTransformPath(anchor) + ", root=" + GetTransformPath(modelRoot) + ", preferred=" + GetTransformPath(((Component)preferredRenderer).transform) + ", rootBounds=" + DescribeBoundsForDiagnostics(modelRoot));
			return true;
		}

		private static bool TryResolveTargetMeshAnchor(Item item, Transform targetVisualRoot, out Transform anchor, out MeshFilter meshFilter, out MeshRenderer meshRenderer)
		{
			anchor = targetVisualRoot;
			meshFilter = null;
			meshRenderer = null;
			if (TryResolveExactBlowgunAnchor(item, targetVisualRoot, out anchor, out meshFilter, out meshRenderer))
			{
				return true;
			}
			int bestScore = int.MinValue;
			HashSet<int> visited = new HashSet<int>();
			EvaluateTargetRendererCandidate(item?.mainRenderer, ref anchor, ref meshFilter, ref meshRenderer, ref bestScore, visited, 25000);
			if ((Object)(object)targetVisualRoot != (Object)null)
			{
				EvaluateTargetMeshCandidate(((Component)targetVisualRoot).GetComponent<MeshFilter>(), ref anchor, ref meshFilter, ref meshRenderer, ref bestScore, visited);
				MeshFilter[] componentsInChildren = ((Component)targetVisualRoot).GetComponentsInChildren<MeshFilter>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					EvaluateTargetMeshCandidate(componentsInChildren[i], ref anchor, ref meshFilter, ref meshRenderer, ref bestScore, visited);
				}
			}
			if ((Object)(object)item != (Object)null)
			{
				MeshFilter[] componentsInChildren2 = ((Component)item).GetComponentsInChildren<MeshFilter>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					EvaluateTargetMeshCandidate(componentsInChildren2[j], ref anchor, ref meshFilter, ref meshRenderer, ref bestScore, visited);
				}
			}
			if ((Object)(object)meshFilter != (Object)null)
			{
				return (Object)(object)meshRenderer != (Object)null;
			}
			return false;
		}

		private static bool TryResolveExactBlowgunAnchor(Item item, Transform targetVisualRoot, out Transform anchor, out MeshFilter meshFilter, out MeshRenderer meshRenderer)
		{
			anchor = null;
			meshFilter = null;
			meshRenderer = null;
			Transform val = (((Object)(object)item != (Object)null) ? ((Component)item).transform.Find("Blowgun") : null);
			if ((Object)(object)val == (Object)null)
			{
				val = targetVisualRoot;
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			meshFilter = ((Component)val).GetComponent<MeshFilter>();
			meshRenderer = ((Component)val).GetComponent<MeshRenderer>();
			if ((Object)(object)meshFilter == (Object)null || (Object)(object)meshRenderer == (Object)null)
			{
				Transform val2 = val.Find("Mesh");
				if ((Object)(object)val2 != (Object)null)
				{
					meshFilter = ((Component)val2).GetComponent<MeshFilter>();
					meshRenderer = ((Component)val2).GetComponent<MeshRenderer>();
					if ((Object)(object)meshFilter != (Object)null && (Object)(object)meshRenderer != (Object)null)
					{
						val = val2;
					}
				}
			}
			if ((Object)(object)meshFilter == (Object)null || (Object)(object)meshRenderer == (Object)null || ShouldSkipTargetTransform(val))
			{
				return false;
			}
			anchor = val;
			return true;
		}

		private static void EvaluateTargetRendererCandidate(Renderer candidateRenderer, ref Transform anchor, ref MeshFilter meshFilter, ref MeshRenderer meshRenderer, ref int bestScore, HashSet<int> visited, int scoreBonus)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			MeshRenderer val = (MeshRenderer)((candidateRenderer is MeshRenderer) ? candidateRenderer : null);
			if (!((Object)(object)val == (Object)null))
			{
				EvaluateTargetMeshCandidate(((Component)val).GetComponent<MeshFilter>(), ref anchor, ref meshFilter, ref meshRenderer, ref bestScore, visited, scoreBonus);
			}
		}

		private static void EvaluateTargetMeshCandidate(MeshFilter candidate, ref Transform anchor, ref MeshFilter meshFilter, ref MeshRenderer meshRenderer, ref int bestScore, HashSet<int> visited, int scoreBonus = 0)
		{
			if ((Object)(object)candidate == (Object)null || (Object)(object)candidate.sharedMesh == (Object)null || (visited != null && !visited.Add(((Object)candidate).GetInstanceID())))
			{
				return;
			}
			MeshRenderer component = ((Component)candidate).GetComponent<MeshRenderer>();
			if (!((Object)(object)component == (Object)null) && !ShouldSkipTargetTransform(((Component)candidate).transform))
			{
				string text = ((((Object)candidate.sharedMesh).name ?? string.Empty) + "/" + (((Object)((Component)candidate).transform).name ?? string.Empty)).ToLowerInvariant();
				int num = candidate.sharedMesh.vertexCount;
				if (text.Contains("blowgun") || text.Contains("healing") || text.Contains("dart") || text.Contains("weapon"))
				{
					num += 900;
				}
				string text2 = GetTransformPath(((Component)candidate).transform).ToLowerInvariant();
				if (text2.Contains("/blowgun"))
				{
					num += 12000;
				}
				if (text2.EndsWith("/blowgun"))
				{
					num += 8000;
				}
				if (text.Contains("mesh") || text.Contains("body"))
				{
					num += 400;
				}
				if (text.Contains("vfx") || text.Contains("effect") || text.Contains("spawn") || text.Contains("trigger") || text.Contains("collider"))
				{
					num -= 12000;
				}
				if (text.Contains("cube") && candidate.sharedMesh.vertexCount <= 200)
				{
					num -= 6000;
				}
				if (((Renderer)component).enabled)
				{
					num += 250;
				}
				num += scoreBonus;
				if (num > bestScore)
				{
					bestScore = num;
					anchor = ((Component)candidate).transform;
					meshFilter = candidate;
					meshRenderer = component;
				}
			}
		}

		private static bool ShouldSkipTargetTransform(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return true;
			}
			string text = (((Object)transform).name ?? string.Empty).ToLowerInvariant();
			if (text.Contains("hand") || text.Contains("arm") || text.Contains("finger"))
			{
				return true;
			}
			if (text.Contains("vfx") || text.Contains("effect") || text.Contains("spawn") || text.Contains("trigger") || text.Contains("collider"))
			{
				return true;
			}
			return false;
		}

		private static bool TryGetBestSourceVisual(out SourceVisualCandidate best)
		{
			best = default(SourceVisualCandidate);
			GameObject akVisualPrefab = Plugin.GetAkVisualPrefab();
			if ((Object)(object)akVisualPrefab == (Object)null)
			{
				return false;
			}
			bool flag = false;
			int num = int.MinValue;
			bool flag2 = false;
			int num2 = int.MinValue;
			SourceVisualCandidate sourceVisualCandidate = default(SourceVisualCandidate);
			MeshFilter[] componentsInChildren = akVisualPrefab.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.sharedMesh == (Object)null)
				{
					continue;
				}
				MeshRenderer component = ((Component)val).GetComponent<MeshRenderer>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				SourceVisualCandidate? sourceVisualCandidate2 = BuildSourceVisualCandidate(((Component)val).transform, val.sharedMesh, ((Renderer)component).sharedMaterials, isSkinnedRenderer: false);
				if (sourceVisualCandidate2.HasValue)
				{
					SourceVisualCandidate value = sourceVisualCandidate2.Value;
					if (value.Score > num)
					{
						num = value.Score;
						best = value;
						flag = true;
					}
					if (!IsLikelyPlaceholderSource(value) && value.Score > num2)
					{
						num2 = value.Score;
						sourceVisualCandidate = value;
						flag2 = true;
					}
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = akVisualPrefab.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2.sharedMesh == (Object)null)
				{
					continue;
				}
				SourceVisualCandidate? sourceVisualCandidate3 = BuildSourceVisualCandidate(((Component)val2).transform, val2.sharedMesh, ((Renderer)val2).sharedMaterials, isSkinnedRenderer: true);
				if (sourceVisualCandidate3.HasValue)
				{
					SourceVisualCandidate value2 = sourceVisualCandidate3.Value;
					if (value2.Score > num)
					{
						num = value2.Score;
						best = value2;
						flag = true;
					}
					if (!IsLikelyPlaceholderSource(value2) && value2.Score > num2)
					{
						num2 = value2.Score;
						sourceVisualCandidate = value2;
						flag2 = true;
					}
				}
			}
			if (flag && flag2 && IsLikelyPlaceholderSource(best) && sourceVisualCandidate.VertexCount > 64 && (sourceVisualCandidate.Score >= best.Score - 10000 || best.VertexCount <= 2000))
			{
				best = sourceVisualCandidate;
			}
			return flag;
		}

		private static SourceVisualCandidate? BuildSourceVisualCandidate(Transform sourceTransform, Mesh mesh, Material[] materials, bool isSkinnedRenderer)
		{
			if ((Object)(object)sourceTransform == (Object)null || (Object)(object)mesh == (Object)null)
			{
				return null;
			}
			int vertexCount = mesh.vertexCount;
			int num = vertexCount;
			string text = (((Object)mesh).name ?? string.Empty).ToLowerInvariant();
			string text2 = (((Object)sourceTransform).name ?? string.Empty).ToLowerInvariant();
			Material[] array = NormalizeMaterialArray(materials, Math.Max(mesh.subMeshCount, 1));
			if (materials == null || materials.Length == 0)
			{
				num -= 2000;
			}
			num = ((!HasUsableTexture(array)) ? (num - 12000) : (num + 1800));
			if (vertexCount <= 24)
			{
				num -= 6000;
			}
			if (text.Contains("cube") || text2.Contains("cube"))
			{
				num -= 12000;
			}
			if (text.Contains("plane") || text2.Contains("plane") || text.Contains("quad") || text2.Contains("quad"))
			{
				num -= 8000;
			}
			if (text2.Contains("vfx") || text2.Contains("effect") || text2.Contains("spawn"))
			{
				num -= 5000;
			}
			if (text.Contains("hand") || text2.Contains("hand") || text.Contains("arm") || text2.Contains("arm") || text.Contains("finger") || text2.Contains("finger"))
			{
				num -= 18000;
			}
			if (isSkinnedRenderer)
			{
				num -= 3000;
			}
			if (text.Contains("ak") || text2.Contains("ak") || text.Contains("weapon") || text2.Contains("weapon") || text.Contains("rifle") || text2.Contains("rifle") || text2.Contains("gun"))
			{
				num += 2500;
			}
			if (text == "mesh" || text2 == "mesh")
			{
				num += 5000;
			}
			SourceVisualCandidate value = default(SourceVisualCandidate);
			value.Mesh = mesh;
			value.Materials = ((array != null) ? array : Array.Empty<Material>());
			value.Transform = sourceTransform;
			value.VertexCount = vertexCount;
			value.Score = num;
			value.Path = GetTransformPath(sourceTransform);
			value.MeshName = ((Object)mesh).name;
			return value;
		}

		private static bool IsLikelyPlaceholderSource(SourceVisualCandidate candidate)
		{
			string text = (candidate.MeshName ?? string.Empty).ToLowerInvariant();
			string text2 = (candidate.Path ?? string.Empty).ToLowerInvariant();
			if ((text.Contains("cube") || text2.Contains("/cube")) && candidate.VertexCount <= 3000)
			{
				return true;
			}
			if ((text.Contains("plane") || text.Contains("quad") || text2.Contains("/plane") || text2.Contains("/quad")) && candidate.VertexCount <= 3000)
			{
				return true;
			}
			return false;
		}

		private static void DisableSiblingWeaponRenderers(Transform targetVisualRoot, Transform preservedAnchor)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0042: Expected O, but got Unknown
			if ((Object)(object)targetVisualRoot == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)targetVisualRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && (!((Object)(object)preservedAnchor != (Object)null) || (!((Object)((Component)val).transform == (Object)preservedAnchor) && !((Component)val).transform.IsChildOf(preservedAnchor))) && IsOriginalWeaponRenderer(val, targetVisualRoot))
				{
					val.enabled = false;
					val.forceRenderingOff = true;
				}
			}
		}

		private static void EnsureHeldVisibility(Item item, Transform modelRoot, string source, bool preserveExistingLayer = false)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null || (int)item.itemState != 1)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
			if ((Object)(object)modelRoot != (Object)null)
			{
				SetItemNonHandRenderersEnabled(item, enabled: false, modelRoot);
				EnsureVisualRenderersActive(modelRoot, visible: true);
			}
			List<MeshRenderer> list = new List<MeshRenderer>();
			List<SkinnedMeshRenderer> list2 = new List<SkinnedMeshRenderer>();
			int num = 0;
			int num2 = 0;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				bool flag = IsHandItemRenderer(val);
				if (((Object)(object)modelRoot != (Object)null && ((Object)(object)((Component)val).transform == (Object)(object)modelRoot || ((Component)val).transform.IsChildOf(modelRoot))) || flag)
				{
					val.enabled = true;
					val.forceRenderingOff = false;
					val.allowOcclusionWhenDynamic = false;
					SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.updateWhenOffscreen = true;
						list2.Add(val2);
					}
					else
					{
						MeshRenderer val3 = (MeshRenderer)((val is MeshRenderer) ? val : null);
						if ((Object)(object)val3 != (Object)null)
						{
							list.Add(val3);
						}
					}
					num++;
				}
				else
				{
					val.enabled = false;
					val.forceRenderingOff = true;
					val.allowOcclusionWhenDynamic = false;
					num2++;
				}
			}
			if (list.Count == 0 && list2.Count == 0)
			{
				list = (from r in ((Component)item).GetComponentsInChildren<MeshRenderer>(true)
					where (Object)(object)r != (Object)null
					select r).ToList();
				list2 = (from r in ((Component)item).GetComponentsInChildren<SkinnedMeshRenderer>(true)
					where (Object)(object)r != (Object)null
					select r).ToList();
				foreach (Renderer item2 in list.Cast<Renderer>().Concat((IEnumerable<Renderer>)list2))
				{
					item2.enabled = true;
					item2.forceRenderingOff = false;
					item2.allowOcclusionWhenDynamic = false;
				}
			}
			Renderer val4 = SelectPreferredRenderer(list.Cast<Renderer>().Concat((IEnumerable<Renderer>)list2), modelRoot);
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = list.Cast<Renderer>().FirstOrDefault() ?? list2.Cast<Renderer>().FirstOrDefault();
			}
			if ((Object)(object)val4 == (Object)null)
			{
				return;
			}
			MeshRenderer val5 = (MeshRenderer)((val4 is MeshRenderer) ? val4 : null);
			if ((Object)(object)val5 != (Object)null)
			{
				list.Remove(val5);
				list.Insert(0, val5);
			}
			else
			{
				SkinnedMeshRenderer val6 = (SkinnedMeshRenderer)((val4 is SkinnedMeshRenderer) ? val4 : null);
				if ((Object)(object)val6 != (Object)null)
				{
					list2.Remove(val6);
					list2.Insert(0, val6);
				}
			}
			if ((Object)(object)modelRoot != (Object)null && !preserveExistingLayer)
			{
				int layer = ResolveReferenceLayer(item, modelRoot);
				if (IsLocallyHeldByPlayer(item))
				{
					layer = ResolveBestVisibleLayerForLocalHeldItem(item, modelRoot);
				}
				SetLayerRecursively(modelRoot, layer);
			}
			Plugin.LogDiagnosticOnce("ak-held-visibility:" + ((Object)item).GetInstanceID() + ":" + source, $"EnsureHeldVisibility applied: {DescribeItemForDiagnostics(item)}, source={source}, modelRoot={GetTransformPath(modelRoot)}, enabledCount={num}, disabledCount={num2}, preferred={GetTransformPath(((Component)val4).transform)}, modelBounds={DescribeBoundsForDiagnostics(modelRoot)}");
			BindItemRendererFields(item, list.ToArray(), list2.ToArray());
			EnsureMuzzleMarkerForItem(item, val4);
		}

		private static void BindInPlaceRendererFields(Item item, MeshRenderer preferredRenderer, Transform modelRoot)
		{
			if (!((Object)(object)item == (Object)null) && !((Object)(object)preferredRenderer == (Object)null))
			{
				List<MeshRenderer> list = (from r in ((Component)item).GetComponentsInChildren<MeshRenderer>(true)
					where (Object)(object)r != (Object)null && (((Renderer)r).enabled || (Object)(object)r == (Object)(object)preferredRenderer || IsHandItemRenderer((Renderer)r) || ((Object)(object)modelRoot != (Object)null && ((Component)r).transform.IsChildOf(modelRoot)))
					select r).ToList();
				List<SkinnedMeshRenderer> list2 = (from r in ((Component)item).GetComponentsInChildren<SkinnedMeshRenderer>(true)
					where (Object)(object)r != (Object)null && (((Renderer)r).enabled || IsHandItemRenderer((Renderer)r) || ((Object)(object)modelRoot != (Object)null && ((Component)r).transform.IsChildOf(modelRoot)))
					select r).ToList();
				list.Remove(preferredRenderer);
				list.Insert(0, preferredRenderer);
				BindItemRendererFields(item, list.ToArray(), list2.ToArray());
			}
		}

		private static void EnsureLegacyHeldVisual(Item item, bool forceRefreshMarker, bool allowWhenSeparateLocalVisual = false)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			if (ShouldUseSeparateLocalFirstPersonVisual(item) && !allowWhenSeparateLocalVisual)
			{
				DestroyLegacyHeldVisual(item, restoreRenderers: false);
				return;
			}
			if (!IsLocallyHeldByPlayer(item))
			{
				DestroyLegacyHeldVisual(item, restoreRenderers: true);
				return;
			}
			AkHeldLegacyVisualMarker akHeldLegacyVisualMarker = ((Component)item).GetComponentInChildren<AkHeldLegacyVisualMarker>(true);
			if (forceRefreshMarker || (Object)(object)akHeldLegacyVisualMarker == (Object)null)
			{
				DestroyLegacyHeldVisual(item, restoreRenderers: false);
				akHeldLegacyVisualMarker = CreateLegacyHeldVisual(item);
			}
			if (!((Object)(object)akHeldLegacyVisualMarker == (Object)null))
			{
				Transform transform = ((Component)akHeldLegacyVisualMarker).transform;
				EnsureLegacyHeldRenderersEnabled(transform);
				Renderer legacyHeldPreferredRenderer = GetLegacyHeldPreferredRenderer(transform);
				if (!((Object)(object)legacyHeldPreferredRenderer == (Object)null))
				{
					int num = ResolveReferenceLayer(item, transform);
					num = ResolveBestVisibleLayerForLocalHeldItem(item, transform);
					SetLayerRecursively(transform, num);
					SetItemNonHandRenderersEnabled(item, enabled: false, transform);
					SyncWeaponColliderState(item, null);
					BindLegacyHeldRendererFields(item, legacyHeldPreferredRenderer, transform);
					EnsureMuzzleMarkerForItem(item, legacyHeldPreferredRenderer);
					EnsureHeldDebugSphere(transform);
					LogHeldVisualCameraState(item, transform, "ensure");
				}
			}
		}

		private static AkHeldLegacyVisualMarker CreateLegacyHeldVisual(Item item)
		{
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			Transform val = ResolveHeldLegacyParent(item);
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)item).transform;
			}
			Transform val2 = CreatePreparedAkClone(val, val, "AK47_HeldLegacyModel");
			if ((Object)(object)val2 != (Object)null)
			{
				ApplyPreparedLegacyHeldClonePose(val2);
				((Component)val2).gameObject.SetActive(true);
				EnsureVisualRenderersActive(val2, visible: true);
				AkHeldLegacyVisualMarker akHeldLegacyVisualMarker = ((Component)val2).GetComponent<AkHeldLegacyVisualMarker>();
				if ((Object)(object)akHeldLegacyVisualMarker == (Object)null)
				{
					akHeldLegacyVisualMarker = ((Component)val2).gameObject.AddComponent<AkHeldLegacyVisualMarker>();
				}
				Plugin.LogDiagnosticOnce("ak-held-legacy-create:" + ((Object)item).GetInstanceID(), "Created held legacy visual from prepared clone: " + DescribeItemForDiagnostics(item) + ", parent=" + GetTransformPath(val) + ", visual=" + GetTransformPath(val2) + ", bounds=" + DescribeBoundsForDiagnostics(val2) + ", renderers=" + DescribeRendererCollectionForDiagnostics(((Component)val2).GetComponentsInChildren<Renderer>(true)));
				LogHeldVisualCameraState(item, val2, "create");
				return akHeldLegacyVisualMarker;
			}
			Transform val3 = ResolveHeldLegacyParent(item);
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ResolveTargetVisualRoot(item);
			}
			AkHeldLegacyVisualMarker akHeldLegacyVisualMarker2 = CreateAnchoredLegacyHeldVisual(item, val3);
			if ((Object)(object)akHeldLegacyVisualMarker2 != (Object)null)
			{
				Plugin.LogDiagnosticOnce("ak-held-legacy-create:" + ((Object)item).GetInstanceID(), "Created held legacy visual from anchored fallback: " + DescribeItemForDiagnostics(item) + ", visual=" + GetTransformPath(((Component)akHeldLegacyVisualMarker2).transform) + ", bounds=" + DescribeBoundsForDiagnostics(((Component)akHeldLegacyVisualMarker2).transform));
				LogHeldVisualCameraState(item, ((Component)akHeldLegacyVisualMarker2).transform, "fallback");
				return akHeldLegacyVisualMarker2;
			}
			if (!TryResolveLegacyHeldSource(out var mesh, out var materials, out var localScale, out var localRotation, out var localPosition, out var _))
			{
				return null;
			}
			Transform val4 = ResolveHeldLegacyParent(item);
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = ((Component)item).transform;
			}
			GameObject val5 = new GameObject("AK47_HeldLegacyModel");
			val5.transform.SetParent(val4, false);
			val5.transform.localScale = localScale;
			val5.transform.localRotation = localRotation;
			val5.transform.localPosition = localPosition;
			AkHeldLegacyVisualMarker result = val5.AddComponent<AkHeldLegacyVisualMarker>();
			MeshFilter val6 = val5.AddComponent<MeshFilter>();
			MeshRenderer obj = val5.AddComponent<MeshRenderer>();
			val6.sharedMesh = mesh;
			((Renderer)obj).sharedMaterials = BuildAkVisibleMaterials(materials, Mathf.Max(mesh.subMeshCount, 1));
			NormalizeAkRenderer((Renderer)obj);
			Plugin.LogDiagnosticOnce("ak-held-legacy-create:" + ((Object)item).GetInstanceID(), $"Created held legacy visual from mesh fallback: {DescribeItemForDiagnostics(item)}, parent={GetTransformPath(val4)}, visual={GetTransformPath(val5.transform)}, pos={localPosition}, rot={((Quaternion)(ref localRotation)).eulerAngles}, scale={localScale}");
			LogHeldVisualCameraState(item, val5.transform, "mesh-fallback");
			return result;
		}

		private static void ApplyPreparedLegacyHeldClonePose(Transform legacyRoot)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)legacyRoot == (Object)null))
			{
				Vector3 localPosition = legacyRoot.localPosition;
				Quaternion localRotation = legacyRoot.localRotation;
				Vector3 localScale = legacyRoot.localScale;
				if (TryResolveHeldPoseRelativeToBase(out var localPosition2, out var localRotation2, out var localScale2))
				{
					legacyRoot.localPosition = SanitizeLocalPosition(localPosition + localPosition2, localPosition);
					legacyRoot.localRotation = SanitizeLocalRotation(localRotation * localRotation2);
					legacyRoot.localScale = SanitizeLocalScale(Vector3.Scale(localScale, localScale2), localScale);
					string key = "ak-held-legacy-pose:" + GetTransformPath(legacyRoot);
					object[] obj = new object[10]
					{
						GetTransformPath(legacyRoot),
						localPosition,
						((Quaternion)(ref localRotation)).eulerAngles,
						localScale,
						localPosition2,
						((Quaternion)(ref localRotation2)).eulerAngles,
						localScale2,
						legacyRoot.localPosition,
						null,
						null
					};
					Quaternion localRotation3 = legacyRoot.localRotation;
					obj[8] = ((Quaternion)(ref localRotation3)).eulerAngles;
					obj[9] = legacyRoot.localScale;
					Plugin.LogDiagnosticOnce(key, string.Format("Applied prepared held pose delta: root={0}, basePos={1}, baseRot={2}, baseScale={3}, deltaPos={4}, deltaRot={5}, deltaScale={6}, finalPos={7}, finalRot={8}, finalScale={9}", obj));
				}
				else
				{
					Plugin.LogDiagnosticOnce("ak-held-legacy-pose:" + GetTransformPath(legacyRoot), $"Held pose delta unavailable, keeping prepared clone pose: root={GetTransformPath(legacyRoot)}, pos={localPosition}, rot={((Quaternion)(ref localRotation)).eulerAngles}, scale={localScale}");
				}
			}
		}

		private static AkHeldLegacyVisualMarker CreateAnchoredLegacyHeldVisual(Item item, Transform targetVisualRoot)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_009e: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			if (!TryResolveBaseAkVisual(out var mesh, out var materials, out var _, out var _, out var _, out var _) || (Object)(object)mesh == (Object)null)
			{
				return null;
			}
			if (!TryResolveTargetMeshAnchor(item, targetVisualRoot, out var anchor, out var _, out var meshRenderer) || (Object)(object)anchor == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("AK47_HeldLegacyModel");
			val.transform.SetParent(anchor, false);
			if (TryResolveHeldPoseRelativeToBase(out var localPosition2, out var localRotation2, out var localScale2))
			{
				val.transform.localPosition = localPosition2;
				val.transform.localRotation = localRotation2;
				val.transform.localScale = localScale2;
			}
			else
			{
				val.transform.localPosition = GetDirectAkPositionOverride();
				val.transform.localRotation = HeldLegacyRotationOffset;
				val.transform.localScale = Vector3.one * Mathf.Max(1f, GetDirectAkScaleMultiplier(Plugin.GetWeaponSelectionForItem(item)));
			}
			AkHeldLegacyVisualMarker result = val.AddComponent<AkHeldLegacyVisualMarker>();
			MeshFilter val2 = val.AddComponent<MeshFilter>();
			MeshRenderer obj = val.AddComponent<MeshRenderer>();
			val2.sharedMesh = mesh;
			((Renderer)obj).sharedMaterials = BuildVisibleMaterials(materials, ((Object)(object)meshRenderer != (Object)null) ? ((Renderer)meshRenderer).sharedMaterials : null, Mathf.Max(mesh.subMeshCount, 1));
			NormalizeAkRenderer((Renderer)obj);
			SetLayerRecursively(val.transform, ((Component)anchor).gameObject.layer);
			return result;
		}

		private static void ApplyLegacyHeldFallbackPose(Transform legacyRoot)
		{
			//IL_001d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)legacyRoot == (Object)null) && TryResolvePreferredAkVisual(out var _, out var _, out var localScale, out var localRotation, out var localPosition, out var _))
			{
				legacyRoot.localPosition = localPosition;
				legacyRoot.localRotation = localRotation;
				legacyRoot.localScale = localScale;
			}
		}

		private static bool TryResolveLegacyHeldSource(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition, out string debugInfo)
		{
			return TryResolvePreferredAkVisual(out mesh, out materials, out localScale, out localRotation, out localPosition, out debugInfo);
		}

		private static Renderer GetLegacyHeldPreferredRenderer(Transform legacyRoot)
		{
			if ((Object)(object)legacyRoot == (Object)null)
			{
				return null;
			}
			Renderer[] componentsInChildren = ((Component)legacyRoot).GetComponentsInChildren<Renderer>(true);
			return SelectPreferredRenderer(componentsInChildren, legacyRoot) ?? ((IEnumerable<Renderer>)componentsInChildren).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => IsMeshBackedRenderer(r)));
		}

		private static void EnsureLegacyHeldRenderersEnabled(Transform legacyRoot)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			if ((Object)(object)legacyRoot == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)legacyRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				bool flag2 = (val.enabled = IsMeshBackedRenderer(val));
				bool flag3 = flag2;
				val.forceRenderingOff = !flag3;
				ConfigureRuntimeWeaponRenderer(val);
				if (flag3)
				{
					SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.updateWhenOffscreen = true;
					}
					NormalizeRendererMaterials(val);
				}
			}
		}

		private static void BindLegacyHeldRendererFields(Item item, Renderer legacyRenderer, Transform legacyRoot)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null || (Object)(object)legacyRenderer == (Object)null)
			{
				return;
			}
			List<MeshRenderer> list = (from r in ((Component)item).GetComponentsInChildren<MeshRenderer>(true)
				where (Object)(object)r != (Object)null && (((Renderer)r).enabled || (Object)(object)r == (Object)(object)legacyRenderer || IsHandItemRenderer((Renderer)r) || ((Object)(object)legacyRoot != (Object)null && ((Component)r).transform.IsChildOf(legacyRoot)))
				select r).ToList();
			List<SkinnedMeshRenderer> list2 = (from r in ((Component)item).GetComponentsInChildren<SkinnedMeshRenderer>(true)
				where (Object)(object)r != (Object)null && (((Renderer)r).enabled || (Object)(object)r == (Object)(object)legacyRenderer || IsHandItemRenderer((Renderer)r) || ((Object)(object)legacyRoot != (Object)null && ((Component)r).transform.IsChildOf(legacyRoot)))
				select r).ToList();
			Renderer val = legacyRenderer;
			MeshRenderer val2 = (MeshRenderer)((val is MeshRenderer) ? val : null);
			if ((Object)(object)val2 != (Object)null)
			{
				list.Remove(val2);
				list.Insert(0, val2);
			}
			else
			{
				Renderer val3 = legacyRenderer;
				SkinnedMeshRenderer val4 = (SkinnedMeshRenderer)((val3 is SkinnedMeshRenderer) ? val3 : null);
				if ((Object)(object)val4 != (Object)null)
				{
					list2.Remove(val4);
					list2.Insert(0, val4);
				}
			}
			BindItemRendererFields(item, list.ToArray(), list2.ToArray());
		}

		private static void BindSimpleVisualRendererFields(Item item, Transform modelRoot)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null || (Object)(object)modelRoot == (Object)null)
			{
				return;
			}
			List<MeshRenderer> list = (from r in ((Component)item).GetComponentsInChildren<MeshRenderer>(true)
				where (Object)(object)r != (Object)null && (((Renderer)r).enabled || IsHandItemRenderer((Renderer)r) || ((Component)r).transform.IsChildOf(modelRoot))
				select r).ToList();
			List<SkinnedMeshRenderer> list2 = (from r in ((Component)item).GetComponentsInChildren<SkinnedMeshRenderer>(true)
				where (Object)(object)r != (Object)null && (((Renderer)r).enabled || IsHandItemRenderer((Renderer)r) || ((Component)r).transform.IsChildOf(modelRoot))
				select r).ToList();
			Renderer val = SelectPreferredRenderer(list.Cast<Renderer>().Concat((IEnumerable<Renderer>)list2), modelRoot);
			MeshRenderer val2 = (MeshRenderer)((val is MeshRenderer) ? val : null);
			if ((Object)(object)val2 != (Object)null)
			{
				list.Remove(val2);
				list.Insert(0, val2);
			}
			else
			{
				SkinnedMeshRenderer val3 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
				if ((Object)(object)val3 != (Object)null)
				{
					list2.Remove(val3);
					list2.Insert(0, val3);
				}
			}
			BindItemRendererFields(item, list.ToArray(), list2.ToArray());
		}

		private static void SetItemNonHandRenderersEnabled(Item item, bool enabled, Transform excludedRoot)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && (!((Object)(object)excludedRoot != (Object)null) || !((Component)val).transform.IsChildOf(excludedRoot)) && !IsHandItemRenderer(val))
				{
					val.enabled = enabled;
					val.forceRenderingOff = !enabled;
					val.allowOcclusionWhenDynamic = false;
					SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.updateWhenOffscreen = true;
					}
				}
			}
		}

		private static bool IsHandItemRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			string text = ((((Object)renderer).name ?? string.Empty) + "/" + GetTransformPath(((Component)renderer).transform)).ToLowerInvariant();
			if (!text.Contains("hand") && !text.Contains("arm"))
			{
				return text.Contains("finger");
			}
			return true;
		}

		private static void DestroyLegacyHeldVisual(Item item, bool restoreRenderers)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (!((Object)(object)item == (Object)null))
			{
				AkHeldLegacyVisualMarker componentInChildren = ((Component)item).GetComponentInChildren<AkHeldLegacyVisualMarker>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Object.Destroy((Object)((Component)componentInChildren).gameObject);
				}
				if (restoreRenderers)
				{
					SetItemNonHandRenderersEnabled(item, enabled: true, null);
					SetOriginalItemCollidersEnabled(item, enabled: true);
				}
				CleanupAllWeaponWorldColliders(item);
			}
		}

		private static void BindOriginalItemRendererFields(Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				MeshRenderer[] array = (from r in ((Component)item).GetComponentsInChildren<MeshRenderer>(true)
					where (Object)(object)r != (Object)null && !IsCustomAkRenderer((Renderer)r)
					select r).ToArray();
				SkinnedMeshRenderer[] array2 = (from r in ((Component)item).GetComponentsInChildren<SkinnedMeshRenderer>(true)
					where (Object)(object)r != (Object)null && !IsCustomAkRenderer((Renderer)r)
					select r).ToArray();
				if ((array != null && array.Length != 0) || (array2 != null && array2.Length != 0))
				{
					BindItemRendererFields(item, array, array2);
				}
			}
		}

		private static bool IsCustomAkRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer != (Object)null)
			{
				if (!((Object)(object)((Component)renderer).GetComponentInParent<AkSimpleVisualMarker>(true) != (Object)null) && !((Object)(object)((Component)renderer).GetComponentInParent<AkLocalVisualMarker>(true) != (Object)null))
				{
					if ((Object)(object)((Component)renderer).GetComponentInParent<AkHeldLegacyVisualMarker>(true) != (Object)null)
					{
						return true;
					}
					return HasNamedAncestor(((Component)renderer).transform, "AK_InPlaceVisualRoot");
				}
				return true;
			}
			return false;
		}

		private static bool HasNamedAncestor(Transform transform, string ancestorName)
		{
			while ((Object)(object)transform != (Object)null)
			{
				if (string.Equals(((Object)transform).name, ancestorName, StringComparison.Ordinal))
				{
					return true;
				}
				transform = transform.parent;
			}
			return false;
		}

		private static void EnsureMuzzleMarkerForItem(Item item, Renderer preferredRenderer)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)item == (Object)null))
			{
				Transform val = ((Component)item).transform.Find("AK_MuzzleMarker");
				if ((Object)(object)val == (Object)null)
				{
					GameObject val2 = new GameObject("AK_MuzzleMarker");
					val2.transform.SetParent(((Component)item).transform, false);
					val2.AddComponent<AkMuzzleMarker>();
					val = val2.transform;
				}
				if ((Object)(object)preferredRenderer == (Object)null)
				{
					val.localPosition = Vector3.forward * 0.6f;
					val.localRotation = Quaternion.identity;
				}
				else
				{
					Bounds bounds = preferredRenderer.bounds;
					val.position = ((Bounds)(ref bounds)).center + ((Component)preferredRenderer).transform.forward * Mathf.Max(((Bounds)(ref bounds)).extents.z, 0.06f);
					val.rotation = ((Component)preferredRenderer).transform.rotation;
				}
			}
		}

		private static Material[] BuildVisibleMaterials(Material[] preferredMaterials, Material[] fallbackMaterials, int subMeshCount)
		{
			if (subMeshCount <= 0)
			{
				return Array.Empty<Material>();
			}
			if (preferredMaterials != null && preferredMaterials.Length != 0 && HasUsableTexture(preferredMaterials))
			{
				return BuildDirectAkMaterials(preferredMaterials, subMeshCount);
			}
			Material[] array = preferredMaterials;
			if (array == null || array.Length == 0 || array.All((Material m) => (Object)(object)m == (Object)null))
			{
				array = fallbackMaterials;
			}
			if (array == null || array.Length == 0 || array.All((Material m) => (Object)(object)m == (Object)null))
			{
				Material[] array2 = (Material[])(object)new Material[subMeshCount];
				for (int i = 0; i < subMeshCount; i++)
				{
					array2[i] = CreateRuntimeMaterial(null, null);
					NormalizeMaterialForVisibility(array2[i]);
				}
				return array2;
			}
			Material[] array3 = NormalizeMaterialArray(array, subMeshCount);
			Material[] array4 = (Material[])(object)new Material[subMeshCount];
			Material val = ((IEnumerable<Material>)array3).FirstOrDefault((Func<Material, bool>)((Material m) => (Object)(object)m != (Object)null));
			for (int j = 0; j < subMeshCount; j++)
			{
				Material val2 = ((j < array3.Length) ? array3[j] : null);
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val;
				}
				Material template = ((fallbackMaterials != null && fallbackMaterials.Length != 0) ? fallbackMaterials[Math.Min(j, fallbackMaterials.Length - 1)] : null);
				array4[j] = CreateRuntimeMaterial(val2, template);
				NormalizeMaterialForVisibility(array4[j]);
			}
			return array4;
		}

		private static Material[] NormalizeMaterialArray(Material[] sourceMaterials, int subMeshCount)
		{
			if (sourceMaterials == null || sourceMaterials.Length == 0 || subMeshCount <= 0)
			{
				return sourceMaterials ?? Array.Empty<Material>();
			}
			if (sourceMaterials.Length == subMeshCount)
			{
				return sourceMaterials;
			}
			Material[] array = (Material[])(object)new Material[subMeshCount];
			for (int i = 0; i < subMeshCount; i++)
			{
				array[i] = sourceMaterials[Math.Min(i, sourceMaterials.Length - 1)];
			}
			return array;
		}

		private static void NormalizeMaterialForVisibility(Material material)
		{
			//IL_0195: 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)
			//IL_01aa: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)material == (Object)null)
			{
				return;
			}
			Shader val = ResolvePreferredVisibleShader();
			Texture val2 = ResolvePrimaryTexture(material);
			if ((Object)(object)val2 == (Object)null && material.HasProperty("_BaseMap"))
			{
				val2 = material.GetTexture("_BaseMap");
			}
			if ((Object)(object)val2 == (Object)null && material.HasProperty("_MainTex"))
			{
				val2 = material.GetTexture("_MainTex");
			}
			string text = (((Object)(object)material.shader != (Object)null) ? ((Object)material.shader).name : string.Empty);
			bool flag = (Object)(object)material.shader == (Object)null || !material.shader.isSupported || string.IsNullOrWhiteSpace(text);
			if (!flag && (text.IndexOf("Character", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Skin", StringComparison.OrdinalIgnoreCase) >= 0))
			{
				flag = true;
			}
			if (flag && (Object)(object)val != (Object)null)
			{
				material.shader = val;
				if ((Object)(object)val2 != (Object)null)
				{
					if (material.HasProperty("_BaseMap"))
					{
						material.SetTexture("_BaseMap", val2);
					}
					if (material.HasProperty("_MainTex"))
					{
						material.SetTexture("_MainTex", val2);
					}
				}
			}
			if (material.HasProperty("_Surface"))
			{
				material.SetFloat("_Surface", 0f);
			}
			if (material.HasProperty("_AlphaClip"))
			{
				material.SetFloat("_AlphaClip", 0f);
			}
			if (material.HasProperty("_Cutoff"))
			{
				material.SetFloat("_Cutoff", 0f);
			}
			if (material.HasProperty("_Cull"))
			{
				material.SetInt("_Cull", 0);
			}
			if (material.HasProperty("_BaseColor"))
			{
				Color color = material.GetColor("_BaseColor");
				color.a = 1f;
				color.r = Mathf.Max(color.r, 0.85f);
				color.g = Mathf.Max(color.g, 0.85f);
				color.b = Mathf.Max(color.b, 0.85f);
				material.SetColor("_BaseColor", color);
			}
			if (material.HasProperty("_Color"))
			{
				Color color2 = material.color;
				color2.a = 1f;
				color2.r = Mathf.Max(color2.r, 0.85f);
				color2.g = Mathf.Max(color2.g, 0.85f);
				color2.b = Mathf.Max(color2.b, 0.85f);
				material.color = color2;
			}
			if (material.HasProperty("_EmissionColor"))
			{
				material.EnableKeyword("_EMISSION");
				material.SetColor("_EmissionColor", new Color(0.1f, 0.1f, 0.1f, 1f));
			}
			material.renderQueue = -1;
		}

		private static Shader ResolvePreferredVisibleShader()
		{
			return Shader.Find("Unlit/Texture") ?? Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("W/Peak_Standard") ?? Shader.Find("Standard") ?? Shader.Find("Legacy Shaders/Diffuse") ?? Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Sprites/Default") ?? Shader.Find("Hidden/InternalErrorShader");
		}

		private static void NormalizeRendererMaterials(Renderer renderer)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			if ((Object)(object)renderer == (Object)null)
			{
				return;
			}
			int num = 0;
			if (renderer is MeshRenderer)
			{
				MeshFilter component = ((Component)renderer).GetComponent<MeshFilter>();
				num = (((Object)(object)component != (Object)null && (Object)(object)component.sharedMesh != (Object)null) ? component.sharedMesh.subMeshCount : 0);
			}
			else
			{
				SkinnedMeshRenderer val = (SkinnedMeshRenderer)((renderer is SkinnedMeshRenderer) ? renderer : null);
				if ((Object)(object)val != (Object)null)
				{
					num = (((Object)(object)val.sharedMesh != (Object)null) ? val.sharedMesh.subMeshCount : 0);
				}
			}
			if (num <= 0)
			{
				return;
			}
			Material[] array = renderer.sharedMaterials;
			if (array == null || array.Length == 0)
			{
				renderer.sharedMaterials = BuildVisibleMaterials(null, null, num);
				return;
			}
			if (array.Length > num)
			{
				Array.Resize(ref array, num);
			}
			if (array.Length < num)
			{
				array = NormalizeMaterialArray(array, num);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)array[i] == (Object)null)
				{
					array[i] = CreateRuntimeMaterial(null, null);
				}
				NormalizeMaterialForVisibility(array[i]);
			}
			renderer.sharedMaterials = array;
		}

		private static void BindItemRendererFields(Item item, MeshRenderer[] meshRenderers, SkinnedMeshRenderer[] skinnedRenderers)
		{
			List<Renderer> list = new List<Renderer>(((meshRenderers != null) ? meshRenderers.Length : 0) + ((skinnedRenderers != null) ? skinnedRenderers.Length : 0));
			if (meshRenderers != null)
			{
				list.AddRange((IEnumerable<Renderer>)meshRenderers.Where((MeshRenderer r) => (Object)(object)r != (Object)null));
			}
			if (skinnedRenderers != null)
			{
				list.AddRange((IEnumerable<Renderer>)skinnedRenderers.Where((SkinnedMeshRenderer r) => (Object)(object)r != (Object)null));
			}
			Renderer val = SelectPreferredRenderer(list, null) ?? list.FirstOrDefault();
			if (!((Object)(object)val == (Object)null))
			{
				Type type = ((object)item).GetType();
				if (SetMember(item, type, MainRendererFieldNames, MainRendererPropertyNames, val))
				{
					list.Remove(val);
					list.Insert(0, val);
					SetMember(item, type, AddtlRendererFieldNames, null, list.ToArray());
				}
			}
		}

		private static Renderer SelectPreferredRenderer(IEnumerable<Renderer> renderers, Transform modelRoot)
		{
			Renderer val = null;
			int num = int.MinValue;
			Renderer val2 = null;
			int num2 = int.MinValue;
			foreach (Renderer item in renderers ?? Enumerable.Empty<Renderer>())
			{
				if ((Object)(object)item == (Object)null || ((Object)(object)modelRoot != (Object)null && !((Component)item).transform.IsChildOf(modelRoot)) || !IsMeshBackedRenderer(item))
				{
					continue;
				}
				int num3 = ScoreRendererCandidate(item);
				if (IsPreferredMainRendererCandidate(item))
				{
					if (num3 > num)
					{
						num = num3;
						val = item;
					}
				}
				else if (num3 > num2)
				{
					num2 = num3;
					val2 = item;
				}
			}
			return val ?? val2;
		}

		private static bool IsPreferredMainRendererCandidate(Renderer renderer)
		{
			if (!IsMeshBackedRenderer(renderer))
			{
				return false;
			}
			string text = GetTransformPath(((Component)renderer).transform).ToLowerInvariant();
			string text2 = (((Object)renderer).name ?? string.Empty).ToLowerInvariant();
			if (text2.Contains("vfx") || text2.Contains("muzzle") || text2.Contains("flash") || text2.Contains("particle") || text2.Contains("effect"))
			{
				return false;
			}
			if (text.Contains("/vfx") || text.Contains("gunshot") || text.Contains("muzzle") || text.Contains("particle") || text.Contains("effect"))
			{
				return false;
			}
			return true;
		}

		private static int ScoreRendererCandidate(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null || !IsMeshBackedRenderer(renderer))
			{
				return int.MinValue;
			}
			string text = GetTransformPath(((Component)renderer).transform).ToLowerInvariant();
			string text2 = (((Object)renderer).name ?? string.Empty).ToLowerInvariant();
			int num = 0;
			if (text2.Contains("vfx") || text2.Contains("muzzle") || text2.Contains("flash") || text2.Contains("particle"))
			{
				num -= 50000;
			}
			if (text.Contains("/vfx") || text.Contains("gunshot"))
			{
				num -= 40000;
			}
			Mesh rendererMesh = GetRendererMesh(renderer);
			if ((Object)(object)rendererMesh != (Object)null)
			{
				num += rendererMesh.vertexCount;
				if (rendererMesh.subMeshCount > 1)
				{
					num += 300;
				}
			}
			if (text2.Contains("ak") || text.Contains("/ak") || text2.Contains("weapon") || text2.Contains("gun"))
			{
				num += 1000;
			}
			return num;
		}

		private static bool SetMember(object target, Type targetType, string[] fieldNames, string[] propertyNames, object value)
		{
			Type type = value.GetType();
			string[] array = fieldNames ?? Array.Empty<string>();
			foreach (string name in array)
			{
				FieldInfo field = targetType.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(field == null) && field.FieldType.IsAssignableFrom(type))
				{
					field.SetValue(target, value);
					return true;
				}
			}
			array = propertyNames ?? Array.Empty<string>();
			foreach (string name2 in array)
			{
				PropertyInfo property = targetType.GetProperty(name2, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(property == null) && property.CanWrite && property.PropertyType.IsAssignableFrom(type))
				{
					property.SetValue(target, value);
					return true;
				}
			}
			return false;
		}

		private static int ResolveReferenceLayer(Item item, Transform originalAnchor)
		{
			if ((Object)(object)item != (Object)null && (Object)(object)item.mainRenderer != (Object)null)
			{
				return ((Component)item.mainRenderer).gameObject.layer;
			}
			Renderer val = (((Object)(object)item != (Object)null) ? ((IEnumerable<Renderer>)((Component)item).GetComponentsInChildren<Renderer>(true)).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => (Object)(object)r != (Object)null && ((Object)(object)originalAnchor == (Object)null || !((Component)r).transform.IsChildOf(originalAnchor)))) : null);
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject.layer;
			}
			if ((Object)(object)originalAnchor != (Object)null)
			{
				return ((Component)originalAnchor).gameObject.layer;
			}
			if (!((Object)(object)item != (Object)null))
			{
				return 0;
			}
			return ((Component)item).gameObject.layer;
		}

		private static string GetTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return "null";
			}
			Stack<string> stack = new Stack<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				stack.Push(((Object)val).name);
				val = val.parent;
			}
			return string.Join("/", stack);
		}

		private static string DescribeMaterialStateForDiagnostics(Material material)
		{
			if ((Object)(object)material == (Object)null)
			{
				return "null";
			}
			Texture val = ResolvePrimaryTexture(material);
			string text = (material.HasProperty("_Cull") ? material.GetInt("_Cull").ToString() : "-");
			object[] obj = new object[5]
			{
				((Object)material).name,
				null,
				null,
				null,
				null
			};
			Shader shader = material.shader;
			obj[1] = ((shader != null) ? ((Object)shader).name : null) ?? "null";
			obj[2] = material.renderQueue;
			obj[3] = text;
			obj[4] = (((Object)(object)val != (Object)null) ? ((Object)val).name : "null");
			return string.Format("{0}[shader={1},rq={2},cull={3},tex={4}]", obj);
		}

		private static string DescribeRendererStateForDiagnostics(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return "null";
			}
			Mesh rendererMesh = GetRendererMesh(renderer);
			Transform transform = ((Component)renderer).transform;
			Material[] array = renderer.sharedMaterials ?? Array.Empty<Material>();
			string text = string.Join(" | ", array.Take(4).Select(DescribeMaterialStateForDiagnostics));
			if (array.Length > 4)
			{
				text += $" | ...+{array.Length - 4}";
			}
			string text2 = (((Object)(object)rendererMesh != (Object)null) ? ((Object)rendererMesh).name : "null");
			int num = (((Object)(object)rendererMesh != (Object)null) ? rendererMesh.subMeshCount : 0);
			int num2 = (((Object)(object)rendererMesh != (Object)null) ? rendererMesh.vertexCount : 0);
			return $"{GetTransformPath(transform)}[enabled={renderer.enabled},forceOff={renderer.forceRenderingOff},active={((Component)renderer).gameObject.activeInHierarchy},layer={((Component)renderer).gameObject.layer},mesh={text2},subMeshes={num},verts={num2},mats={text}]";
		}

		private static string DescribeRendererCollectionForDiagnostics(IEnumerable<Renderer> renderers, int maxCount = 10)
		{
			if (renderers == null)
			{
				return "none";
			}
			List<string> list = renderers.Where((Renderer r) => (Object)(object)r != (Object)null).Take(maxCount).Select(DescribeRendererStateForDiagnostics)
				.ToList();
			if (list.Count == 0)
			{
				return "none";
			}
			int num = renderers.Count((Renderer r) => (Object)(object)r != (Object)null);
			if (num > list.Count)
			{
				list.Add("...+" + (num - list.Count));
			}
			return string.Join(" || ", list);
		}

		private static string DescribeBoundsForDiagnostics(Transform root)
		{
			//IL_0018: 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)
			if (!TryGetCombinedRenderableBounds(root, out var bounds))
			{
				return "none";
			}
			return $"center={((Bounds)(ref bounds)).center},size={((Bounds)(ref bounds)).size}";
		}

		private static void LogWorldVisualState(Item item, Transform visualRoot, string phase, Transform targetVisualRoot)
		{
			//IL_0114: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)item == (Object)null) && !((Object)(object)visualRoot == (Object)null))
			{
				int instanceID = ((Object)item).GetInstanceID();
				string text = DisplayName ?? "unknown";
				string text2 = DescribeRendererCollectionForDiagnostics(((Component)visualRoot).GetComponentsInChildren<Renderer>(true));
				string text3 = "none";
				if (HiddenRendererCache.TryGetValue(instanceID, out var value))
				{
					text3 = DescribeRendererCollectionForDiagnostics(value);
				}
				int num = ResolveReferenceLayer(item, targetVisualRoot);
				string key = "ak-world-state:" + phase + ":" + instanceID + ":" + text + ":" + ((Object)visualRoot).GetInstanceID();
				object[] obj = new object[18]
				{
					phase,
					DescribeItemForDiagnostics(item),
					GetTransformPath(targetVisualRoot),
					((Object)(object)targetVisualRoot != (Object)null) ? ((Component)targetVisualRoot).gameObject.layer : (-1),
					num,
					GetTransformPath(visualRoot),
					GetTransformPath(visualRoot.parent),
					visualRoot.localPosition,
					null,
					null,
					null,
					null,
					null,
					null,
					null,
					null,
					null,
					null
				};
				Quaternion val = visualRoot.localRotation;
				obj[8] = ((Quaternion)(ref val)).eulerAngles;
				obj[9] = visualRoot.localScale;
				obj[10] = visualRoot.position;
				val = visualRoot.rotation;
				obj[11] = ((Quaternion)(ref val)).eulerAngles;
				obj[12] = visualRoot.lossyScale;
				obj[13] = ((Component)visualRoot).gameObject.activeSelf;
				obj[14] = ((Component)visualRoot).gameObject.activeInHierarchy;
				obj[15] = DescribeBoundsForDiagnostics(visualRoot);
				obj[16] = text2;
				obj[17] = text3;
				Plugin.LogDiagnosticOnce(key, string.Format("World visual state: phase={0}, {1}, targetRoot={2}, targetLayer={3}, refLayer={4}, visualRoot={5}, parent={6}, localPos={7}, localRot={8}, localScale={9}, worldPos={10}, worldRot={11}, lossyScale={12}, activeSelf={13}, activeInHierarchy={14}, bounds={15}, renderers={16}, hiddenRenderers={17}", obj));
			}
		}

		private static void LogHeldVisualCameraState(Item item, Transform visualRoot, string phase)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)item == (Object)null) && !((Object)(object)visualRoot == (Object)null))
			{
				Vector3 val = visualRoot.position;
				if (TryGetCombinedRenderableBounds(visualRoot, out var bounds))
				{
					val = ((Bounds)(ref bounds)).center;
				}
				int layer = ((Component)visualRoot).gameObject.layer;
				int layer2 = -1;
				string sourcePath = "none";
				TryResolveHeldHandRendererLayer(item, out layer2, out sourcePath);
				Camera val2 = ResolvePreferredLocalCamera();
				string text = "camera=null";
				if ((Object)(object)val2 != (Object)null)
				{
					Vector3 position = ((Component)val2).transform.position;
					Vector3 val3 = val - position;
					float magnitude = ((Vector3)(ref val3)).magnitude;
					float num = ((magnitude > 0.0001f) ? Vector3.Dot(((Component)val2).transform.forward, val3 / magnitude) : 0f);
					text = $"camera={GetTransformPath(((Component)val2).transform)}, nearClip={val2.nearClipPlane:0.###}, farClip={val2.farClipPlane:0.###}, camLayer={((Component)val2).gameObject.layer}, cullingMask={val2.cullingMask}, distanceToBounds={magnitude:0.###}, dotForward={num:0.###}";
				}
				string key = "ak-held-camera:" + phase + ":" + ((Object)item).GetInstanceID() + ":" + ((Object)visualRoot).GetInstanceID();
				object[] obj = new object[13]
				{
					phase,
					DescribeItemForDiagnostics(item),
					GetTransformPath(visualRoot),
					GetTransformPath(visualRoot.parent),
					layer,
					layer2,
					sourcePath,
					visualRoot.localPosition,
					null,
					null,
					null,
					null,
					null
				};
				Quaternion localRotation = visualRoot.localRotation;
				obj[8] = ((Quaternion)(ref localRotation)).eulerAngles;
				obj[9] = visualRoot.localScale;
				obj[10] = visualRoot.position;
				obj[11] = DescribeBoundsForDiagnostics(visualRoot);
				obj[12] = text;
				Plugin.LogDiagnosticOnce(key, string.Format("Held visual camera state: phase={0}, {1}, visualRoot={2}, parent={3}, visualLayer={4}, handLayer={5}, handSource={6}, localPos={7}, localRot={8}, localScale={9}, worldPos={10}, bounds={11}, {12}", obj));
			}
		}

		private static bool ContainsKeyword(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			string text = value.ToLowerInvariant();
			string value2 = DisplayName.ToLowerInvariant();
			if (!string.IsNullOrWhiteSpace(value2) && text.Contains(value2))
			{
				return true;
			}
			string[] selectableWeaponKeywords = SelectableWeaponKeywords;
			foreach (string value3 in selectableWeaponKeywords)
			{
				if (text.Contains(value3))
				{
					return true;
				}
			}
			selectableWeaponKeywords = ItemKeywords;
			foreach (string value4 in selectableWeaponKeywords)
			{
				if (text.Contains(value4))
				{
					return true;
				}
			}
			return false;
		}

		private static Mesh GetRendererMesh(Renderer renderer)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			if ((Object)(object)renderer == (Object)null)
			{
				return null;
			}
			if (renderer is MeshRenderer)
			{
				MeshFilter component = ((Component)renderer).GetComponent<MeshFilter>();
				if (!((Object)(object)component != (Object)null))
				{
					return null;
				}
				return component.sharedMesh;
			}
			SkinnedMeshRenderer val = (SkinnedMeshRenderer)((renderer is SkinnedMeshRenderer) ? renderer : null);
			if ((Object)(object)val != (Object)null)
			{
				return val.sharedMesh;
			}
			return null;
		}

		private static void SetLayerRecursively(Transform root, int layer)
		{
			if (!((Object)(object)root == (Object)null))
			{
				((Component)root).gameObject.layer = layer;
				for (int i = 0; i < root.childCount; i++)
				{
					SetLayerRecursively(root.GetChild(i), layer);
				}
			}
		}

		private static int ResolveVisibleLayerForLocalPlayer(int fallbackLayer)
		{
			Camera val = ResolvePreferredLocalCamera();
			if ((Object)(object)val == (Object)null)
			{
				return fallbackLayer;
			}
			int cullingMask = val.cullingMask;
			if (fallbackLayer >= 0 && fallbackLayer < 32 && (cullingMask & (1 << fallbackLayer)) != 0)
			{
				return fallbackLayer;
			}
			int layer = ((Component)val).gameObject.layer;
			if ((cullingMask & (1 << layer)) != 0)
			{
				return layer;
			}
			for (int i = 0; i < 32; i++)
			{
				if ((cullingMask & (1 << i)) != 0)
				{
					return i;
				}
			}
			return fallbackLayer;
		}

		private static bool TryResolveHeldHandRendererLayer(Item item, out int layer, out string sourcePath)
		{
			layer = -1;
			sourcePath = "none";
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && IsHandItemRenderer(val))
				{
					layer = ((Component)val).gameObject.layer;
					sourcePath = GetTransformPath(((Component)val).transform);
					return true;
				}
			}
			return false;
		}

		private static int ResolveBestVisibleLayerForLocalHeldItem(Item item, Transform preferredRoot)
		{
			int num = ResolveReferenceLayer(item, preferredRoot);
			if (ShouldUseSeparateLocalFirstPersonVisual(item))
			{
				return num;
			}
			if (TryResolveHeldHandRendererLayer(item, out var layer, out var _))
			{
				return layer;
			}
			Camera val = ResolvePreferredLocalCamera();
			if ((Object)(object)val == (Object)null)
			{
				return num;
			}
			int cullingMask = val.cullingMask;
			List<int> list = new List<int>();
			if ((Object)(object)preferredRoot != (Object)null)
			{
				list.Add(((Component)preferredRoot).gameObject.layer);
			}
			Transform val2 = ResolveTargetVisualRoot(item);
			if ((Object)(object)val2 != (Object)null)
			{
				list.Add(((Component)val2).gameObject.layer);
			}
			if ((Object)(object)item != (Object)null)
			{
				Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val3 in componentsInChildren)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						if (IsHandItemRenderer(val3))
						{
							list.Insert(0, ((Component)val3).gameObject.layer);
						}
						else
						{
							list.Add(((Component)val3).gameObject.layer);
						}
					}
				}
			}
			foreach (int item2 in list.Distinct())
			{
				if (item2 >= 0 && item2 < 32 && (cullingMask & (1 << item2)) != 0)
				{
					return item2;
				}
			}
			return ResolveVisibleLayerForLocalPlayer(num);
		}

		internal static bool TryGetTransformPoseRelativeToAkRoot(Transform sourceTransform, out Vector3 localPosition, out Quaternion localRotation, out Vector3 localScale)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			localPosition = Vector3.zero;
			localRotation = Quaternion.identity;
			localScale = Vector3.one;
			if ((Object)(object)sourceTransform == (Object)null || (Object)(object)Plugin._ak47Prefab == (Object)null)
			{
				return false;
			}
			DecomposeMatrix(Plugin._ak47Prefab.transform.worldToLocalMatrix * sourceTransform.localToWorldMatrix, out localPosition, out localRotation, out localScale);
			localPosition = SanitizeLocalPosition(localPosition, Vector3.zero);
			localRotation = SanitizeLocalRotation(localRotation);
			localScale = SanitizeLocalScale(localScale, Vector3.one);
			return true;
		}

		private static Vector3 SanitizeLocalPosition(Vector3 value, Vector3 fallback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFiniteFloat(value.x) || !IsFiniteFloat(value.y) || !IsFiniteFloat(value.z))
			{
				return fallback;
			}
			if (((Vector3)(ref value)).sqrMagnitude > 100f)
			{
				return fallback;
			}
			return value;
		}

		private static Quaternion SanitizeLocalRotation(Quaternion value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFiniteFloat(value.x) || !IsFiniteFloat(value.y) || !IsFiniteFloat(value.z) || !IsFiniteFloat(value.w))
			{
				return Quaternion.identity;
			}
			float num = Mathf.Sqrt(value.x * value.x + value.y * value.y + value.z * value.z + value.w * value.w);
			if (!IsFiniteFloat(num) || num < 1E-05f)
			{
				return Quaternion.identity;
			}
			return new Quaternion(value.x / num, value.y / num, value.z / num, value.w / num);
		}

		private static Vector3 SanitizeLocalScale(Vector3 value, Vector3 fallback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFiniteFloat(value.x) || !IsFiniteFloat(value.y) || !IsFiniteFloat(value.z))
			{
				return fallback;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(Mathf.Abs(value.x), Mathf.Abs(value.y), Mathf.Abs(value.z));
			if (val.x < 0.0001f || val.y < 0.0001f || val.z < 0.0001f)
			{
				return fallback;
			}
			if (val.x > 10f || val.y > 10f || val.z > 10f)
			{
				return fallback;
			}
			return val;
		}

		private static bool IsFiniteFloat(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static Camera ResolvePreferredLocalCamera()
		{
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null && ((Behaviour)main).isActiveAndEnabled && (Object)(object)main.targetTexture == (Object)null)
			{
				return main;
			}
			Camera[] array = Object.FindObjectsByType<Camera>((FindObjectsSortMode)0);
			Camera result = null;
			int num = int.MinValue;
			Character localCharacter = Character.localCharacter;
			Camera[] array2 = array;
			foreach (Camera val in array2)
			{
				if (!((Object)(object)val == (Object)null) && ((Behaviour)val).isActiveAndEnabled && !((Object)(object)val.targetTexture != (Object)null))
				{
					int num2 = 0;
					string text = ((((Object)val).name ?? string.Empty) + "/" + (((Object)(object)((Component)val).transform.parent != (Object)null) ? ((Object)((Component)val).transform.parent).name : string.Empty)).ToLowerInvariant();
					if (text.Contains("main"))
					{
						num2 += 80;
					}
					if (text.Contains("player") || text.Contains("fps") || text.Contains("view"))
					{
						num2 += 50;
					}
					if ((Object)(object)localCharacter != (Object)null && ((Component)val).transform.IsChildOf(((Component)localCharacter).transform))
					{
						num2 += 120;
					}
					if (val.depth > 0f)
					{
						num2 += 10;
					}
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static void SyncVisualRootToTarget(Transform visualRoot, Transform targetVisualRoot)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_004d: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0085: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)visualRoot == (Object)null))
			{
				if ((Object)(object)targetVisualRoot == (Object)null)
				{
					visualRoot.localPosition = Vector3.zero;
					visualRoot.localRotation = Quaternion.identity;
					visualRoot.localScale = Vector3.one;
				}
				else if ((Object)visualRoot.parent == (Object)targetVisualRoot)
				{
					visualRoot.localPosition = Vector3.zero;
					visualRoot.localRotation = Quaternion.identity;
					visualRoot.localScale = Vector3.one;
				}
				else
				{
					visualRoot.SetParent(targetVisualRoot, false);
					visualRoot.localPosition = Vector3.zero;
					visualRoot.localRotation = Quaternion.identity;
					visualRoot.localScale = Vector3.one;
				}
			}
		}

		private static void DecomposeMatrix(Matrix4x4 matrix, out Vector3 position, out Quaternion rotation, out Vector3 scale)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			position = Vector4.op_Implicit(((Matrix4x4)(ref matrix)).GetColumn(3));
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(matrix.m00, matrix.m10, matrix.m20);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(matrix.m01, matrix.m11, matrix.m21);
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(matrix.m02, matrix.m12, matrix.m22);
			scale = new Vector3(((Vector3)(ref val)).magnitude, ((Vector3)(ref val2)).magnitude, ((Vector3)(ref val3)).magnitude);
			if (scale.x == 0f)
			{
				scale.x = 1f;
			}
			if (scale.y == 0f)
			{
				scale.y = 1f;
			}
			if (scale.z == 0f)
			{
				scale.z = 1f;
			}
			rotation = Quaternion.LookRotation(val3 / scale.z, val2 / scale.y);
		}
	}
	[HarmonyPatch(typeof(ItemSlot), "SetItem")]
	public static class ItemSlotSetItemPatch
	{
		[HarmonyPostfix]
		public static void SetItemPostfix(ItemSlot __instance, object[] __args)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (__instance == null)
			{
				return;
			}
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					Item val = null;
					if (__args != null && __args.Length != 0)
					{
						object obj = __args[0];
						val = (Item)((obj is Item) ? obj : null);
					}
					if ((Object)(object)val == (Object)null)
					{
						val = AkUiPatchHelpers.ResolveItemFromSlot(__instance);
					}
					if ((Object)(object)val != (Object)null && ItemPatch.IsBlowgunLike(val))
					{
						ItemPatch.ApplyAkDisplayIfNeeded(val);
					}
					if ((Object)(object)__instance.prefab != (Object)null && ItemPatch.IsBlowgunLike(__instance.prefab))
					{
						ItemPatch.ApplyAkDisplayIfNeeded(__instance.prefab);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] ItemSlotSetItemPatch failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch]
	public static class ItemUIDataPatch
	{
		[CompilerGenerated]
		private sealed class <DeferredVisibleUiRefresh>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredVisibleUiRefresh>d__12(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_008c;
				case 1:
					<>1__state = -1;
					goto IL_0073;
				case 2:
					{
						<>1__state = -1;
						goto IL_0073;
					}
					IL_0073:
					if (!_pendingVisibleUiRefresh)
					{
						break;
					}
					if (!Plugin.IsRuntimeVisualRefreshBlocked())
					{
						_pendingVisibleUiRefresh = false;
						RefreshVisibleUiNow();
					}
					goto IL_008c;
					IL_008c:
					if (_pendingVisibleUiRefresh)
					{
						float num = 0.5f - (Time.unscaledTime - _lastVisibleUiRefreshTime);
						if (num > 0f)
						{
							<>2__current = (object)new WaitForSecondsRealtime(num);
							<>1__state = 1;
							return true;
						}
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					break;
				}
				_deferredVisibleUiRefreshCoroutine = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const float VisibleUiRefreshCooldown = 0.5f;

		private static MethodBase _targetMethod;

		private static bool _hasPerformedFallbackVisibleUiScan;

		private static float _lastVisibleUiRefreshTime = -999f;

		private static bool _pendingVisibleUiRefresh;

		private static Coroutine _deferredVisibleUiRefreshCoroutine;

		public static MethodBase TargetMethod()
		{
			if (_targetMethod != null)
			{
				return _targetMethod;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					try
					{
						Type type = assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "ItemUIData");
						if (!(type == null))
						{
							MethodInfo method = type.GetMethod("GetIcon", BindingFlags.Instance | BindingFlags.Public);
							if (method != null)
							{
								_targetMethod = method;
								return _targetMethod;
							}
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			return null;
		}

		[HarmonyPostfix]
		public static void GetIconPostfix(object __instance, ref Texture2D __result)
		{
			try
			{
				if (Plugin.IsWeaponFeatureEnabled())
				{
					Texture2D akIconTexture = Plugin.GetAkIconTexture();
					if (!((Object)(object)akIconTexture == (Object)null) && ShouldUseAkIcon(__instance.GetType().GetField("itemName", BindingFlags.Instance | BindingFlags.Public)?.GetValue(__instance) as string))
					{
						__result = akIconTexture;
					}
				}
			}
			catch
			{
			}
		}

		private static bool ShouldUseAkIcon(string itemName)
		{
			return ItemPatch.ContainsWeaponKeyword(itemName);
		}

		public static void ForceRefreshVisibleUi()
		{
			if (!Plugin.IsWeaponFeatureEnabled())
			{
				ResetVisibleUiTrackingFallback();
				InventoryItemUiPatch.ClearCaches();
			}
			else if (Plugin.IsRuntimeVisualRefreshBlocked())
			{
				_pendingVisibleUiRefresh = true;
				ScheduleDeferredVisibleUiRefresh();
			}
			else if (Time.unscaledTime - _lastVisibleUiRefreshTime < 0.5f)
			{
				_pendingVisibleUiRefresh = true;
				ScheduleDeferredVisibleUiRefresh();
			}
			else
			{
				RefreshVisibleUiNow();
			}
		}

		private static void RefreshVisibleUiNow()
		{
			_lastVisibleUiRefreshTime = Time.unscaledTime;
			try
			{
				Plugin.GetAkIconTexture();
				if (!AkUiPatchHelpers.RefreshTrackedUi() && !_hasPerformedFallbackVisibleUiScan)
				{
					FallbackScanVisibleUiOnce();
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] ForceRefreshVisibleUi failed: " + ex.Message));
			}
		}

		private static void ScheduleDeferredVisibleUiRefresh()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (_deferredVisibleUiRefreshCoroutine == null)
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)instance == (Object)null))
				{
					_deferredVisibleUiRefreshCoroutine = ((MonoBehaviour)instance).StartCoroutine(DeferredVisibleUiRefresh());
				}
			}
		}

		[IteratorStateMachine(typeof(<DeferredVisibleUiRefresh>d__12))]
		private static IEnumerator DeferredVisibleUiRefresh()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredVisibleUiRefresh>d__12(0);
		}

		private static void FallbackScanVisibleUiOnce()
		{
			_hasPerformedFallbackVisibleUiScan = true;
			InventoryItemUI[] array = Object.FindObjectsByType<InventoryItemUI>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				AkUiPatchHelpers.ApplyAkToInventoryUi(array[i]);
			}
			BackpackWheelSlice[] array2 = Object.FindObjectsByType<BackpackWheelSlice>((FindObjectsSortMode)0);
			for (int j = 0; j < array2.Length; j++)
			{
				AkUiPatchHelpers.ApplyAkToSliceImage(array2[j]);
			}
			BackpackWheel[] array3 = Object.FindObjectsByType<BackpackWheel>((FindObjectsSortMode)0);
			for (int k = 0; k < array3.Length; k++)
			{
				AkUiPatchHelpers.ApplyAkToBackpackWheel(array3[k]);
			}
		}

		internal static void ResetVisibleUiTrackingFallback()
		{
			_hasPerformedFallbackVisibleUiScan = false;
			_pendingVisibleUiRefresh = false;
			_lastVisibleUiRefreshTime = -999f;
		}
	}
	internal sealed class LobbyConfigPanel
	{
		private enum PanelThemeMode
		{
			Dark,
			Light,
			Transparent
		}

		private sealed class ConfigSource
		{
			public string Id;

			public string DisplayName;

			public ConfigFile Config;

			public bool IsShootZombies;

			public ConfigLocalizer Localizer;

			public List<ConfigSection> Sections = new List<ConfigSection>();
		}

		private sealed class ConfigLocalizer
		{
			public Func<string, string> LocalizeSectionName;

			public Func<string, string> LocalizeKeyName;

			public Func<string, string> LocalizeDescription;

			public Func<string, object, string> LocalizeOptionDisplayText;
		}

		private sealed class ConfigSection
		{
			public string Key;

			public string DisplayName;

			public List<ConfigEntryBase> Entries = new List<ConfigEntryBase>();
		}

		private sealed class EntryBinding
		{
			public ConfigSource Source;

			public ConfigEntryBase Entry;

			public bool SuppressCallbacks;

			public Action Refresh;
		}

		private sealed class LobbyConfigPanelGuiHost : MonoBehaviour
		{
			public LobbyConfigPanel Owner;

			private void OnGUI()
			{
				Owner?.RenderImmediateGui();
			}
		}

		private static readonly Color BackdropColor = new Color(0f, 0f, 0f, 0.18f);

		private static readonly Color PanelColor = new Color(0.13f, 0.15f, 0.22f, 0.93f);

		private static readonly Color HeaderColor = new Color(0.21f, 0.26f, 0.36f, 1f);

		private static readonly Color SidebarColor = new Color(0.11f, 0.12f, 0.17f, 1f);

		private static readonly Color ContentColor = new Color(0.22f, 0.31f, 0.42f, 0.97f);

		private static readonly Color CardColor = new Color(0.18f, 0.22f, 0.29f, 0.98f);

		private static readonly Color ButtonColor = new Color(0.28f, 0.31f, 0.39f, 1f);

		private static readonly Color ButtonActiveColor = new Color(0.22f, 0.62f, 0.54f, 1f);

		private static readonly Color ButtonSecondaryActiveColor = new Color(0.25f, 0.47f, 0.71f, 1f);

		private static readonly Color FieldColor = new Color(0.24f, 0.27f, 0.34f, 1f);

		private static readonly Color BorderColor = new Color(0.44f, 0.5f, 0.61f, 0.95f);

		private static readonly Color TextPrimaryColor = new Color(0.96f, 0.96f, 0.98f, 1f);

		private static readonly Color TextSecondaryColor = new Color(0.82f, 0.85f, 0.9f, 1f);

		private static readonly Color TextMutedColor = new Color(0.7f, 0.73f, 0.79f, 1f);

		private readonly Plugin _owner;

		private readonly List<ConfigSource> _sources = new List<ConfigSource>();

		private readonly List<EntryBinding> _visibleBindings = new List<EntryBinding>();

		private GameObject _rootObject;

		private Canvas _canvas;

		private RectTransform _panelRect;

		private RectTransform _pluginTabsRect;

		private RectTransform _sectionListRect;

		private RectTransform _entryListRect;

		private TextMeshProUGUI _panelTitleText;

		private TextMeshProUGUI _contentTitleText;

		private bool _isOpen;

		private bool _isDirty = true;

		private bool _hasDataModel;

		private string _selectedSourceId = string.Empty;

		private string _selectedSectionKey = string.Empty;

		private ConfigEntryBase _pendingKeyCaptureEntry;

		private TextMeshProUGUI _pendingKeyCaptureText;

		private float _nextExternalRefreshTime;

		private bool _cursorStateCaptured;

		private bool _savedCursorVisible;

		private CursorLockMode _savedCursorLockMode;

		private bool _pendingRenderDiagnostic;

		private float _nextDiagnosticLogTime;

		private string _lastDiagnosticSummary = string.Empty;

		private Rect _windowRect;

		private Vector2 _entryScrollPosition;

		private readonly Dictionary<ConfigEntryBase, string> _textBufferByEntry = new Dictionary<ConfigEntryBase, string>();

		private static LobbyConfigPanel _cursorOwner;

		private PanelThemeMode _panelTheme;

		private readonly Dictionary<int, Texture2D> _immediateTextureCache = new Dictionary<int, Texture2D>();

		private GUIStyle _immediateWindowStyle;

		private GUIStyle _immediatePaneStyle;

		private GUIStyle _immediateCardStyle;

		private GUIStyle _immediateButtonStyle;

		private GUIStyle _immediateFieldStyle;

		private GUIStyle _immediateTextFieldStyle;

		private GUIStyle _immediateLabelStyle;

		private GUIStyle _immediateTitleStyle;

		private GUIStyle _immediateDescriptionStyle;

		public LobbyConfigPanel(Plugin owner)
		{
			_owner = owner;
			_panelTheme = GetConfiguredThemeMode();
		}

		private bool IsLightTheme()
		{
			return _panelTheme == PanelThemeMode.Light;
		}

		private bool IsTransparentTheme()
		{
			return _panelTheme == PanelThemeMode.Transparent;
		}

		private static bool IsChineseUi()
		{
			return Plugin.Instance?.GetCachedChineseLanguageSettingRuntime() ?? string.Equals(Plugin.GetLocalizedConfigSectionDisplayRuntime("Weapon"), "武器", StringComparison.Ordinal);
		}

		private static string GetAkSoundOptionDisplayText(string value)
		{
			bool flag = IsChineseUi();
			return value switch
			{
				"ak_sound1" => flag ? "音效 1" : "Sound 1", 
				"ak_sound2" => flag ? "音效 2" : "Sound 2", 
				"ak_sound3" => flag ? "音效 3" : "Sound 3", 
				_ => value, 
			};
		}

		private static string GetPanelThemeOptionDisplayText(string value)
		{
			bool flag = IsChineseUi();
			string text = NormalizeThemeSelectionValue(value);
			if (!(text == "light"))
			{
				if (text == "transparent")
				{
					return flag ? "透明" : "Transparent";
				}
				return flag ? "黑色" : "Dark";
			}
			return flag ? "白色" : "Light";
		}

		private string GetThemeToggleIcon()
		{
			return _panelTheme switch
			{
				PanelThemeMode.Light => "☽", 
				PanelThemeMode.Transparent => "◌", 
				_ => "☀", 
			};
		}

		private string GetSectionsLabel()
		{
			if (!IsChineseUi())
			{
				return "Sections";
			}
			return "章节";
		}

		private string GetToggleStateLabel(bool value)
		{
			if (IsChineseUi())
			{
				if (!value)
				{
					return "关闭";
				}
				return "开启";
			}
			if (!value)
			{
				return "Off";
			}
			return "On";
		}

		private string GetPressAnyKeyLabel()
		{
			if (!IsChineseUi())
			{
				return "Press any key...";
			}
			return "按任意键...";
		}

		private string GetNoVisibleEntriesLabel()
		{
			if (!IsChineseUi())
			{
				return "No visible settings.";
			}
			return "没有可显示的配置项。";
		}

		private float GetImmediateEntryContentWidth()
		{
			return Mathf.Clamp(((Rect)(ref _windowRect)).width - 254f, 560f, 1040f);
		}

		private float GetImmediateEntryTitleWidth()
		{
			return Mathf.Clamp(GetImmediateEntryContentWidth() * 0.24f, 168f, 308f);
		}

		private float GetImmediateCompactControlWidth()
		{
			return Mathf.Clamp(GetImmediateEntryContentWidth() * 0.34f, 280f, 420f);
		}

		private float GetImmediateRangeControlWidth()
		{
			return Mathf.Clamp(GetImmediateEntryContentWidth() * 0.52f, 360f, 560f);
		}

		private float GetImmediateRangeSliderWidth()
		{
			return Mathf.Clamp(GetImmediateRangeControlWidth() - 92f, 260f, 460f);
		}

		private float GetImmediateDescriptionWidth()
		{
			return Mathf.Max(520f, GetImmediateEntryContentWidth() - 24f);
		}

		private void ToggleTheme()
		{
			SetTheme(GetNextThemeMode(_panelTheme));
		}

		private void SetTheme(PanelThemeMode theme, bool persist = true)
		{
			if (_panelTheme != theme)
			{
				_panelTheme = theme;
				_isDirty = true;
				if (Plugin.ShouldEmitVerboseInfoLogsRuntime())
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)("[ShootZombies] LobbyConfigPanel theme changed to " + theme.ToString() + "."));
					}
				}
			}
			if (persist)
			{
				PersistThemeSelection(theme);
			}
		}

		internal static string NormalizeThemeSelectionValue(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "dark";
			}
			switch (value.Trim().ToLowerInvariant())
			{
			case "black":
			case "黑":
			case "黑色":
			case "dark":
				return "dark";
			case "light":
			case "white":
			case "白":
			case "白色":
				return "light";
			case "clear":
			case "透":
			case "透明":
			case "translucent":
			case "transparent":
				return "transparent";
			default:
				return "dark";
			}
		}

		private static PanelThemeMode GetThemeModeFromConfigValue(string value)
		{
			string text = NormalizeThemeSelectionValue(value);
			if (!(text == "light"))
			{
				if (text == "transparent")
				{
					return PanelThemeMode.Transparent;
				}
				return PanelThemeMode.Dark;
			}
			return PanelThemeMode.Light;
		}

		private static string GetThemeConfigValue(PanelThemeMode theme)
		{
			return theme switch
			{
				PanelThemeMode.Light => "light", 
				PanelThemeMode.Transparent => "transparent", 
				_ => "dark", 
			};
		}

		private static PanelThemeMode GetNextThemeMode(PanelThemeMode current)
		{
			return current switch
			{
				PanelThemeMode.Dark => PanelThemeMode.Light, 
				PanelThemeMode.Light => PanelThemeMode.Transparent, 
				_ => PanelThemeMode.Dark, 
			};
		}

		private static PanelThemeMode GetConfiguredThemeMode()
		{
			return GetThemeModeFromConfigValue(Plugin.ConfigPanelTheme?.Value);
		}

		private void SyncThemeFromConfig()
		{
			SetTheme(GetConfiguredThemeMode(), persist: false);
		}

		private void PersistThemeSelection(PanelThemeMode theme)
		{
			if (Plugin.ConfigPanelTheme != null)
			{
				string themeConfigValue = GetThemeConfigValue(theme);
				if (!string.Equals(NormalizeThemeSelectionValue(Plugin.ConfigPanelTheme.Value), themeConfigValue, StringComparison.Ordinal))
				{
					Plugin.ConfigPanelTheme.Value = themeConfigValue;
				}
				_owner?.SaveOwnedConfigRuntime();
			}
		}

		private Color GetImmediateBackdropColor()
		{
			//IL_001c: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (IsTransparentTheme())
			{
				return new Color(0f, 0f, 0f, 0.01f);
			}
			if (!IsLightTheme())
			{
				return new Color(0f, 0f, 0f, 0.1f);
			}
			return new Color(0f, 0f, 0f, 0.06f);
		}

		private Color GetImmediateWindowColor()
		{
			//IL_001c: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (IsTransparentTheme())
			{
				return new Color(0.04f, 0.04f, 0.04f, 0.34f);
			}
			if (!IsLightTheme())
			{
				return new Color(0.05f, 0.05f, 0.05f, 1f);
			}
			return new Color(0.97f, 0.97f, 0.97f, 1f);
		}

		private Color GetImmediatePaneColor()
		{
			//IL_001c: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (IsTransparentTheme())
			{
				return new Color(0.08f, 0.08f, 0.08f, 0.24f);
			}
			if (!IsLightTheme())
			{
				return new Color(0.09f, 0.09f, 0.09f, 1f);
			}
			return new Color(0.92f, 0.92f, 0.92f, 1f);
		}

		private Color GetImmediateCardColor()
		{
			//IL_001c: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (IsTransparentTheme())
			{
				return new Color(0.11f, 0.11f, 0.11f, 0.28f);
			}
			if (!IsLightTheme())
			{
				return new Color(0.14f, 0.14f, 0.14f, 1f);
			}
			return new Color(0.98f, 0.98f, 0.98f, 1f);
		}

		private Color GetImmediateFieldColor()
		{
			//IL_001c: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (IsTransparentTheme())
			{
				return new Color(0.16f, 0.16f, 0.16f, 0.36f);
			}
			if (!IsLightTheme())
			{
				return new Color(0.2f, 0.2f, 0.2f, 1f);
			}
			return new Color(0.87f, 0.87f, 0.87f, 1f);
		}

		private Color GetImmediateFieldFocusColor()
		{
			//IL_001c: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (IsTransparentTheme())
			{
				return new Color(0.2f, 0.2f, 0.2f, 0.44f);
			}
			if (!IsLightTheme())
			{
				return new Color(0.24f, 0.24f, 0.24f, 1f);
			}
			return new Color(0.88f, 0.88f, 0.88f, 1f);
		}

		private Color GetImmediateButtonColor(bool active)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0095: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			if (IsTransparentTheme())
			{
				if (!active)
				{
					return new Color(0.18f, 0.18f, 0.18f, 0.58f);
				}
				return new Color(0.34f, 0.34f, 0.34f, 0.78f);
			}
			if (IsLightTheme())
			{
				if (!active)
				{
					return new Color(0.86f, 0.86f, 0.86f, 1f);
				}
				return new Color(0.72f, 0.72f, 0.72f, 1f);
			}
			if (!active)
			{
				return new Color(0.18f, 0.18f, 0.18f, 1f);
			}
			return new Color(0.34f, 0.34f, 0.34f, 1f);
		}

		private Color GetImmediateThemeButtonColor(PanelThemeMode theme, bool active)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			switch (theme)
			{
			case PanelThemeMode.Light:
				if (!active)
				{
					return new Color(0.8f, 0.8f, 0.8f, 1f);
				}
				return new Color(0.98f, 0.98f, 0.98f, 1f);
			case PanelThemeMode.Transparent:
				if (!active)
				{
					return new Color(0.22f, 0.22f, 0.22f, 0.48f);
				}
				return new Color(0.18f, 0.18f, 0.18f, 0.82f);
			default:
				if (!active)
				{
					return new Color(0.28f, 0.28f, 0.28f, 1f);
				}
				return new Color(0.12f, 0.12f, 0.12f, 1f);
			}
		}

		private Color GetImmediateThemeButtonTextColor(PanelThemeMode theme, bool active)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			switch (theme)
			{
			case PanelThemeMode.Light:
				return new Color(0.08f, 0.08f, 0.08f, 1f);
			case PanelThemeMode.Transparent:
				return new Color(0.96f, 0.96f, 0.96f, active ? 1f : 0.92f);
			default:
				if (!active)
				{
					return new Color(0.86f, 0.86f, 0.86f, 1f);
				}
				return new Color(0.96f, 0.96f, 0.96f, 1f);
			}
		}

		private Color GetImmediateTextPrimaryColor()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsLightTheme())
			{
				return new Color(0.96f, 0.96f, 0.96f, 1f);
			}
			return new Color(0.08f, 0.08f, 0.08f, 1f);
		}

		private Color GetImmediateTextMutedColor()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsLightTheme())
			{
				return new Color(0.78f, 0.78f, 0.78f, 1f);
			}
			return new Color(0.28f, 0.28f, 0.28f, 1f);
		}

		private Texture2D GetSolidTexture(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Color32 val = Color32.op_Implicit(color);
			int key = val.r | (val.g << 8) | (val.b << 16) | (val.a << 24);
			if (_immediateTextureCache.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Texture2D val2 = new Texture2D(1, 1, (TextureFormat)5, false);
			((Object)val2).hideFlags = (HideFlags)61;
			val2.SetPixel(0, 0, color);
			val2.Apply(false, true);
			_immediateTextureCache[key] = val2;
			return val2;
		}

		private void EnsureImmediateStyles()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Expected O, but got Unknown
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Expected O, but got Unknown
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: 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_0105: Expected O, but got Unknown
			if (_immediateWindowStyle == null)
			{
				_immediateWindowStyle = new GUIStyle(GUI.skin.window);
			}
			if (_immediatePaneStyle == null)
			{
				_immediatePaneStyle = new GUIStyle(GUI.skin.box);
			}
			if (_immediateCardStyle == null)
			{
				_immediateCardStyle = new GUIStyle(GUI.skin.box);
			}
			if (_immediateButtonStyle == null)
			{
				_immediateButtonStyle = new GUIStyle(GUI.skin.button);
			}
			if (_immediateFieldStyle == null)
			{
				_immediateFieldStyle = new GUIStyle(GUI.skin.box);
			}
			if (_immediateTextFieldStyle == null)
			{
				_immediateTextFieldStyle = new GUIStyle(GUI.skin.textField);
			}
			if (_immediateLabelStyle == null)
			{
				_immediateLabelStyle = new GUIStyle(GUI.skin.label);
			}
			if (_immediateTitleStyle == null)
			{
				_immediateTitleStyle = new GUIStyle(GUI.skin.label);
			}
			if (_immediateDescriptionStyle == null)
			{
				_immediateDescriptionStyle = new GUIStyle(GUI.skin.label);
			}
			Texture2D solidTexture = GetSolidTexture(Color.white);
			Color immediateTextPrimaryColor = GetImmediateTextPrimaryColor();
			Color immediateTextMutedColor = GetImmediateTextMutedColor();
			_immediateWindowStyle.normal.background = GetSolidTexture(GetImmediateWindowColor());
			_immediateWindowStyle.onNormal.background = _immediateWindowStyle.normal.background;
			_immediateWindowStyle.normal.textColor = immediateTextPrimaryColor;
			_immediateWindowStyle.alignment = (TextAnchor)0;
			_immediateWindowStyle.fontSize = 15;
			_immediateWindowStyle.fontStyle = (FontStyle)1;
			_immediateWindowStyle.padding = new RectOffset(12, 12, 12, 12);
			_immediatePaneStyle.normal.background = GetSolidTexture(GetImmediatePaneColor());
			_immediatePaneStyle.normal.textColor = immediateTextPrimaryColor;
			_immediatePaneStyle.border = new RectOffset(1, 1, 1, 1);
			_immediateCardStyle.normal.background = GetSolidTexture(GetImmediateCardColor());
			_immediateCardStyle.normal.textColor = immediateTextPrimaryColor;
			_immediateCardStyle.alignment = (TextAnchor)0;
			_immediateCardStyle.padding = new RectOffset(10, 10, 8, 8);
			_immediateButtonStyle.normal.background = solidTexture;
			_immediateButtonStyle.hover.background = solidTexture;
			_immediateButtonStyle.active.background = solidTexture;
			_immediateButtonStyle.focused.background = solidTexture;
			_immediateButtonStyle.normal.textColor = immediateTextPrimaryColor;
			_immediateButtonStyle.hover.textColor = immediateTextPrimaryColor;
			_immediateButtonStyle.active.textColor = immediateTextPrimaryColor;
			_immediateButtonStyle.focused.textColor = immediateTextPrimaryColor;
			_immediateButtonStyle.alignment = (TextAnchor)4;
			_immediateFieldStyle.normal.background = GetSolidTexture(GetImmediateFieldColor());
			_immediateFieldStyle.normal.textColor = immediateTextPrimaryColor;
			_immediateFieldStyle.alignment = (TextAnchor)4;
			_immediateFieldStyle.padding = new RectOffset(8, 8, 6, 6);
			_immediateTextFieldStyle.normal.background = GetSolidTexture(GetImmediateFieldColor());
			_immediateTextFieldStyle.focused.background = GetSolidTexture(GetImmediateFieldFocusColor());
			_immediateTextFieldStyle.hover.background = _immediateTextFieldStyle.normal.background;
			_immediateTextFieldStyle.normal.textColor = immediateTextPrimaryColor;
			_immediateTextFieldStyle.focused.textColor = immediateTextPrimaryColor;
			_immediateTextFieldStyle.hover.textColor = immediateTextPrimaryColor;
			_immediateTextFieldStyle.padding = new RectOffset(8, 8, 6, 6);
			_immediateLabelStyle.fontSize = 12;
			_immediateLabelStyle.normal.textColor = immediateTextPrimaryColor;
			_immediateTitleStyle.fontSize = 14;
			_immediateTitleStyle.fontStyle = (FontStyle)1;
			_immediateTitleStyle.normal.textColor = immediateTextPrimaryColor;
			_immediateDescriptionStyle.fontSize = 10;
			_immediateDescriptionStyle.wordWrap = true;
			_immediateDescriptionStyle.normal.textColor = immediateTextMutedColor;
		}

		internal static bool IsCursorOwnershipActive()
		{
			if (_cursorOwner != null)
			{
				return _cursorOwner._isOpen;
			}
			return false;
		}

		public void Tick()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (!Plugin.IsLobbySceneRuntime(activeScene) && !Plugin.IsGameplaySceneRuntime(activeScene))
			{
				if (_isOpen)
				{
					Close();
				}
				return;
			}
			SyncThemeFromConfig();
			if (!_isOpen && (Object)(object)_rootObject == (Object)null)
			{
				BuildUi();
				RefreshDataModel();
				_isDirty = false;
			}
			if (_pendingKeyCaptureEntry != null)
			{
				HandleKeyCapture();
			}
			else if (ShouldTogglePanel())
			{
				if (_isOpen)
				{
					Close();
				}
				else
				{
					Open();
				}
			}
			else
			{
				if (!_isOpen)
				{
					return;
				}
				if (Input.GetKeyDown((KeyCode)27))
				{
					Close();
					return;
				}
				if ((Object)(object)_rootObject == (Object)null)
				{
					BuildUi();
					_isDirty = true;
				}
				ClampPanelToScreen();
				EnsureWindowRectInitialized();
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				if (_isDirty || Time.unscaledTime >= _nextExternalRefreshTime)
				{
					if (_isDirty || !_hasDataModel)
					{
						RefreshDataModel();
						RefreshUi();
						_isDirty = false;
					}
					else
					{
						RefreshVisibleBindings();
						UpdatePanelHeaders();
					}
					_nextExternalRefreshTime = Time.unscaledTime + 0.5f;
				}
			}
		}

		public void Dispose()
		{
			Close();
			if (_cursorOwner == this)
			{
				_cursorOwner = null;
			}
			if ((Object)(object)_rootObject != (Object)null)
			{
				Object.Destroy((Object)(object)_rootObject);
				_rootObject = null;
				_canvas = null;
				_panelRect = null;
				_pluginTabsRect = null;
				_sectionListRect = null;
				_entryListRect = null;
				_panelTitleText = null;
				_contentTitleText = null;
			}
			foreach (Texture2D value in _immediateTextureCache.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			_immediateTextureCache.Clear();
			_sources.Clear();
			_visibleBindings.Clear();
			_hasDataModel = false;
		}

		private void Open()
		{
			EnsureEventSystem();
			SyncThemeFromConfig();
			if ((Object)(object)_rootObject == (Object)null)
			{
				BuildUi();
			}
			_rootObject.SetActive(true);
			if ((Object)(object)_canvas != (Object)null)
			{
				((Behaviour)_canvas).enabled = false;
			}
			ClampPanelToScreen();
			if (!_hasDataModel || _sources.Count == 0 || _isDirty)
			{
				RefreshDataModel();
				RefreshUi();
				_isDirty = false;
			}
			else
			{
				RefreshVisibleBindings();
				UpdatePanelHeaders();
			}
			CaptureCursorState();
			EnsureWindowRectInitialized(((Rect)(ref _windowRect)).width <= 1f || ((Rect)(ref _windowRect)).height <= 1f);
			_cursorOwner = this;
			EventSystem current = EventSystem.current;
			if (current != null)
			{
				current.SetSelectedGameObject((GameObject)null);
			}
			_isOpen = true;
			_pendingRenderDiagnostic = true;
			_nextExternalRefreshTime = Time.unscaledTime + 0.5f;
			if (Plugin.ShouldEmitVerboseInfoLogsRuntime())
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[ShootZombies] LobbyConfigPanel opened.");
				}
			}
		}

		public void NotifyLanguageChanged(bool isChineseLanguage)
		{
			_selectedSectionKey = string.Empty;
			_isDirty = true;
			_nextExternalRefreshTime = 0f;
			if (!_isOpen || (Object)(object)_rootObject == (Object)null)
			{
				return;
			}
			RefreshDataModel();
			RefreshUi();
			_isDirty = false;
			_nextExternalRefreshTime = Time.unscaledTime + 0.5f;
			_pendingRenderDiagnostic = true;
			if (Plugin.ShouldEmitVerboseInfoLogsRuntime())
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[ShootZombies] LobbyConfigPanel language refresh applied. isChinese=" + isChineseLanguage + "."));
				}
			}
		}

		private void Close()
		{
			_pendingKeyCaptureEntry = null;
			_pendingKeyCaptureText = null;
			if ((Object)(object)_rootObject != (Object)null)
			{
				_rootObject.SetActive(false);
			}
			if (_cursorOwner == this)
			{
				_cursorOwner = null;
			}
			RestoreCursorState();
			_isOpen = false;
			_pendingRenderDiagnostic = false;
		}

		private bool ShouldTogglePanel()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (IsTypingIntoInputField())
			{
				return false;
			}
			return Input.GetKeyDown(GetOpenKey());
		}

		private KeyCode GetOpenKey()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.OpenConfigPanelKey == null || (int)Plugin.OpenConfigPanelKey.Value == 0)
			{
				return (KeyCode)92;
			}
			return Plugin.OpenConfigPanelKey.Value;
		}

		private void HandleKeyCapture()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (_pendingKeyCaptureEntry == null)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				CancelKeyCapture();
				return;
			}
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				if ((int)value != 0 && Input.GetKeyDown(value))
				{
					TryAssignBoxedValue(_pendingKeyCaptureEntry, (object)value);
					SaveEntryOwner(_pendingKeyCaptureEntry);
					CancelKeyCapture();
					RefreshVisibleBindings();
					break;
				}
			}
		}

		private void CancelKeyCapture()
		{
			_pendingKeyCaptureEntry = null;
			_pendingKeyCaptureText = null;
			RefreshVisibleBindings();
		}

		private void CaptureCursorState()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!_cursorStateCaptured)
			{
				_savedCursorVisible = Cursor.visible;
				_savedCursorLockMode = Cursor.lockState;
				_cursorStateCaptured = true;
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
		}

		private void RestoreCursorState()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (_cursorStateCaptured)
			{
				Cursor.visible = _savedCursorVisible;
				Cursor.lockState = _savedCursorLockMode;
				_cursorStateCaptured = false;
			}
		}

		private void EnterPauseMenuMode()
		{
		}

		private void ExitPauseMenuMode()
		{
		}

		private void RefreshDataModel()
		{
			_sources.Clear();
			ConfigSource configSource = BuildShootZombiesSource();
			if (configSource != null)
			{
				_sources.Add(configSource);
			}
			ConfigSource configSource2 = BuildFogAndColdControlSource();
			if (configSource2 != null)
			{
				_sources.Add(configSource2);
			}
			if (_sources.Count == 0)
			{
				_selectedSourceId = string.Empty;
				_selectedSectionKey = string.Empty;
				_hasDataModel = false;
				return;
			}
			_hasDataModel = true;
			if (!_sources.Any((ConfigSource source) => string.Equals(source.Id, _selectedSourceId, StringComparison.Ordinal)))
			{
				_selectedSourceId = _sources[0].Id;
			}
			ConfigSource selectedSource = GetSelectedSource();
			if (selectedSource == null || selectedSource.Sections.Count == 0)
			{
				_selectedSectionKey = string.Empty;
				return;
			}
			if (!selectedSource.Sections.Any((ConfigSection section) => string.Equals(section.Key, _selectedSectionKey, StringComparison.Ordinal)))
			{
				_selectedSectionKey = selectedSource.Sections[0].Key;
			}
			MaybeLogDiagnostics();
		}

		private ConfigSource BuildShootZombiesSource()
		{
			if ((Object)(object)Plugin.Instance == (Object)null)
			{
				return null;
			}
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			return BuildSource("shootzombies", "ShootZombies", config, CreateShootZombiesLocalizer(), isShootZombies: true);
		}

		private bool GetCurrentLanguageIsChinese()
		{
			return _owner?.GetCachedChineseLanguageSettingRuntime() ?? IsChineseUi();
		}

		private ConfigSource BuildFogAndColdControlSource()
		{
			bool currentLanguageIsChinese = GetCurrentLanguageIsChinese();
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				BaseUnityPlugin val = ((value != null) ? value.Instance : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)Plugin.Instance) && IsFogAndColdControlPlugin(value))
				{
					BepInPlugin metadata = value.Metadata;
					string text = ((metadata != null) ? metadata.GUID : null);
					if (string.IsNullOrWhiteSpace(text))
					{
						text = "thanks.fogandcoldcontrol";
					}
					BepInPlugin metadata2 = value.Metadata;
					string text2 = ((metadata2 != null) ? metadata2.Name : null);
					if (string.IsNullOrWhiteSpace(text2))
					{
						text2 = "Fog&ColdControl";
					}
					return BuildSource(text, text2, val.Config, TryCreatePluginLocalizer(val, currentLanguageIsChinese), isShootZombies: false);
				}
			}
			return null;
		}

		private static bool IsFogAndColdControlPlugin(PluginInfo info)
		{
			if (info == null)
			{
				return false;
			}
			string[] array3 = new string[4];
			BepInPlugin metadata = info.Metadata;
			array3[0] = ((metadata != null) ? metadata.GUID : null);
			BepInPlugin metadata2 = info.Metadata;
			array3[1] = ((metadata2 != null) ? metadata2.Name : null);
			array3[2] = ((object)info.Instance)?.GetType().Assembly.GetName().Name;
			array3[3] = Path.GetFileNameWithoutExtension(info.Location ?? string.Empty);
			string[] source = array3;
			string[] array2 = new string[4] { "Thanks.Fog&ColdControl", "Fog&ColdControl", "FogAndColdControl", "FogColdControl" };
			return source.Any((string candidate) => !string.IsNullOrWhiteSpace(candidate) && array2.Any((string matchToken) => candidate.IndexOf(matchToken, StringComparison.OrdinalIgnoreCase) >= 0));
		}

		private static ConfigLocalizer CreateShootZombiesLocalizer()
		{
			return new ConfigLocalizer
			{
				LocalizeSectionName = (string section) => Plugin.GetLocalizedConfigSectionDisplayRuntime(section),
				LocalizeKeyName = (string key) => Plugin.GetLocalizedConfigKeyDisplayRuntime(key),
				LocalizeDescription = (string key) => Plugin.GetLocalizedConfigDescriptionRuntime(key),
				LocalizeOptionDisplayText = (string key, object option) => GetShootZombiesOptionDisplayText(key, option)
			};
		}

		private static ConfigLocalizer TryCreatePluginLocalizer(BaseUnityPlugin pluginInstance, bool isChineseLanguage)
		{
			if ((Object)(object)pluginInstance == (Object)null)
			{
				return null;
			}
			ConfigLocalizer configLocalizer = TryCreateConfigKeyEnumPluginLocalizer(pluginInstance, isChineseLanguage);
			if (configLocalizer != null)
			{
				return configLocalizer;
			}
			Type type = ((object)pluginInstance).GetType();
			if (!HasMethod(type, "GetLocalizedConfigKeyDisplayRuntime") && !HasMethod(type, "GetLocalizedKeyName") && !HasMethod(type, "GetKeyName") && !HasMethod(type, "GetLocalizedConfigSectionDisplayRuntime") && !HasMethod(type, "GetLocalizedSectionName") && !HasMethod(type, "GetSectionName") && !HasMethod(type, "GetLocalizedConfigDescriptionRuntime") && !HasMethod(type, "GetLocalizedDescription") && !HasMethod(type, "GetLocalizedConfigOptionDisplayRuntime") && !HasMethod(type, "GetLocalizedConfigOptionDisplayTextRuntime") && !HasMethod(type, "GetLocalizedOptionDisplayText") && !HasMethod(type, "GetOptionDisplayText"))
			{
				return null;
			}
			return new ConfigLocalizer
			{
				LocalizeSectionName = (string section) => TryLocalizePluginSectionName(pluginInstance, section, isChineseLanguage) ?? section,
				LocalizeKeyName = (string key) => TryLocalizePluginKeyName(pluginInstance, key, isChineseLanguage) ?? key,
				LocalizeDescription = (string key) => TryLocalizePluginDescription(pluginInstance, key, isChineseLanguage) ?? string.Empty,
				LocalizeOptionDisplayText = (string key, object option) => TryLocalizePluginOptionDisplayText(pluginInstance, key, option, isChineseLanguage) ?? option?.ToString() ?? string.Empty
			};
		}

		private ConfigSource BuildSource(string id, string displayName, ConfigFile config, ConfigLocalizer localizer, bool isShootZombies)
		{
			ConfigEntryBase[] configEntriesSnapshotRuntime = Plugin.GetConfigEntriesSnapshotRuntime(config);
			if (configEntriesSnapshotRuntime.Length == 0)
			{
				return null;
			}
			ConfigSource configSource = new ConfigSource
			{
				Id = id,
				DisplayName = displayName,
				Config = config,
				IsShootZombies = isShootZombies,
				Localizer = localizer
			};
			foreach (IGrouping<string, ConfigEntryBase> item in (from entry in configEntriesSnapshotRuntime
				where entry != null && entry.Definition != (ConfigDefinition)null && (!isShootZombies || Plugin.ShouldExposeOwnedConfigEntryRuntime(entry))
				group entry by entry.Definition.Section ?? string.Empty into @group
				orderby GetSectionSortIndex(configSource, @group.Key)
				select @group).ThenBy<IGrouping<string, ConfigEntryBase>, string>((IGrouping<string, ConfigEntryBase> group) => GetSectionDisplayName(configSource, group.Key), StringComparer.OrdinalIgnoreCase))
			{
				ConfigSection configSection = new ConfigSection
				{
					Key = item.Key,
					DisplayName = GetSectionDisplayName(configSource, item.Key)
				};
				configSection.Entries.AddRange(item.OrderBy((ConfigEntryBase entry) => GetEntrySortIndex(configSource, entry)).ThenBy<ConfigEntryBase, string>((ConfigEntryBase entry) => GetEntryDisplayName(configSource, entry), StringComparer.OrdinalIgnoreCase));
				if (configSection.Entries.Count > 0)
				{
					configSource.Sections.Add(configSection);
				}
			}
			if (configSource.Sections.Count == 0)
			{
				return null;
			}
			return configSource;
		}

		private static string GetShootZombiesOptionDisplayText(string key, object option)
		{
			string text = option?.ToString() ?? string.Empty;
			if (string.Equals(key, "Config Panel Theme", StringComparison.Ordinal))
			{
				return GetPanelThemeOptionDisplayText(text);
			}
			if (string.Equals(key, "AK Sound", StringComparison.Ordinal))
			{
				return GetAkSoundOptionDisplayText(text);
			}
			if (string.Equals(key, "Weapon Selection", StringComparison.Ordinal))
			{
				return text switch
				{
					"AK47" => "AK47", 
					"HK416" => "HK416", 
					"MPX" => "MPX", 
					_ => text, 
				};
			}
			if (string.Equals(key, "Behavior Difficulty", StringComparison.Ordinal))
			{
				return Plugin.GetZombieBehaviorDifficultyDisplayNameRuntime(text);
			}
			return text;
		}

		private static bool HasMethod(Type type, string methodName)
		{
			if (type == null || string.IsNullOrWhiteSpace(methodName))
			{
				return false;
			}
			return type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Any((MethodInfo method) => string.Equals(method.Name, methodName, StringComparison.Ordinal));
		}

		private static bool TryResolvePluginChineseLanguage(BaseUnityPlugin pluginInstance)
		{
			if ((Object)(object)pluginInstance != (Object)null)
			{
				Type type = ((object)pluginInstance).GetType();
				if (TryInvokeCompatibleMethod(type, pluginInstance, "GetCachedChineseLanguageSetting", out var result) && result is bool)
				{
					return (bool)result;
				}
				if (TryInvokeCompatibleMethod(type, pluginInstance, "IsChineseLanguage", out result) && result is bool)
				{
					return (bool)result;
				}
			}
			return string.Equals(Plugin.GetLocalizedConfigSectionDisplayRuntime("Weapon"), "武器", StringComparison.Ordinal);
		}

		private static ConfigLocalizer TryCreateConfigKeyEnumPluginLocalizer(BaseUnityPlugin pluginInstance, bool isChineseLanguage)
		{
			if ((Object)(object)pluginInstance == (Object)null)
			{
				return null;
			}
			Type type = ((object)pluginInstance).GetType();
			Type nestedType = type.GetNestedType("ConfigKey", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (nestedType == null || !nestedType.IsEnum)
			{
				return null;
			}
			MethodInfo methodInfo = FindCompatibleMethod(type, "GetKeyName", nestedType, typeof(bool));
			MethodInfo methodInfo2 = FindCompatibleMethod(type, "GetSectionName", nestedType, typeof(bool));
			MethodInfo methodInfo3 = FindCompatibleMethod(type, "GetLocalizedDescription", nestedType, typeof(bool));
			if (methodInfo == null || methodInfo2 == null || methodInfo3 == null)
			{
				return null;
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			foreach (object value in Enum.GetValues(nestedType))
			{
				string source = InvokeStringMethod(methodInfo, pluginInstance, value, false);
				string source2 = InvokeStringMethod(methodInfo, pluginInstance, value, true);
				string target = InvokeStringMethod(methodInfo, pluginInstance, value, isChineseLanguage);
				AddLocalizationAlias(dictionary, source, target);
				AddLocalizationAlias(dictionary, source2, target);
				string source3 = InvokeStringMethod(methodInfo2, pluginInstance, value, false);
				string source4 = InvokeStringMethod(methodInfo2, pluginInstance, value, true);
				string target2 = InvokeStringMethod(methodInfo2, pluginInstance, value, isChineseLanguage);
				AddLocalizationAlias(dictionary2, source3, target2);
				AddLocalizationAlias(dictionary2, source4, target2);
				string source5 = InvokeStringMethod(methodInfo3, pluginInstance, value, false);
				string source6 = InvokeStringMethod(methodInfo3, pluginInstance, value, true);
				string target3 = InvokeStringMethod(methodInfo3, pluginInstance, value, isChineseLanguage);
				AddLocalizationAlias(dictionary3, source, target3);
				AddLocalizationAlias(dictionary3, source2, target3);
				AddLocalizationAlias(dictionary3, source5, target3);
				AddLocalizationAlias(dictionary3, source6, target3);
			}
			if (dictionary.Count == 0 && dictionary2.Count == 0 && dictionary3.Count == 0)
			{
				return null;
			}
			return new ConfigLocalizer
			{
				LocalizeSectionName = (string section) => LookupLocalization(dictionary2, section),
				LocalizeKeyName = (string key) => LookupLocalization(dictionary, key),
				LocalizeDescription = (string key) => LookupLocalization(dictionary3, key),
				LocalizeOptionDisplayText = (string key, object option) => option?.ToString() ?? string.Empty
			};
		}

		private static MethodInfo FindCompatibleMethod(Type declaringType, string methodName, params Type[] parameterTypes)
		{
			if (declaringType == null || string.IsNullOrWhiteSpace(methodName))
			{
				return null;
			}
			return declaringType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo method)
			{
				if (!string.Equals(method.Name, methodName, StringComparison.Ordinal))
				{
					return false;
				}
				ParameterInfo[] parameters = method.GetParameters();
				if (parameters.Length != parameterTypes.Length)
				{
					return false;
				}
				for (int i = 0; i < parameterTypes.Length; i++)
				{
					if (parameters[i].ParameterType != parameterTypes[i])
					{
						return false;
					}
				}
				return method.ReturnType == typeof(string);
			});
		}

		private static string InvokeStringMethod(MethodInfo method, object target, params object[] arguments)
		{
			if (method == null)
			{
				return null;
			}
			try
			{
				object obj = method.Invoke(method.IsStatic ? null : target, arguments);
				return (obj as string) ?? obj?.ToString();
			}
			catch
			{
			}
			return null;
		}

		private static void AddLocalizationAlias(Dictionary<string, string> map, string source, string target)
		{
			if (map != null && !string.IsNullOrWhiteSpace(source) && !string.IsNullOrWhiteSpace(target))
			{
				map[source] = target;
			}
		}

		private static string LookupLocalization(Dictionary<string, string> map, string value)
		{
			if (map == null || string.IsNullOrWhiteSpace(value))
			{
				return null;
			}
			if (!map.TryGetValue(value, out var value2))
			{
				return null;
			}
			return value2;
		}

		private static string TryLocalizePluginSectionName(BaseUnityPlugin pluginInstance, string section, bool isChinese)
		{
			if ((Object)(object)pluginInstance == (Object)null || string.IsNullOrWhiteSpace(section))
			{
				return null;
			}
			Type type = ((object)pluginInstance).GetType();
			return TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedConfigSectionDisplayRuntime", section) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedSectionName", section, isChinese);
		}

		private static string TryLocalizePluginKeyName(BaseUnityPlugin pluginInstance, string key, bool isChinese)
		{
			if ((Object)(object)pluginInstance == (Object)null || string.IsNullOrWhiteSpace(key))
			{
				return null;
			}
			Type type = ((object)pluginInstance).GetType();
			return TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedConfigKeyDisplayRuntime", key) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedKeyName", key, isChinese);
		}

		private static string TryLocalizePluginDescription(BaseUnityPlugin pluginInstance, string key, bool isChinese)
		{
			if ((Object)(object)pluginInstance == (Object)null || string.IsNullOrWhiteSpace(key))
			{
				return null;
			}
			Type type = ((object)pluginInstance).GetType();
			return TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedConfigDescriptionRuntime", key) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedDescription", key, isChinese);
		}

		private static string TryLocalizePluginOptionDisplayText(BaseUnityPlugin pluginInstance, string key, object option, bool isChinese)
		{
			if ((Object)(object)pluginInstance == (Object)null)
			{
				return null;
			}
			Type type = ((object)pluginInstance).GetType();
			string text = option?.ToString() ?? string.Empty;
			return TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedConfigOptionDisplayRuntime", key, option) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedConfigOptionDisplayRuntime", key, text) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedConfigOptionDisplayTextRuntime", key, option) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedConfigOptionDisplayTextRuntime", key, text) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedOptionDisplayText", key, option, isChinese) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedOptionDisplayText", key, text, isChinese) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedOptionDisplayText", option, isChinese) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetLocalizedOptionDisplayText", text, isChinese) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetOptionDisplayText", key, option, isChinese) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetOptionDisplayText", key, text, isChinese) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetOptionDisplayText", option, isChinese) ?? TryInvokeStringCompatibleMethod(type, pluginInstance, "GetOptionDisplayText", text, isChinese);
		}

		private static string TryInvokeStringCompatibleMethod(Type declaringType, object target, string methodName, params object[] suppliedArguments)
		{
			if (!TryInvokeCompatibleMethod(declaringType, target, methodName, out var result, suppliedArguments) || result == null)
			{
				return null;
			}
			return (result as string) ?? result.ToString();
		}

		private static bool TryInvokeCompatibleMethod(Type declaringType, object target, string methodName, out object result, params object[] suppliedArguments)
		{
			result = null;
			if (declaringType == null || string.IsNullOrWhiteSpace(methodName))
			{
				return false;
			}
			MethodInfo[] array = (from method in declaringType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where string.Equals(method.Name, methodName, StringComparison.Ordinal)
				select method).OrderBy(delegate(MethodInfo method)
			{
				int num = method.GetParameters().Length;
				object[] array2 = suppliedArguments;
				return Math.Abs(num - ((array2 != null) ? array2.Length : 0));
			}).ThenBy((MethodInfo method) => method.GetParameters().Length).ToArray();
			foreach (MethodInfo methodInfo in array)
			{
				if ((methodInfo.IsStatic || target != null) && TryBuildCompatibleInvokeArguments(methodInfo, suppliedArguments, out var invokeArguments))
				{
					try
					{
						result = methodInfo.Invoke(methodInfo.IsStatic ? null : target, invokeArguments);
						return true;
					}
					catch (TargetParameterCountException)
					{
					}
					catch (ArgumentException)
					{
					}
					catch (TargetInvocationException)
					{
						return false;
					}
					catch
					{
						return false;
					}
				}
			}
			return false;
		}

		private static bool TryBuildCompatibleInvokeArguments(MethodInfo method, object[] suppliedArguments, out object[] invokeArguments)
		{
			invokeArguments = null;
			if (method == null)
			{
				return false;
			}
			suppliedArguments = suppliedArguments ?? Array.Empty<object>();
			ParameterInfo[] parameters = method.GetParameters();
			if (suppliedArguments.Length > parameters.Length)
			{
				return false;
			}
			object[] array = new object[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterInfo parameterInfo = parameters[i];
				if (i < suppliedArguments.Length)
				{
					if (!TryCoerceInvokeArgument(parameterInfo.ParameterType, suppliedArguments[i], out array[i]))
					{
						return false;
					}
					continue;
				}
				if (parameterInfo.HasDefaultValue)
				{
					array[i] = parameterInfo.DefaultValue;
					continue;
				}
				Type type = (parameterInfo.ParameterType.IsByRef ? parameterInfo.ParameterType.GetElementType() : parameterInfo.ParameterType);
				if (type == null)
				{
					return false;
				}
				if (Nullable.GetUnderlyingType(parameterInfo.ParameterType) != null || !type.IsValueType)
				{
					array[i] = null;
					continue;
				}
				return false;
			}
			invokeArguments = array;
			return true;
		}

		private static bool TryCoerceInvokeArgument(Type parameterType, object value, out object coercedValue)
		{
			coercedValue = null;
			if (parameterType == null)
			{
				return false;
			}
			if (parameterType.IsByRef)
			{
				parameterType = parameterType.GetElementType();
				if (parameterType == null)
				{
					return false;
				}
			}
			Type type = Nullable.GetUnderlyingType(parameterType) ?? parameterType;
			if (value == null)
			{
				if (Nullable.GetUnderlyingType(parameterType) != null || !type.IsValueType)
				{
					coercedValue = null;
					return true;
				}
				return false;
			}
			if (type.IsInstanceOfType(value))
			{
				coercedValue = value;
				return true;
			}
			try
			{
				if (type.IsEnum)
				{
					if (value is string value2)
					{
						coercedValue = Enum.Parse(type, value2, ignoreCase: true);
						return true;
					}
					coercedValue = Enum.ToObject(type, value);
					return true;
				}
				if (value is IConvertible && typeof(IConvertible).IsAssignableFrom(type))
				{
					coercedValue = Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private void RefreshUi()
		{
			RebuildPluginTabs();
			RebuildSectionButtons();
			RebuildEntryContent();
			UpdatePanelHeaders();
		}

		private void UpdatePanelHeaders()
		{
			ConfigSource selectedSource = GetSelectedSource();
			ConfigSection selectedSection = GetSelectedSection();
			if ((Object)(object)_panelTitleText != (Object)null)
			{
				((TMP_Text)_panelTitleText).text = selectedSource?.DisplayName ?? "Config";
			}
			if ((Object)(object)_contentTitleText != (Object)null)
			{
				string text = selectedSection?.DisplayName ?? string.Empty;
				((TMP_Text)_contentTitleText).text = ((!string.IsNullOrWhiteSpace(text)) ? ((selectedSource?.DisplayName ?? "Config") + " / " + text) : (selectedSource?.DisplayName ?? "Config"));
			}
		}

		private void RebuildPluginTabs()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00d1: Expected O, but got Unknown
			DestroyChildren((Transform)(object)_pluginTabsRect);
			if ((Object)(object)_pluginTabsRect == (Object)null)
			{
				return;
			}
			HorizontalLayoutGroup orAddComponent = GetOrAddComponent<HorizontalLayoutGroup>(((Component)_pluginTabsRect).gameObject);
			((HorizontalOrVerticalLayoutGroup)orAddComponent).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)orAddComponent).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)orAddComponent).childForceExpandWidth = false;
			((LayoutGroup)orAddComponent).childAlignment = (TextAnchor)3;
			ConfigSource[] array = _sources.ToArray();
			foreach (ConfigSource source in array)
			{
				bool flag = string.Equals(source.Id, _selectedSourceId, StringComparison.Ordinal);
				((UnityEvent)CreateButton((Transform)(object)_pluginTabsRect, source.DisplayName, flag ? ButtonSecondaryActiveColor : ButtonColor, 18f, 150f, 36f).onClick).AddListener((UnityAction)delegate
				{
					_selectedSourceId = source.Id;
					_selectedSectionKey = string.Empty;
					_isDirty = true;
					RefreshDataModel();
					RefreshUi();
				});
			}
		}

		private void RebuildSectionButtons()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			DestroyChildren((Transform)(object)_sectionListRect);
			if ((Object)(object)_sectionListRect == (Object)null)
			{
				return;
			}
			VerticalLayoutGroup orAddComponent = GetOrAddComponent<VerticalLayoutGroup>(((Component)_sectionListRect).gameObject);
			((HorizontalOrVerticalLayoutGroup)orAddComponent).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)orAddComponent).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)orAddComponent).childForceExpandWidth = true;
			((LayoutGroup)orAddComponent).padding = new RectOffset(0, 0, 0, 0);
			ConfigSource selectedSource = GetSelectedSource();
			if (selectedSource == null)
			{
				return;
			}
			foreach (ConfigSection section in selectedSource.Sections)
			{
				bool flag = string.Equals(section.Key, _selectedSectionKey, StringComparison.Ordinal);
				((UnityEvent)CreateButton((Transform)(object)_sectionListRect, section.DisplayName, flag ? ButtonActiveColor : ButtonColor, 18f, -1f, 42f).onClick).AddListener((UnityAction)delegate
				{
					_selectedSectionKey = section.Key;
					RefreshUi();
				});
			}
		}

		private void RebuildEntryContent()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			if (RebuildEntryContentManual())
			{
				return;
			}
			DestroyChildren((Transform)(object)_entryListRect);
			_visibleBindings.Clear();
			if ((Object)(object)_entryListRect == (Object)null)
			{
				return;
			}
			VerticalLayoutGroup orAddComponent = GetOrAddComponent<VerticalLayoutGroup>(((Component)_entryListRect).gameObject);
			((HorizontalOrVerticalLayoutGroup)orAddComponent).spacing = 12f;
			((HorizontalOrVerticalLayoutGroup)orAddComponent).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)orAddComponent).childForceExpandWidth = true;
			((LayoutGroup)orAddComponent).padding = new RectOffset(4, 12, 4, 18);
			GetOrAddComponent<ContentSizeFitter>(((Component)_entryListRect).gameObject).verticalFit = (FitMode)2;
			ConfigSection selectedSection = GetSelectedSection();
			if (selectedSection == null || selectedSection.Entries.Count == 0)
			{
				CreateEmptyState((Transform)(object)_entryListRect, GetNoVisibleEntriesLabel());
				RefreshEntryLayout();
				return;
			}
			foreach (ConfigEntryBase entry in selectedSection.Entries)
			{
				CreateEntryCard((Transform)(object)_entryListRect, GetSelectedSource(), entry);
			}
			RefreshEntryLayout();
		}

		private void CreateEntryCard(Transform parent, ConfigSource source, ConfigEntryBase entry)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject("EntryCard", parent);
			((Graphic)val.AddComponent<Image>()).color = CardColor;
			AddOutline(val, BorderColor);
			val.AddComponent<LayoutElement>().minHeight = 88f;
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).padding = new RectOffset(18, 18, 14, 14);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			GameObject val2 = CreateUiObject("HeaderRow", val.transform);
			HorizontalLayoutGroup obj2 = val2.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 16f;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((Component)CreateText(val2.transform, GetEntryDisplayName(source, entry), 21f, TextPrimaryColor, (TextAlignmentOptions)4097)).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
			EntryBinding entryBinding = new EntryBinding
			{
				Source = source,
				Entry = entry
			};
			Type entryValueType = GetEntryValueType(entry);
			List<object> options;
			if (entryValueType == typeof(bool))
			{
				CreateBoolControl(val2.transform, entryBinding);
			}
			else if (entryValueType == typeof(KeyCode))
			{
				CreateKeyControl(val2.transform, entryBinding);
			}
			else if (TryGetSelectableOptions(entry, entryValueType, out options))
			{
				CreateDropdownControl(val2.transform, entryBinding, options);
			}
			else
			{
				CreateInputControl(val2.transform, entryBinding, entryValueType);
			}
			string entryDescriptionText = GetEntryDescriptionText(source, entry);
			if (!string.IsNullOrWhiteSpace(entryDescriptionText))
			{
				CreateText(val.transform, entryDescriptionText, 15f, TextMutedColor, (TextAlignmentOptions)257);
			}
			string entrySupplementalText = GetEntrySupplementalText(source, entry);
			if (!string.IsNullOrWhiteSpace(entrySupplementalText))
			{
				TextMeshProUGUI obj3 = CreateText(val.transform, entrySupplementalText, 14f, TextMutedColor, (TextAlignmentOptions)257);
				((TMP_Text)obj3).textWrappingMode = (TextWrappingModes)1;
				((TMP_Text)obj3).overflowMode = (TextOverflowModes)0;
			}
			entryBinding.Refresh?.Invoke();
			_visibleBindings.Add(entryBinding);
		}

		private bool RebuildEntryContentManual()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			DestroyChildren((Transform)(object)_entryListRect);
			_visibleBindings.Clear();
			if ((Object)(object)_entryListRect == (Object)null)
			{
				return true;
			}
			VerticalLayoutGroup component = ((Component)_entryListRect).GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			ContentSizeFitter component2 = ((Component)_entryListRect).GetComponent<ContentSizeFitter>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			ConfigSource selectedSource = GetSelectedSource();
			ConfigSection selectedSection = GetSelectedSection();
			if (selectedSection == null || selectedSection.Entries.Count == 0)
			{
				CreateEmptyState((Transform)(object)_entryListRect, GetNoVisibleEntriesLabel());
				_entryListRect.sizeDelta = new Vector2(0f, 220f);
				RefreshEntryLayout();
				return true;
			}
			float num = 8f;
			foreach (ConfigEntryBase entry in selectedSection.Entries)
			{
				num += CreateEntryCardManual((Transform)(object)_entryListRect, selectedSource, entry, num) + 10f;
			}
			_entryListRect.sizeDelta = new Vector2(0f, Mathf.Max(num + 8f, 120f));
			RefreshEntryLayout();
			return true;
		}

		private float CreateEntryCardManual(Transform parent, ConfigSource source, ConfigEntryBase entry, float topOffset)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: 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)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			string entryDescriptionText = GetEntryDescriptionText(source, entry);
			bool flag = !string.IsNullOrWhiteSpace(entryDescriptionText);
			string entrySupplementalText = GetEntrySupplementalText(source, entry);
			bool num = !string.IsNullOrWhiteSpace(entrySupplementalText);
			float num2 = (flag ? 108f : 74f);
			if (num)
			{
				num2 += 128f;
			}
			GameObject val = CreateUiObject("EntryCardManual", parent);
			RectTransform rectTransform = GetRectTransform(val);
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.offsetMin = new Vector2(4f, 0f - topOffset - num2);
			rectTransform.offsetMax = new Vector2(-12f, 0f - topOffset);
			((Graphic)val.AddComponent<Image>()).color = CardColor;
			AddOutline(val, BorderColor);
			RectTransform rectTransform2 = ((TMP_Text)CreateText(val.transform, GetEntryDisplayName(source, entry), 20f, TextPrimaryColor, (TextAlignmentOptions)257)).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 1f);
			rectTransform2.anchorMax = new Vector2(1f, 1f);
			rectTransform2.pivot = new Vector2(0f, 1f);
			rectTransform2.sizeDelta = new Vector2(-332f, 28f);
			rectTransform2.anchoredPosition = new Vector2(18f, -14f);
			GameObject val2 = CreateUiObject("ControlHost", val.transform);
			RectTransform rectTransform3 = GetRectTransform(val2);
			rectTransform3.anchorMin = new Vector2(1f, 1f);
			rectTransform3.anchorMax = new Vector2(1f, 1f);
			rectTransform3.pivot = new Vector2(1f, 1f);
			rectTransform3.sizeDelta = new Vector2(286f, 38f);
			rectTransform3.anchoredPosition = new Vector2(-18f, -12f);
			EntryBinding entryBinding = new EntryBinding
			{
				Source = source,
				Entry = entry
			};
			Type entryValueType = GetEntryValueType(entry);
			List<object> options;
			if (entryValueType == typeof(bool))
			{
				CreateBoolControl(val2.transform, entryBinding);
			}
			else if (entryValueType == typeof(KeyCode))
			{
				CreateKeyControl(val2.transform, entryBinding);
			}
			else if (TryGetSelectableOptions(entry, entryValueType, out options))
			{
				CreateDropdownControl(val2.transform, entryBinding, options);
			}
			else
			{
				CreateInputControl(val2.transform, entryBinding, entryValueType);
			}
			RectTransform val3 = (RectTransform)((val2.transform.childCount > 0) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)val3 != (Object)null)
			{
				val3.anchorMin = new Vector2(0.5f, 0.5f);
				val3.anchorMax = new Vector2(0.5f, 0.5f);
				val3.pivot = new Vector2(0.5f, 0.5f);
				val3.anchoredPosition = Vector2.zero;
			}
			float num3 = -48f;
			if (flag)
			{
				TextMeshProUGUI obj = CreateText(val.transform, entryDescriptionText, 14f, TextMutedColor, (TextAlignmentOptions)257);
				RectTransform rectTransform4 = ((TMP_Text)obj).rectTransform;
				rectTransform4.anchorMin = new Vector2(0f, 1f);
				rectTransform4.anchorMax = new Vector2(1f, 1f);
				rectTransform4.pivot = new Vector2(0f, 1f);
				rectTransform4.sizeDelta = new Vector2(-36f, 40f);
				rectTransform4.anchoredPosition = new Vector2(18f, num3);
				((TMP_Text)obj).textWrappingMode = (TextWrappingModes)1;
				((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
				num3 -= 46f;
			}
			if (num)
			{
				TextMeshProUGUI obj2 = CreateText(val.transform, entrySupplementalText, 13.5f, TextMutedColor, (TextAlignmentOptions)257);
				RectTransform rectTransform5 = ((TMP_Text)obj2).rectTransform;
				rectTransform5.anchorMin = new Vector2(0f, 1f);
				rectTransform5.anchorMax = new Vector2(1f, 1f);
				rectTransform5.pivot = new Vector2(0f, 1f);
				rectTransform5.sizeDelta = new Vector2(-36f, 116f);
				rectTransform5.anchoredPosition = new Vector2(18f, num3);
				((TMP_Text)obj2).textWrappingMode = (TextWrappingModes)1;
				((TMP_Text)obj2).overflowMode = (TextOverflowModes)0;
			}
			entryBinding.Refresh?.Invoke();
			_visibleBindings.Add(entryBinding);
			return num2;
		}

		private void CreateBoolControl(Transform parent, EntryBinding binding)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject("ToggleRoot", parent);
			GetRectTransform(val).sizeDelta = new Vector2(78f, 30f);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredWidth = 78f;
			obj.preferredHeight = 30f;
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = FieldColor;
			AddOutline(val, BorderColor);
			Toggle toggle = val.AddComponent<Toggle>();
			((Selectable)toggle).targetGraphic = (Graphic)(object)val2;
			GameObject val3 = CreateUiObject("Checkmark", val.transform);
			RectTransform rectTransform = GetRectTransform(val3);
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.sizeDelta = new Vector2(50f, 22f);
			Image image2 = val3.AddComponent<Image>();
			((Graphic)image2).color = ButtonActiveColor;
			toggle.graphic = (Graphic)(object)image2;
			((UnityEvent<bool>)(object)toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
			{
				if (!binding.SuppressCallbacks)
				{
					TryAssignBoxedValue(binding.Entry, value);
					SaveEntryOwner(binding.Entry);
					binding.Refresh?.Invoke();
				}
			});
			binding.Refresh = delegate
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				binding.SuppressCallbacks = true;
				object boxedValue = GetBoxedValue(binding.Entry);
				bool flag = default(bool);
				int num;
				if (boxedValue is bool)
				{
					flag = (bool)boxedValue;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag2 = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				toggle.isOn = flag2;
				((Graphic)image2).color = (flag2 ? ButtonActiveColor : ButtonColor);
				binding.SuppressCallbacks = false;
			};
		}

		private void CreateKeyControl(Transform parent, EntryBinding binding)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			Button val = CreateButton(parent, string.Empty, FieldColor, 17f, 210f, 34f);
			TextMeshProUGUI componentInChildren = ((Component)val).GetComponentInChildren<TextMeshProUGUI>();
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				_pendingKeyCaptureEntry = binding.Entry;
				_pendingKeyCaptureText = componentInChildren;
				RefreshVisibleBindings();
			});
			binding.Refresh = delegate
			{
				binding.SuppressCallbacks = true;
				if (_pendingKeyCaptureEntry == binding.Entry && (Object)(object)_pendingKeyCaptureText == (Object)(object)componentInChildren)
				{
					((TMP_Text)componentInChildren).text = "鎸変换鎰忛敭...";
				}
				else
				{
					((TMP_Text)componentInChildren).text = GetDisplayValueText(binding.Entry);
				}
				binding.SuppressCallbacks = false;
			};
		}

		private void CreateDropdownControl(Transform parent, EntryBinding binding, List<object> options)
		{
			TMP_Dropdown tMP_Dropdown = CreateDropdown(parent, 270f, 34f);
			List<string> list = options.Select((object option) => GetOptionDisplayText(binding.Source, binding.Entry, option)).ToList();
			tMP_Dropdown.ClearOptions();
			tMP_Dropdown.AddOptions(list);
			((UnityEvent<int>)(object)tMP_Dropdown.onValueChanged).AddListener((UnityAction<int>)delegate(int index)
			{
				if (!binding.SuppressCallbacks && index >= 0 && index < options.Count)
				{
					TryAssignBoxedValue(binding.Entry, options[index]);
					SaveEntryOwner(binding.Entry);
					binding.Refresh?.Invoke();
				}
			});
			binding.Refresh = delegate
			{
				binding.SuppressCallbacks = true;
				object boxedValue = GetBoxedValue(binding.Entry);
				int valueWithoutNotify = 0;
				for (int i = 0; i < options.Count; i++)
				{
					if (ValuesEqual(options[i], boxedValue))
					{
						valueWithoutNotify = i;
						break;
					}
				}
				tMP_Dropdown.SetValueWithoutNotify(valueWithoutNotify);
				tMP_Dropdown.RefreshShownValue();
				binding.SuppressCallbacks = false;
			};
		}

		private void CreateInputControl(Transform parent, EntryBinding binding, Type valueType)
		{
			TMP_InputField tMP_InputField = CreateInputField(parent, 270f, 34f);
			((UnityEvent<string>)(object)tMP_InputField.onEndEdit).AddListener((UnityAction<string>)delegate(string value)
			{
				if (!binding.SuppressCallbacks)
				{
					if (!TryAssignTextValue(binding.Entry, valueType, value))
					{
						binding.Refresh?.Invoke();
					}
					else
					{
						SaveEntryOwner(binding.Entry);
						binding.Refresh?.Invoke();
					}
				}
			});
			binding.Refresh = delegate
			{
				binding.SuppressCallbacks = true;
				tMP_InputField.SetTextWithoutNotify(GetDisplayValueText(binding.Entry));
				binding.SuppressCallbacks = false;
			};
		}

		private void RefreshVisibleBindings()
		{
			foreach (EntryBinding visibleBinding in _visibleBindings)
			{
				visibleBinding.Refresh?.Invoke();
			}
		}

		private void RefreshEntryLayout()
		{
			if ((Object)(object)_entryListRect == (Object)null)
			{
				return;
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(_entryListRect);
			ScrollRect componentInParent = ((Component)_entryListRect).GetComponentInParent<ScrollRect>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				RectTransform component = ((Component)componentInParent).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)component != (Object)(object)_entryListRect)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(component);
				}
			}
		}

		private ConfigSource GetSelectedSource()
		{
			return _sources.FirstOrDefault((ConfigSource source) => string.Equals(source.Id, _selectedSourceId, StringComparison.Ordinal));
		}

		private ConfigSection GetSelectedSection()
		{
			return GetSelectedSource()?.Sections.FirstOrDefault((ConfigSection section) => string.Equals(section.Key, _selectedSectionKey, StringComparison.Ordinal));
		}

		private ConfigSource GetSourceForEntry(ConfigEntryBase entry)
		{
			if (entry == null)
			{
				return null;
			}
			return _sources.FirstOrDefault((ConfigSource source) => source.Sections.Any((ConfigSection section) => section.Entries.Contains(entry)));
		}

		private string GetOptionDisplayText(ConfigSource source, ConfigEntryBase entry, object option)
		{
			if (option?.ToString() == null)
			{
				_ = string.Empty;
			}
			object obj;
			if (entry == null)
			{
				obj = null;
			}
			else
			{
				ConfigDefinition definition = entry.Definition;
				obj = ((definition != null) ? definition.Key : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			string arg = (string)obj;
			string text = source?.Localizer?.LocalizeOptionDisplayText?.Invoke(arg, option);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return GetOptionDisplayText(entry, option);
		}

		private static string GetEntryDisplayName(ConfigSource source, ConfigEntryBase entry)
		{
			if (entry == null || entry.Definition == (ConfigDefinition)null)
			{
				return string.Empty;
			}
			string key = entry.Definition.Key;
			string text = source?.Localizer?.LocalizeKeyName?.Invoke(key);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return key;
		}

		private static string GetSectionDisplayName(ConfigSource source, string section)
		{
			if (string.IsNullOrWhiteSpace(section))
			{
				return "General";
			}
			string text = source?.Localizer?.LocalizeSectionName?.Invoke(section);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return section;
		}

		private static int GetEntrySortIndex(ConfigSource source, ConfigEntryBase entry)
		{
			if (source == null || !source.IsShootZombies)
			{
				return int.MaxValue;
			}
			return Plugin.GetOwnedConfigEntrySortIndexRuntime(entry);
		}

		private static int GetSectionSortIndex(ConfigSource source, string section)
		{
			if (source == null || !source.IsShootZombies)
			{
				return int.MaxValue;
			}
			return Plugin.GetOwnedConfigSectionSortIndexRuntime(section);
		}

		private string GetDisplayValueText(ConfigEntryBase entry)
		{
			object boxedValue = GetBoxedValue(entry);
			if (boxedValue == null)
			{
				return string.Empty;
			}
			if (boxedValue is float num)
			{
				if (ShouldRenderWithSingleDecimal(entry))
				{
					return num.ToString("0.0", CultureInfo.InvariantCulture);
				}
				return num.ToString("0.###", CultureInfo.InvariantCulture);
			}
			if (boxedValue is double num2)
			{
				if (ShouldRenderWithSingleDecimal(entry))
				{
					return num2.ToString("0.0", CultureInfo.InvariantCulture);
				}
				return num2.ToString("0.###", CultureInfo.InvariantCulture);
			}
			return boxedValue.ToString();
		}

		private static string GetOptionDisplayText(ConfigEntryBase entry, object option)
		{
			string text = option?.ToString() ?? string.Empty;
			if (entry == Plugin.ConfigPanelTheme)
			{
				return GetPanelThemeOptionDisplayText(text);
			}
			if (entry == Plugin.AkSoundSelection)
			{
				return GetAkSoundOptionDisplayText(text);
			}
			if (entry == Plugin.WeaponSelection)
			{
				return text switch
				{
					"AK47" => "AK47", 
					"HK416" => "HK416", 
					"MPX" => "MPX", 
					_ => text, 
				};
			}
			if (entry == Plugin.ZombieBehaviorDifficulty)
			{
				return Plugin.GetZombieBehaviorDifficultyDisplayNameRuntime(text);
			}
			return text;
		}

		private static string GetEntryDisplayName(bool isShootZombies, ConfigEntryBase entry)
		{
			if (entry == null || entry.Definition == (ConfigDefinition)null)
			{
				return string.Empty;
			}
			if (!isShootZombies)
			{
				return entry.Definition.Key;
			}
			return Plugin.GetLocalizedConfigKeyDisplayRuntime(entry.Definition.Key);
		}

		private static string GetEntryDescriptionText(ConfigSource source, ConfigEntryBase entry)
		{
			if (source != null && ((entry != null) ? entry.Definition : null) != (ConfigDefinition)null)
			{
				string text = source.Localizer?.LocalizeDescription?.Invoke(entry.Definition.Key);
				if (!string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
			}
			object obj;
			if (entry == null)
			{
				obj = null;
			}
			else
			{
				ConfigDescription description = entry.Description;
				obj = ((description != null) ? description.Description : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			return (string)obj;
		}

		private static string GetEntrySupplementalText(ConfigSource source, ConfigEntryBase entry)
		{
			if (source != null && source.IsShootZombies && entry == Plugin.ZombieBehaviorDifficulty)
			{
				return Plugin.GetZombieBehaviorDifficultyDetailsRuntime();
			}
			return string.Empty;
		}

		private static string GetSectionDisplayName(bool isShootZombies, string section)
		{
			if (string.IsNullOrWhiteSpace(section))
			{
				return "General";
			}
			if (!isShootZombies)
			{
				return section;
			}
			return Plugin.GetLocalizedConfigSectionDisplayRuntime(section);
		}

		private static int GetEntrySortIndex(bool isShootZombies, ConfigEntryBase entry)
		{
			if (!isShootZombies)
			{
				return int.MaxValue;
			}
			return Plugin.GetOwnedConfigEntrySortIndexRuntime(entry);
		}

		private static int GetSectionSortIndex(bool isShootZombies, string section)
		{
			if (!isShootZombies)
			{
				return int.MaxValue;
			}
			return Plugin.GetOwnedConfigSectionSortIndexRuntime(section);
		}

		private static object GetBoxedValue(ConfigEntryBase entry)
		{
			return ((object)entry)?.GetType().GetProperty("BoxedValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(entry);
		}

		private static bool TryAssignBoxedValue(ConfigEntryBase entry, object value)
		{
			if (entry == null)
			{
				return false;
			}
			try
			{
				((object)entry).GetType().GetProperty("BoxedValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(entry, value);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private bool TryAssignTextValue(ConfigEntryBase entry, Type valueType, string text)
		{
			if (entry == null)
			{
				return false;
			}
			try
			{
				if (valueType == typeof(string))
				{
					TryAssignBoxedValue(entry, text ?? string.Empty);
					return true;
				}
				if (valueType == typeof(int))
				{
					if (!int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && !int.TryParse(text, NumberStyles.Integer, CultureInfo.CurrentCulture, out result))
					{
						return false;
					}
					if (TryGetNumericRange(entry, out var min, out var max))
					{
						result = Mathf.Clamp(result, Mathf.RoundToInt((float)min), Mathf.RoundToInt((float)max));
					}
					return TryAssignBoxedValue(entry, result);
				}
				if (valueType == typeof(float))
				{
					if (!float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && !float.TryParse(text, NumberStyles.Float, CultureInfo.CurrentCulture, out result2))
					{
						return false;
					}
					if (TryGetNumericRange(entry, out var min2, out var max2))
					{
						result2 = Mathf.Clamp(result2, (float)min2, (float)max2);
					}
					return TryAssignBoxedValue(entry, result2);
				}
				if (valueType == typeof(double))
				{
					if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) && !double.TryParse(text, NumberStyles.Float, CultureInfo.CurrentCulture, out result3))
					{
						return false;
					}
					if (TryGetNumericRange(entry, out var min3, out var max3))
					{
						result3 = Math.Min(Math.Max(result3, min3), max3);
					}
					return TryAssignBoxedValue(entry, result3);
				}
				if (valueType.IsEnum)
				{
					object value = Enum.Parse(valueType, text, ignoreCase: true);
					return TryAssignBoxedValue(entry, value);
				}
				entry.SetSerializedValue(text ?? string.Empty);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private void SaveEntryOwner(ConfigEntryBase entry)
		{
			ConfigSource configSource = _sources.ToArray().FirstOrDefault((ConfigSource source) => source.Sections.Any((ConfigSection section) => section.Entries.Contains(entry)));
			if (configSource != null && configSource.IsShootZombies)
			{
				_owner?.SaveOwnedConfigRuntime();
			}
			else if (configSource != null)
			{
				ConfigFile config = configSource.Config;
				if (config != null)
				{
					config.Save();
				}
			}
			if (entry == Plugin.ConfigPanelTheme)
			{
				SyncThemeFromConfig();
				_isDirty = true;
			}
		}

		private static Type GetEntryValueType(ConfigEntryBase entry)
		{
			Type type = ((object)entry)?.GetType();
			while (type != null)
			{
				if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ConfigEntry<>))
				{
					return type.GetGenericArguments()[0];
				}
				type = type.BaseType;
			}
			return GetBoxedValue(entry)?.GetType() ?? typeof(string);
		}

		private static bool TryGetSelectableOptions(ConfigEntryBase entry, Type valueType, out List<object> options)
		{
			options = new List<object>();
			if (valueType.IsEnum)
			{
				options.AddRange(Enum.GetValues(valueType).Cast<object>());
				return options.Count > 0;
			}
			if (entry != null)
			{
				string[] ownedSelectableConfigValuesRuntime = Plugin.GetOwnedSelectableConfigValuesRuntime(entry);
				if (ownedSelectableConfigValuesRuntime.Length != 0)
				{
					options.AddRange(ownedSelectableConfigValuesRuntime.Cast<object>());
					return true;
				}
			}
			object obj;
			if (entry == null)
			{
				obj = null;
			}
			else
			{
				ConfigDescription description = entry.Description;
				obj = ((description != null) ? description.AcceptableValues : null);
			}
			object obj2 = obj;
			if (obj2 == null)
			{
				return false;
			}
			if ((obj2.GetType().GetProperty("AcceptableValues", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2) ?? obj2.GetType().GetField("AcceptableValues", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2)) is IEnumerable enumerable)
			{
				foreach (object item in enumerable)
				{
					options.Add(item);
				}
			}
			return options.Count > 0;
		}

		private static bool TryGetNumericRange(ConfigEntryBase entry, out double min, out double max)
		{
			min = 0.0;
			max = 0.0;
			object obj;
			if (entry == null)
			{
				obj = null;
			}
			else
			{
				ConfigDescription description = entry.Description;
				obj = ((description != null) ? description.AcceptableValues : null);
			}
			object obj2 = obj;
			if (obj2 == null)
			{
				return false;
			}
			object obj3 = obj2.GetType().GetProperty("MinValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2) ?? obj2.GetType().GetField("MinValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2);
			object obj4 = obj2.GetType().GetProperty("MaxValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2) ?? obj2.GetType().GetField("MaxValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2);
			if (obj3 == null || obj4 == null)
			{
				return false;
			}
			try
			{
				min = Convert.ToDouble(obj3, CultureInfo.InvariantCulture);
				max = Convert.ToDouble(obj4, CultureInfo.InvariantCulture);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static int CountFractionDigits(double value)
		{
			string text = Math.Abs(value).ToString("0.###", CultureInfo.InvariantCulture);
			int num = text.IndexOf('.');
			if (num < 0)
			{
				return 0;
			}
			return text.Length - num - 1;
		}

		private static string NormalizeNumericFormatEntryKey(string key)
		{
			if (string.IsNullOrWhiteSpace(key))
			{
				return string.Empty;
			}
			return key.Trim();
		}

		private static bool IsFogSpeedEntry(ConfigEntryBase entry)
		{
			object key;
			if (entry == null)
			{
				key = null;
			}
			else
			{
				ConfigDefinition definition = entry.Definition;
				key = ((definition != null) ? definition.Key : null);
			}
			string a = NormalizeNumericFormatEntryKey((string)key);
			if (!string.Equals(a, "Fog Speed", StringComparison.OrdinalIgnoreCase) && !string.Equals(a, "FogSpeed", StringComparison.OrdinalIgnoreCase) && !string.Equals(a, "毒雾移动速度", StringComparison.Ordinal))
			{
				return string.Equals(a, "毒速", StringComparison.Ordinal);
			}
			return true;
		}

		private static bool ShouldRenderWithSingleDecimal(ConfigEntryBase entry)
		{
			if (entry != Plugin.FireInterval)
			{
				return IsFogSpeedEntry(entry);
			}
			return true;
		}

		private static int GetNumericStepScale(ConfigEntryBase entry, Type entryValueType, double min, double max)
		{
			if (entryValueType == typeof(int))
			{
				return 1;
			}
			if (ShouldRenderWithSingleDecimal(entry))
			{
				return 10;
			}
			double value = 0.0;
			try
			{
				object boxedValue = GetBoxedValue(entry);
				if (boxedValue is float num)
				{
					value = num;
				}
				else if (boxedValue is double num2)
				{
					value = num2;
				}
				else if (boxedValue is int)
				{
					int num3 = (int)boxedValue;
					value = num3;
				}
			}
			catch
			{
			}
			return Math.Max(CountFractionDigits(min), Math.Max(CountFractionDigits(max), CountFractionDigits(value))) switch
			{
				1 => 10, 
				2 => 100, 
				3 => 1000, 
				_ => 1, 
			};
		}

		private static bool TryGetScaledNumericRange(ConfigEntryBase entry, Type entryValueType, out int scaledMin, out int scaledMax, out int scale)
		{
			scaledMin = 0;
			scaledMax = 0;
			scale = 1;
			if (!TryGetNumericRange(entry, out var min, out var max))
			{
				return false;
			}
			scale = GetNumericStepScale(entry, entryValueType, min, max);
			scaledMin = Mathf.RoundToInt((float)(min * (double)scale));
			scaledMax = Mathf.RoundToInt((float)(max * (double)scale));
			if (scaledMax < scaledMin)
			{
				int num = scaledMax;
				int num2 = scaledMin;
				scaledMin = num;
				scaledMax = num2;
			}
			return true;
		}

		private static int GetScaledNumericValue(ConfigEntryBase entry, Type entryValueType, int scale)
		{
			object boxedValue = GetBoxedValue(entry);
			if (entryValueType == typeof(int))
			{
				return Convert.ToInt32(boxedValue ?? ((object)0), CultureInfo.InvariantCulture);
			}
			if (entryValueType == typeof(double))
			{
				return Mathf.RoundToInt((float)(Convert.ToDouble(boxedValue ?? ((object)0.0), CultureInfo.InvariantCulture) * (double)scale));
			}
			return Mathf.RoundToInt(Convert.ToSingle(boxedValue ?? ((object)0f), CultureInfo.InvariantCulture) * (float)scale);
		}

		private static bool TryAssignScaledNumericValue(ConfigEntryBase entry, Type entryValueType, int scaledValue, int scale)
		{
			if (entryValueType == typeof(int))
			{
				return TryAssignBoxedValue(entry, scaledValue);
			}
			if (entryValueType == typeof(double))
			{
				return TryAssignBoxedValue(entry, (double)scaledValue / (double)scale);
			}
			return TryAssignBoxedValue(entry, (float)scaledValue / (float)scale);
		}

		private static bool ValuesEqual(object left, object right)
		{
			if (left == null && right == null)
			{
				return true;
			}
			if (left == null || right == null)
			{
				return false;
			}
			if (left.Equals(right))
			{
				return true;
			}
			return string.Equals(left.ToString(), right.ToString(), StringComparison.OrdinalIgnoreCase);
		}

		private void EnsureWindowRectInitialized(bool forceReset = false)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!forceReset && ((Rect)(ref _windowRect)).width > 100f && ((Rect)(ref _windowRect)).height > 100f)
			{
				ClampWindowRectToScreen();
				return;
			}
			float num = Mathf.Clamp((float)Screen.width * 0.64f, 900f, 1360f);
			float num2 = Mathf.Clamp((float)Screen.height * 0.52f, 460f, 760f);
			_windowRect = new Rect(((float)Screen.width - num) * 0.5f, ((float)Screen.height - num2) * 0.5f, num, num2);
			ClampWindowRectToScreen();
		}

		private void ClampWindowRectToScreen()
		{
			if (!(((Rect)(ref _windowRect)).width <= 0f) && !(((Rect)(ref _windowRect)).height <= 0f))
			{
				float num = Mathf.Max(0f, (float)Screen.width - ((Rect)(ref _windowRect)).width);
				float num2 = Mathf.Max(0f, (float)Screen.height - ((Rect)(ref _windowRect)).height);
				((Rect)(ref _windowRect)).x = Mathf.Clamp(((Rect)(ref _windowRect)).x, 0f, num);
				((Rect)(ref _windowRect)).y = Mathf.Clamp(((Rect)(ref _windowRect)).y, 0f, num2);
			}
		}

		private bool HandleOutsideWindowClick()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			if (current == null || (int)current.type != 0 || current.button < 0)
			{
				return false;
			}
			if (((Rect)(ref _windowRect)).Contains(current.mousePosition))
			{
				return false;
			}
			Close();
			current.Use();
			return true;
		}

		private void RenderImmediateGui()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!_isOpen)
			{
				return;
			}
			EnsureWindowRectInitialized();
			EnsureImmediateStyles();
			if (_pendingRenderDiagnostic)
			{
				_pendingRenderDiagnostic = false;
				if (Plugin.ShouldEmitVerboseInfoLogsRuntime())
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)$"[ShootZombies] LobbyConfigPanel OnGUI active. sources={_sources.Count}, selectedSource={_selectedSourceId}, selectedSection={_selectedSectionKey}, rect={_windowRect}.");
					}
				}
			}
			GUI.depth = -1000;
			Color color = GUI.color;
			GUI.color = Color.white;
			GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)GetSolidTexture(GetImmediateBackdropColor()));
			if (HandleOutsideWindowClick())
			{
				GUI.color = color;
				GUIUtility.ExitGUI();
			}
			else
			{
				_windowRect = GUI.Window(GetHashCode(), _windowRect, new WindowFunction(DrawImmediateWindow), string.Empty, _immediateWindowStyle);
				GUI.color = color;
				ClampWindowRectToScreen();
			}
		}

		private void MaybeLogDiagnostics()
		{
			if (!_isOpen || Time.unscaledTime < _nextDiagnosticLogTime)
			{
				return;
			}
			ConfigSource selectedSource = GetSelectedSource();
			ConfigSection selectedSection = GetSelectedSection();
			int valueOrDefault = (selectedSource?.Sections?.Count).GetValueOrDefault();
			int valueOrDefault2 = (selectedSection?.Entries?.Count).GetValueOrDefault();
			string text = string.Format("{0}|{1}|{2}|{3}|{4}", _sources.Count, selectedSource?.DisplayName ?? "<none>", valueOrDefault, selectedSection?.DisplayName ?? "<none>", valueOrDefault2);
			if (!string.Equals(text, _lastDiagnosticSummary, StringComparison.Ordinal))
			{
				_lastDiagnosticSummary = text;
				if (Plugin.ShouldEmitVerboseInfoLogsRuntime())
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)string.Format("[ShootZombies] LobbyConfigPanel data sources={0}, selectedSource={1}, sections={2}, selectedSection={3}, entries={4}.", _sources.Count, selectedSource?.DisplayName ?? "<none>", valueOrDefault, selectedSection?.DisplayName ?? "<none>", valueOrDefault2));
					}
				}
			}
			_nextDiagnosticLogTime = Time.unscaledTime + 5f;
		}

		private void DrawImmediateWindow(int windowId)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle immediateLabelStyle = _immediateLabelStyle;
			GUIStyle immediateTitleStyle = _immediateTitleStyle;
			GUIStyle immediateDescriptionStyle = _immediateDescriptionStyle;
			GUIStyle immediateCardStyle = _immediateCardStyle;
			float width = ((Rect)(ref _windowRect)).width;
			float height = ((Rect)(ref _windowRect)).height;
			Color backgroundColor = GUI.backgroundColor;
			Color contentColor = GUI.contentColor;
			GUI.Label(new Rect(14f, 8f, width - 136f, 20f), GetSelectedSource()?.DisplayName ?? "Config", immediateTitleStyle);
			Rect val = new Rect(width - 78f, 6f, 32f, 22f);
			GUI.backgroundColor = GetImmediateThemeButtonColor(_panelTheme, active: true);
			GUI.contentColor = GetImmediateThemeButtonTextColor(_panelTheme, active: true);
			if (GUI.Button(val, GetThemeToggleIcon(), _immediateButtonStyle))
			{
				ToggleTheme();
				GUI.backgroundColor = backgroundColor;
				GUI.contentColor = contentColor;
				GUIUtility.ExitGUI();
				return;
			}
			GUI.backgroundColor = GetImmediateButtonColor(active: true);
			GUI.contentColor = contentColor;
			if (GUI.Button(new Rect(width - 38f, 6f, 26f, 22f), "x", _immediateButtonStyle))
			{
				GUI.backgroundColor = backgroundColor;
				GUI.contentColor = contentColor;
				Close();
				GUIUtility.ExitGUI();
				return;
			}
			GUI.backgroundColor = backgroundColor;
			GUI.contentColor = contentColor;
			float num = 34f;
			float num2 = 12f;
			float num3 = height - num - 14f;
			float num4 = 156f;
			float num5 = width - num4 - 34f;
			GUILayout.BeginArea(new Rect(num2, num, width - num2 * 2f, 30f));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			ConfigSource[] array = _sources.ToArray();
			foreach (ConfigSource configSource in array)
			{
				Color backgroundColor2 = GUI.backgroundColor;
				GUI.backgroundColor = GetImmediateButtonColor(string.Equals(configSource.Id, _selectedSourceId, StringComparison.Ordinal));
				if (GUILayout.Button(configSource.DisplayName, _immediateButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(124f),
					GUILayout.Height(24f)
				}))
				{
					_selectedSourceId = configSource.Id;
					_selectedSectionKey = string.Empty;
					RefreshDataModel();
				}
				GUI.backgroundColor = backgroundColor2;
				GUILayout.Space(6f);
			}
			GUILayout.EndHorizontal();
			GUILayout.EndArea();
			GUI.Box(new Rect(num2, num + 32f, num4, num3 - 32f), GUIContent.none, _immediatePaneStyle);
			GUI.Label(new Rect(num2 + 8f, num + 40f, num4 - 16f, 22f), GetSectionsLabel(), immediateTitleStyle);
			ConfigSource selectedSource = GetSelectedSource();
			float num6 = num + 70f;
			if (selectedSource != null)
			{
				ConfigSection[] array2 = selectedSource.Sections.ToArray();
				foreach (ConfigSection configSection in array2)
				{
					Color backgroundColor3 = GUI.backgroundColor;
					GUI.backgroundColor = GetImmediateButtonColor(string.Equals(configSection.Key, _selectedSectionKey, StringComparison.Ordinal));
					if (GUI.Button(new Rect(num2 + 12f, num6, num4 - 24f, 32f), configSection.DisplayName, _immediateButtonStyle))
					{
						_selectedSectionKey = configSection.Key;
					}
					GUI.backgroundColor = backgroundColor3;
					num6 += 38f;
				}
			}
			float num7 = num2 + num4 + 10f;
			GUI.Box(new Rect(num7, num + 32f, num5, num3 - 32f), GUIContent.none, _immediatePaneStyle);
			string text = GetSelectedSection()?.DisplayName ?? string.Empty;
			string text2 = ((!string.IsNullOrWhiteSpace(text)) ? ((selectedSource?.DisplayName ?? "Config") + " / " + text) : (selectedSource?.DisplayName ?? "Config"));
			GUI.Label(new Rect(num7 + 10f, num + 40f, num5 - 20f, 24f), text2, immediateTitleStyle);
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(num7 + 10f, num + 72f, num5 - 20f, num3 - 82f);
			GUILayout.BeginArea(val2);
			_entryScrollPosition = GUILayout.BeginScrollView(_entryScrollPosition, false, true, GUIStyle.none, GUI.skin.verticalScrollbar, Array.Empty<GUILayoutOption>());
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(((Rect)(ref val2)).width - 22f) });
			ConfigSection selectedSection = GetSelectedSection();
			if (selectedSection == null || selectedSection.Entries.Count == 0)
			{
				GUILayout.Space(8f);
				GUILayout.Label(GetNoVisibleEntriesLabel(), immediateLabelStyle, Array.Empty<GUILayoutOption>());
			}
			else
			{
				ConfigEntryBase[] array3 = selectedSection.Entries.ToArray();
				foreach (ConfigEntryBase entry in array3)
				{
					DrawImmediateEntry(selectedSource, entry, immediateLabelStyle, immediateTitleStyle, immediateDescriptionStyle, immediateCardStyle);
					GUILayout.Space(8f);
				}
			}
			GUILayout.EndVertical();
			GUILayout.EndScrollView();
			GUILayout.EndArea();
			GUI.DragWindow(new Rect(0f, 0f, width - 54f, 36f));
		}

		private void DrawImmediateEntry(ConfigSource source, ConfigEntryBase entry, GUIStyle labelStyle, GUIStyle titleStyle, GUIStyle descriptionStyle, GUIStyle cardStyle)
		{
			float immediateEntryTitleWidth = GetImmediateEntryTitleWidth();
			float immediateDescriptionWidth = GetImmediateDescriptionWidth();
			GUILayout.BeginVertical(cardStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.Label(GetEntryDisplayName(source, entry), titleStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(immediateEntryTitleWidth) });
			GUILayout.Space(12f);
			DrawImmediateEntryControlStableV2(entry);
			GUILayout.EndHorizontal();
			string entryDescriptionText = GetEntryDescriptionText(source, entry);
			if (!string.IsNullOrWhiteSpace(entryDescriptionText))
			{
				GUILayout.Space(4f);
				GUILayout.Label(entryDescriptionText, descriptionStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(immediateDescriptionWidth) });
			}
			string entrySupplementalText = GetEntrySupplementalText(source, entry);
			if (!string.IsNullOrWhiteSpace(entrySupplementalText))
			{
				GUILayout.Space(6f);
				GUILayout.Label(entrySupplementalText, descriptionStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(immediateDescriptionWidth) });
			}
			GUILayout.EndVertical();
		}

		private void DrawImmediateEntryControlStable(ConfigEntryBase entry)
		{
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Invalid comparison between Unknown and I4
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Invalid comparison between Unknown and I4
			Type entryValueType = GetEntryValueType(entry);
			if (entryValueType == typeof(bool))
			{
				object boxedValue2 = GetBoxedValue(entry);
				bool flag = default(bool);
				int num;
				if (boxedValue2 is bool)
				{
					flag = (bool)boxedValue2;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag2 = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				bool flag3 = GUILayout.Toggle(flag2, GetToggleStateLabel(flag2), (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(92f),
					GUILayout.Height(28f)
				});
				if (flag3 != flag2)
				{
					TryAssignBoxedValue(entry, flag3);
					SaveEntryOwner(entry);
				}
			}
			else if (entryValueType == typeof(KeyCode))
			{
				if (GUILayout.Button((_pendingKeyCaptureEntry == entry) ? "鎸変换鎰忛敭..." : GetDisplayValueText(entry), (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(280f),
					GUILayout.Height(28f)
				}))
				{
					_pendingKeyCaptureEntry = entry;
					_pendingKeyCaptureText = null;
				}
			}
			else
			{
				if (TryDrawImmediateRangeControlStable(entry, entryValueType))
				{
					return;
				}
				if (TryGetSelectableOptions(entry, entryValueType, out var options) && options.Count > 0)
				{
					if (ShouldRenderOptionSelectionBoxStable(entry))
					{
						DrawImmediateOptionSelectionBoxStable(entry, options);
						return;
					}
					object boxedValue = GetBoxedValue(entry);
					int num2 = Mathf.Max(0, options.FindIndex((object option) => ValuesEqual(option, boxedValue)));
					GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(280f) });
					if (GUILayout.Button("<", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(28f),
						GUILayout.Height(28f)
					}))
					{
						num2 = (num2 - 1 + options.Count) % options.Count;
						TryAssignBoxedValue(entry, options[num2]);
						SaveEntryOwner(entry);
					}
					GUILayout.Box(GetOptionDisplayText(GetSourceForEntry(entry), entry, options[num2]), (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(220f),
						GUILayout.Height(28f)
					});
					if (GUILayout.Button(">", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(28f),
						GUILayout.Height(28f)
					}))
					{
						num2 = (num2 + 1) % options.Count;
						TryAssignBoxedValue(entry, options[num2]);
						SaveEntryOwner(entry);
					}
					GUILayout.EndHorizontal();
				}
				else
				{
					string value;
					string text = ((!_textBufferByEntry.TryGetValue(entry, out value)) ? GetDisplayValueText(entry) : value);
					ConfigDefinition definition = entry.Definition;
					string obj = ((definition != null) ? definition.Section : null) ?? string.Empty;
					ConfigDefinition definition2 = entry.Definition;
					string text2 = "cfg_" + obj + "_" + (((definition2 != null) ? definition2.Key : null) ?? string.Empty);
					GUI.SetNextControlName(text2);
					string text3 = GUILayout.TextField(text ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(280f),
						GUILayout.Height(28f)
					});
					if (!string.Equals(text3, text, StringComparison.Ordinal))
					{
						_textBufferByEntry[entry] = text3;
					}
					bool flag4 = string.Equals(GUI.GetNameOfFocusedControl(), text2, StringComparison.Ordinal);
					if ((int)Event.current.type == 4 && (int)Event.current.keyCode == 13 && flag4)
					{
						CommitBufferedEntryText(entry, entryValueType);
						GUI.FocusControl((string)null);
						Event.current.Use();
					}
					if (!flag4 && _textBufferByEntry.TryGetValue(entry, out var _) && !string.Equals(_textBufferByEntry[entry], GetDisplayValueText(entry), StringComparison.Ordinal))
					{
						CommitBufferedEntryText(entry, entryValueType);
					}
				}
			}
		}

		private void DrawImmediateEntryControlStableV2(ConfigEntryBase entry)
		{
			//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_0050: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Invalid comparison between Unknown and I4
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Invalid comparison between Unknown and I4
			Type entryValueType = GetEntryValueType(entry);
			float immediateCompactControlWidth = GetImmediateCompactControlWidth();
			if (entryValueType == typeof(bool))
			{
				object boxedValue2 = GetBoxedValue(entry);
				bool flag = default(bool);
				int num;
				if (boxedValue2 is bool)
				{
					flag = (bool)boxedValue2;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag2 = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				Color backgroundColor = GUI.backgroundColor;
				GUI.backgroundColor = GetImmediateButtonColor(flag2);
				if (GUILayout.Button(GetToggleStateLabel(flag2), _immediateButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(92f),
					GUILayout.Height(28f)
				}))
				{
					TryAssignBoxedValue(entry, !flag2);
					SaveEntryOwner(entry);
				}
				GUI.backgroundColor = backgroundColor;
			}
			else if (entryValueType == typeof(KeyCode))
			{
				string obj = ((_pendingKeyCaptureEntry == entry) ? GetPressAnyKeyLabel() : GetDisplayValueText(entry));
				Color backgroundColor2 = GUI.backgroundColor;
				GUI.backgroundColor = GetImmediateButtonColor(active: false);
				if (GUILayout.Button(obj, _immediateButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(immediateCompactControlWidth),
					GUILayout.Height(28f)
				}))
				{
					_pendingKeyCaptureEntry = entry;
					_pendingKeyCaptureText = null;
				}
				GUI.backgroundColor = backgroundColor2;
			}
			else
			{
				if (TryDrawImmediateRangeControlStableV2(entry, entryValueType))
				{
					return;
				}
				if (TryGetSelectableOptions(entry, entryValueType, out var options) && options.Count > 0)
				{
					if (ShouldRenderOptionSelectionBoxStable(entry))
					{
						DrawImmediateOptionSelectionBoxStableV2(entry, options);
						return;
					}
					object boxedValue = GetBoxedValue(entry);
					int num2 = Mathf.Max(0, options.FindIndex((object option) => ValuesEqual(option, boxedValue)));
					float num3 = Mathf.Clamp(immediateCompactControlWidth - 60f, 180f, 360f);
					GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(immediateCompactControlWidth) });
					Color backgroundColor3 = GUI.backgroundColor;
					GUI.backgroundColor = GetImmediateButtonColor(active: false);
					if (GUILayout.Button("<", _immediateButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(28f),
						GUILayout.Height(28f)
					}))
					{
						num2 = (num2 - 1 + options.Count) % options.Count;
						TryAssignBoxedValue(entry, options[num2]);
						SaveEntryOwner(entry);
					}
					GUILayout.Box(GetOptionDisplayText(GetSourceForEntry(entry), entry, options[num2]), _immediateFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(num3),
						GUILayout.Height(28f)
					});
					if (GUILayout.Button(">", _immediateButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(28f),
						GUILayout.Height(28f)
					}))
					{
						num2 = (num2 + 1) % options.Count;
						TryAssignBoxedValue(entry, options[num2]);
						SaveEntryOwner(entry);
					}
					GUI.backgroundColor = backgroundColor3;
					GUILayout.EndHorizontal();
				}
				else
				{
					string value;
					string text = ((!_textBufferByEntry.TryGetValue(entry, out value)) ? GetDisplayValueText(entry) : value);
					ConfigDefinition definition = entry.Definition;
					string obj2 = ((definition != null) ? definition.Section : null) ?? string.Empty;
					ConfigDefinition definition2 = entry.Definition;
					string text2 = "cfg_" + obj2 + "_" + (((definition2 != null) ? definition2.Key : null) ?? string.Empty);
					GUI.SetNextControlName(text2);
					string text3 = GUILayout.TextField(text ?? string.Empty, _immediateTextFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(immediateCompactControlWidth),
						GUILayout.Height(28f)
					});
					if (!string.Equals(text3, text, StringComparison.Ordinal))
					{
						_textBufferByEntry[entry] = text3;
					}
					bool flag3 = string.Equals(GUI.GetNameOfFocusedControl(), text2, StringComparison.Ordinal);
					if ((int)Event.current.type == 4 && (int)Event.current.keyCode == 13 && flag3)
					{
						CommitBufferedEntryText(entry, entryValueType);
						GUI.FocusControl((string)null);
						Event.current.Use();
					}
					if (!flag3 && _textBufferByEntry.TryGetValue(entry, out var _) && !string.Equals(_textBufferByEntry[entry], GetDisplayValueText(entry), StringComparison.Ordinal))
					{
						CommitBufferedEntryText(entry, entryValueType);
					}
				}
			}
		}

		private bool TryDrawImmediateRangeControlStableV2(ConfigEntryBase entry, Type entryValueType)
		{
			if ((entryValueType != typeof(int) && entryValueType != typeof(float) && entryValueType != typeof(double)) || !TryGetScaledNumericRange(entry, entryValueType, out var scaledMin, out var scaledMax, out var scale))
			{
				return false;
			}
			float immediateRangeControlWidth = GetImmediateRangeControlWidth();
			float immediateRangeSliderWidth = GetImmediateRangeSliderWidth();
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(immediateRangeControlWidth) });
			int scaledNumericValue = GetScaledNumericValue(entry, entryValueType, scale);
			int num = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)scaledNumericValue, (float)scaledMin, (float)scaledMax, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(immediateRangeSliderWidth) }));
			num = Mathf.Clamp(num, scaledMin, scaledMax);
			if (num != scaledNumericValue && TryAssignScaledNumericValue(entry, entryValueType, num, scale))
			{
				SaveEntryOwner(entry);
			}
			GUILayout.Space(10f);
			GUILayout.Label(GetDisplayValueText(entry), _immediateLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
			GUILayout.EndHorizontal();
			return true;
		}

		private void DrawImmediateOptionSelectionBoxStableV2(ConfigEntryBase entry, List<object> options)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			object right = GetBoxedValue(entry);
			int count = options.Count;
			float num = 86f;
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num * (float)count + 6f * (float)(count - 1)) });
			for (int i = 0; i < options.Count; i += count)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				for (int j = i; j < Mathf.Min(i + count, options.Count); j++)
				{
					object obj = options[j];
					bool flag = ValuesEqual(obj, right);
					Color backgroundColor = GUI.backgroundColor;
					GUI.backgroundColor = GetImmediateButtonColor(flag);
					if (GUILayout.Button(GetOptionDisplayText(GetSourceForEntry(entry), entry, obj), _immediateButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(num),
						GUILayout.Height(28f)
					}) && !flag)
					{
						TryAssignBoxedValue(entry, obj);
						SaveEntryOwner(entry);
						right = obj;
					}
					GUI.backgroundColor = backgroundColor;
					if (j < Mathf.Min(i + count, options.Count) - 1)
					{
						GUILayout.Space(6f);
					}
				}
				GUILayout.EndHorizontal();
				if (i + count < options.Count)
				{
					GUILayout.Space(4f);
				}
			}
			GUILayout.EndVertical();
		}

		private bool TryDrawImmediateRangeControlStable(ConfigEntryBase entry, Type entryValueType)
		{
			if ((entryValueType != typeof(int) && entryValueType != typeof(float) && entryValueType != typeof(double)) || !TryGetScaledNumericRange(entry, entryValueType, out var scaledMin, out var scaledMax, out var scale))
			{
				return false;
			}
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(380f) });
			int scaledNumericValue = GetScaledNumericValue(entry, entryValueType, scale);
			int num = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)scaledNumericValue, (float)scaledMin, (float)scaledMax, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(300f) }));
			num = Mathf.Clamp(num, scaledMin, scaledMax);
			if (num != scaledNumericValue && TryAssignScaledNumericValue(entry, entryValueType, num, scale))
			{
				SaveEntryOwner(entry);
			}
			GUILayout.Space(10f);
			GUILayout.Label(GetDisplayValueText(entry), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
			GUILayout.EndHorizontal();
			return true;
		}

		private static bool ShouldRenderOptionSelectionBoxStable(ConfigEntryBase entry)
		{
			if (entry != Plugin.WeaponSelection && entry != Plugin.AkSoundSelection)
			{
				return entry == Plugin.ConfigPanelTheme;
			}
			return true;
		}

		private void DrawImmediateOptionSelectionBoxStable(ConfigEntryBase entry, List<object> options)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			object right = GetBoxedValue(entry);
			int num = ((entry == Plugin.AkSoundSelection) ? options.Count : options.Count);
			float num2 = ((entry == Plugin.AkSoundSelection) ? 86f : 86f);
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2 * (float)num + 6f * (float)(num - 1)) });
			for (int i = 0; i < options.Count; i += num)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				for (int j = i; j < Mathf.Min(i + num, options.Count); j++)
				{
					object obj = options[j];
					bool flag = ValuesEqual(obj, right);
					Color backgroundColor = GUI.backgroundColor;
					GUI.backgroundColor = (flag ? new Color(0.27f, 0.66f, 0.58f, 1f) : new Color(0.34f, 0.37f, 0.45f, 1f));
					if (GUILayout.Button(GetOptionDisplayText(GetSourceForEntry(entry), entry, obj), (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(num2),
						GUILayout.Height(28f)
					}) && !flag)
					{
						TryAssignBoxedValue(entry, obj);
						SaveEntryOwner(entry);
						right = obj;
					}
					GUI.backgroundColor = backgroundColor;
					if (j < Mathf.Min(i + num, options.Count) - 1)
					{
						GUILayout.Space(6f);
					}
				}
				GUILayout.EndHorizontal();
				if (i + num < options.Count)
				{
					GUILayout.Space(4f);
				}
			}
			GUILayout.EndVertical();
		}

		private void DrawImmediateEntryControl(ConfigEntryBase entry)
		{
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Invalid comparison between Unknown and I4
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Invalid comparison between Unknown and I4
			Type entryValueType = GetEntryValueType(entry);
			if (entryValueType == typeof(bool))
			{
				object boxedValue2 = GetBoxedValue(entry);
				bool flag = default(bool);
				int num;
				if (boxedValue2 is bool)
				{
					flag = (bool)boxedValue2;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag2 = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				bool flag3 = GUILayout.Toggle(flag2, GetToggleStateLabel(flag2), (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(80f),
					GUILayout.Height(28f)
				});
				if (flag3 != flag2)
				{
					TryAssignBoxedValue(entry, flag3);
					SaveEntryOwner(entry);
				}
			}
			else if (entryValueType == typeof(KeyCode))
			{
				if (GUILayout.Button((_pendingKeyCaptureEntry == entry) ? "鎸変换鎰忛敭..." : GetDisplayValueText(entry), (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(220f),
					GUILayout.Height(28f)
				}))
				{
					_pendingKeyCaptureEntry = entry;
					_pendingKeyCaptureText = null;
				}
			}
			else
			{
				if (TryDrawImmediateRangeControl(entry, entryValueType))
				{
					return;
				}
				if (TryGetSelectableOptions(entry, entryValueType, out var options) && options.Count > 0)
				{
					if (ShouldRenderOptionSelectionBox(entry))
					{
						DrawImmediateOptionSelectionBox(entry, options);
						return;
					}
					object boxedValue = GetBoxedValue(entry);
					int num2 = Mathf.Max(0, options.FindIndex((object option) => ValuesEqual(option, boxedValue)));
					GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(220f) });
					if (GUILayout.Button("<", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(28f),
						GUILayout.Height(28f)
					}))
					{
						num2 = (num2 - 1 + options.Count) % options.Count;
						TryAssignBoxedValue(entry, options[num2]);
						SaveEntryOwner(entry);
					}
					GUILayout.Box(GetOptionDisplayText(GetSourceForEntry(entry), entry, options[num2]), (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(160f),
						GUILayout.Height(28f)
					});
					if (GUILayout.Button(">", (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(28f),
						GUILayout.Height(28f)
					}))
					{
						num2 = (num2 + 1) % options.Count;
						TryAssignBoxedValue(entry, options[num2]);
						SaveEntryOwner(entry);
					}
					GUILayout.EndHorizontal();
				}
				else
				{
					string value;
					string text = ((!_textBufferByEntry.TryGetValue(entry, out value)) ? GetDisplayValueText(entry) : value);
					ConfigDefinition definition = entry.Definition;
					string obj = ((definition != null) ? definition.Section : null) ?? string.Empty;
					ConfigDefinition definition2 = entry.Definition;
					string text2 = "cfg_" + obj + "_" + (((definition2 != null) ? definition2.Key : null) ?? string.Empty);
					GUI.SetNextControlName(text2);
					string text3 = GUILayout.TextField(text ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(260f),
						GUILayout.Height(28f)
					});
					if (!string.Equals(text3, text, StringComparison.Ordinal))
					{
						_textBufferByEntry[entry] = text3;
					}
					bool flag4 = string.Equals(GUI.GetNameOfFocusedControl(), text2, StringComparison.Ordinal);
					if ((int)Event.current.type == 4 && (int)Event.current.keyCode == 13 && flag4)
					{
						CommitBufferedEntryText(entry, entryValueType);
						GUI.FocusControl((string)null);
						Event.current.Use();
					}
					if (!flag4 && _textBufferByEntry.TryGetValue(entry, out var _) && !string.Equals(_textBufferByEntry[entry], GetDisplayValueText(entry), StringComparison.Ordinal))
					{
						CommitBufferedEntryText(entry, entryValueType);
					}
				}
			}
		}

		private bool TryDrawImmediateRangeControl(ConfigEntryBase entry, Type entryValueType)
		{
			if ((entryValueType != typeof(int) && entryValueType != typeof(float) && entryValueType != typeof(double)) || !TryGetScaledNumericRange(entry, entryValueType, out var scaledMin, out var scaledMax, out var scale))
			{
				return false;
			}
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(320f) });
			int scaledNumericValue = GetScaledNumericValue(entry, entryValueType, scale);
			int num = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)scaledNumericValue, (float)scaledMin, (float)scaledMax, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(240f) }));
			num = Mathf.Clamp(num, scaledMin, scaledMax);
			if (num != scaledNumericValue && TryAssignScaledNumericValue(entry, entryValueType, num, scale))
			{
				SaveEntryOwner(entry);
			}
			GUILayout.Space(10f);
			GUILayout.Label(GetDisplayValueText(entry), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
			GUILayout.EndHorizontal();
			return true;
		}

		private static bool ShouldRenderOptionSelectionBox(ConfigEntryBase entry)
		{
			if (entry != Plugin.WeaponSelection && entry != Plugin.AkSoundSelection)
			{
				return entry == Plugin.ConfigPanelTheme;
			}
			return true;
		}

		private void DrawImmediateOptionSelectionBox(ConfigEntryBase entry, List<object> options)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			object right = GetBoxedValue(entry);
			int num = ((entry == Plugin.AkSoundSelection) ? options.Count : options.Count);
			float num2 = ((entry == Plugin.AkSoundSelection) ? 72f : 72f);
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2 * (float)num + 6f * (float)(num - 1)) });
			for (int i = 0; i < options.Count; i += num)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				for (int j = i; j < Mathf.Min(i + num, options.Count); j++)
				{
					object obj = options[j];
					bool flag = ValuesEqual(obj, right);
					Color backgroundColor = GUI.backgroundColor;
					GUI.backgroundColor = (flag ? new Color(0.27f, 0.66f, 0.58f, 1f) : new Color(0.34f, 0.37f, 0.45f, 1f));
					if (GUILayout.Button(GetOptionDisplayText(GetSourceForEntry(entry), entry, obj), (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(num2),
						GUILayout.Height(28f)
					}) && !flag)
					{
						TryAssignBoxedValue(entry, obj);
						SaveEntryOwner(entry);
						right = obj;
					}
					GUI.backgroundColor = backgroundColor;
					if (j < Mathf.Min(i + num, options.Count) - 1)
					{
						GUILayout.Space(6f);
					}
				}
				GUILayout.EndHorizontal();
				if (i + num < options.Count)
				{
					GUILayout.Space(4f);
				}
			}
			GUILayout.EndVertical();
		}

		private void CommitBufferedEntryText(ConfigEntryBase entry, Type valueType)
		{
			if (entry != null && _textBufferByEntry.TryGetValue(entry, out var value))
			{
				if (TryAssignTextValue(entry, valueType, value))
				{
					SaveEntryOwner(entry);
					_textBufferByEntry[entry] = GetDisplayValueText(entry);
				}
				else
				{
					_textBufferByEntry[entry] = GetDisplayValueText(entry);
				}
			}
		}

		private void BuildUi()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: 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_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Expected O, but got Unknown
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_0621: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0667: Unknown result type (might be due to invalid IL or missing references)
			//IL_067c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			_rootObject = new GameObject("ShootZombiesLobbyConfigPanel", new Type[1] { typeof(RectTransform) });
			_canvas = _rootObject.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 3100;
			CanvasScaler obj = _rootObject.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.screenMatchMode = (ScreenMatchMode)0;
			obj.matchWidthOrHeight = 0.5f;
			_rootObject.AddComponent<GraphicRaycaster>();
			Object.DontDestroyOnLoad((Object)(object)_rootObject);
			GameObject val = CreateUiObject("Backdrop", _rootObject.transform);
			StretchToFill(GetRectTransform(val));
			((Graphic)val.AddComponent<Image>()).color = BackdropColor;
			GameObject val2 = CreateUiObject("Panel", val.transform);
			_panelRect = GetRectTransform(val2);
			((Graphic)val2.AddComponent<Image>()).color = PanelColor;
			AddOutline(val2, BorderColor);
			ClampPanelToScreen();
			GameObject val3 = CreateUiObject("Header", val2.transform);
			RectTransform rectTransform = GetRectTransform(val3);
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.sizeDelta = new Vector2(0f, 62f);
			rectTransform.anchoredPosition = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = HeaderColor;
			_panelTitleText = CreateText(val3.transform, "ShootZombies", 28f, TextPrimaryColor, (TextAlignmentOptions)4097);
			RectTransform rectTransform2 = ((TMP_Text)_panelTitleText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0f);
			rectTransform2.anchorMax = new Vector2(1f, 1f);
			rectTransform2.offsetMin = new Vector2(26f, 0f);
			rectTransform2.offsetMax = new Vector2(-100f, 0f);
			Button obj2 = CreateButton(val3.transform, "x", new Color(0.55f, 0.24f, 0.24f, 1f), 22f, 40f, 32f);
			RectTransform component = ((Component)obj2).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0.5f);
			component.anchorMax = new Vector2(1f, 0.5f);
			component.pivot = new Vector2(1f, 0.5f);
			component.anchoredPosition = new Vector2(-20f, 0f);
			((UnityEvent)obj2.onClick).AddListener(new UnityAction(Close));
			GameObject gameObject = CreateUiObject("PluginTabs", val2.transform);
			_pluginTabsRect = GetRectTransform(gameObject);
			_pluginTabsRect.anchorMin = new Vector2(0f, 1f);
			_pluginTabsRect.anchorMax = new Vector2(1f, 1f);
			_pluginTabsRect.pivot = new Vector2(0.5f, 1f);
			_pluginTabsRect.sizeDelta = new Vector2(-40f, 42f);
			_pluginTabsRect.anchoredPosition = new Vector2(0f, -74f);
			GameObject val4 = CreateUiObject("Sidebar", val2.transform);
			RectTransform rectTransform3 = GetRectTransform(val4);
			rectTransform3.anchorMin = new Vector2(0f, 0f);
			rectTransform3.anchorMax = new Vector2(0f, 1f);
			rectTransform3.pivot = new Vector2(0f, 1f);
			rectTransform3.sizeDelta = new Vector2(250f, -134f);
			rectTransform3.anchoredPosition = new Vector2(20f, -124f);
			((Graphic)val4.AddComponent<Image>()).color = SidebarColor;
			AddOutline(val4, BorderColor);
			RectTransform rectTransform4 = ((TMP_Text)CreateText(val4.transform, "Sections", 20f, TextPrimaryColor, (TextAlignmentOptions)257)).rectTransform;
			rectTransform4.anchorMin = new Vector2(0f, 1f);
			rectTransform4.anchorMax = new Vector2(1f, 1f);
			rectTransform4.pivot = new Vector2(0f, 1f);
			rectTransform4.sizeDelta = new Vector2(-28f, 28f);
			rectTransform4.anchoredPosition = new Vector2(16f, -12f);
			GameObject gameObject2 = CreateUiObject("SectionList", val4.transform);
			_sectionListRect = GetRectTransform(gameObject2);
			_sectionListRect.anchorMin = new Vector2(0f, 0f);
			_sectionListRect.anchorMax = new Vector2(1f, 1f);
			_sectionListRect.offsetMin = new Vector2(14f, 14f);
			_sectionListRect.offsetMax = new Vector2(-14f, -52f);
			GameObject val5 = CreateUiObject("Content", val2.transform);
			RectTransform rectTransform5 = GetRectTransform(val5);
			rectTransform5.anchorMin = new Vector2(0f, 0f);
			rectTransform5.anchorMax = new Vector2(1f, 1f);
			rectTransform5.offsetMin = new Vector2(286f, 20f);
			rectTransform5.offsetMax = new Vector2(-20f, -124f);
			((Graphic)val5.AddComponent<Image>()).color = ContentColor;
			AddOutline(val5, BorderColor);
			GameObject val6 = CreateUiObject("ContentHeader", val5.transform);
			RectTransform rectTransform6 = GetRectTransform(val6);
			rectTransform6.anchorMin = new Vector2(0f, 1f);
			rectTransform6.anchorMax = new Vector2(1f, 1f);
			rectTransform6.pivot = new Vector2(0.5f, 1f);
			rectTransform6.sizeDelta = new Vector2(0f, 52f);
			rectTransform6.anchoredPosition = Vector2.zero;
			((Graphic)val6.AddComponent<Image>()).color = HeaderColor;
			_contentTitleText = CreateText(val6.transform, "Config", 24f, TextPrimaryColor, (TextAlignmentOptions)4097);
			RectTransform rectTransform7 = ((TMP_Text)_contentTitleText).rectTransform;
			rectTransform7.anchorMin = new Vector2(0f, 0f);
			rectTransform7.anchorMax = new Vector2(1f, 1f);
			rectTransform7.offsetMin = new Vector2(20f, 0f);
			rectTransform7.offsetMax = new Vector2(-20f, 0f);
			CreateScrollView(val5.transform, out var _, out _entryListRect, new Vector2(16f, 16f), new Vector2(-16f, -68f));
			_rootObject.AddComponent<LobbyConfigPanelGuiHost>().Owner = this;
			((Behaviour)_canvas).enabled = false;
			_rootObject.SetActive(false);
		}

		private void ClampPanelToScreen()
		{
			//IL_0031: 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_00d6: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panelRect == (Object)null))
			{
				float num = Mathf.Max((float)Screen.width, 1f);
				float num2 = Mathf.Max((float)Screen.height, 1f);
				Rect safeArea = Screen.safeArea;
				float num3 = Mathf.Max(Mathf.Min(((Rect)(ref safeArea)).width - 96f, ((Rect)(ref safeArea)).width * 0.76f), 960f);
				float num4 = Mathf.Max(Mathf.Min(((Rect)(ref safeArea)).height - 84f, ((Rect)(ref safeArea)).height * 0.74f), 620f);
				num3 = Mathf.Clamp(num3, 640f, Mathf.Max(((Rect)(ref safeArea)).width - 32f, 640f));
				num4 = Mathf.Clamp(num4, 520f, Mathf.Max(((Rect)(ref safeArea)).height - 32f, 520f));
				Vector2 anchoredPosition = ((Rect)(ref safeArea)).center - new Vector2(num * 0.5f, num2 * 0.5f);
				_panelRect.anchorMin = new Vector2(0.5f, 0.5f);
				_panelRect.anchorMax = new Vector2(0.5f, 0.5f);
				_panelRect.pivot = new Vector2(0.5f, 0.5f);
				_panelRect.sizeDelta = new Vector2(num3, num4);
				_panelRect.anchoredPosition = anchoredPosition;
			}
		}

		private void CreateScrollView(Transform parent, out RectTransform viewportRect, out RectTransform contentRect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0013: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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)
			GameObject val = CreateUiObject("ScrollView", parent);
			RectTransform rectTransform = GetRectTransform(val);
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = offsetMin;
			rectTransform.offsetMax = offsetMax;
			((Graphic)val.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.08f);
			ScrollRect obj = val.AddComponent<ScrollRect>();
			obj.horizontal = false;
			obj.scrollSensitivity = 28f;
			obj.movementType = (MovementType)2;
			GameObject val2 = CreateUiObject("Viewport", val.transform);
			viewportRect = GetRectTransform(val2);
			StretchToFill(viewportRect);
			((Graphic)val2.AddComponent<Image>()).color = Color.clear;
			val2.AddComponent<Mask>().showMaskGraphic = false;
			GameObject gameObject = CreateUiObject("Content", val2.transform);
			contentRect = GetRectTransform(gameObject);
			contentRect.anchorMin = new Vector2(0f, 1f);
			contentRect.anchorMax = new Vector2(1f, 1f);
			contentRect.pivot = new Vector2(0.5f, 1f);
			contentRect.anchoredPosition = Vector2.zero;
			contentRect.sizeDelta = new Vector2(0f, 0f);
			obj.viewport = viewportRect;
			obj.content = contentRect;
		}

		private static Button CreateButton(Transform parent, string label, Color backgroundColor, float fontSize, float preferredWidth, float preferredHeight)
		{
			//IL_003d: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject("Button", parent);
			RectTransform rectTransform = GetRectTransform(obj);
			LayoutElement val = obj.AddComponent<LayoutElement>();
			if (preferredWidth > 0f)
			{
				val.preferredWidth = preferredWidth;
				rectTransform.sizeDelta = new Vector2(preferredWidth, preferredHeight);
			}
			else
			{
				rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, preferredHeight);
			}
			val.preferredHeight = preferredHeight;
			Image val2 = obj.AddComponent<Image>();
			((Graphic)val2).color = backgroundColor;
			AddOutline(obj, BorderColor);
			Button val3 = obj.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			StretchToFill(((TMP_Text)CreateText(obj.transform, label, fontSize, TextPrimaryColor, (TextAlignmentOptions)514)).rectTransform, 10f);
			return val3;
		}

		private TMP_Dropdown CreateDropdown(Transform parent, float width, float height)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a6: 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_010c: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject("Dropdown", parent);
			RectTransform rectTransform = GetRectTransform(val);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredWidth = width;
			obj.preferredHeight = height;
			rectTransform.sizeDelta = new Vector2(width, height);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = FieldColor;
			AddOutline(val, BorderColor);
			TMP_Dropdown obj2 = val.AddComponent<TMP_Dropdown>();
			((Selectable)obj2).targetGraphic = (Graphic)(object)val2;
			GameObject obj3 = CreateUiObject("Label", val.transform);
			RectTransform rectTransform2 = GetRectTransform(obj3);
			rectTransform2.anchorMin = Vector2.zero;
			rectTransform2.anchorMax = Vector2.one;
			rectTransform2.offsetMin = new Vector2(12f, 4f);
			rectTransform2.offsetMax = new Vector2(-30f, -4f);
			TextMeshProUGUI val3 = CreateText(obj3.transform, string.Empty, 17f, TextPrimaryColor, (TextAlignmentOptions)4097);
			StretchToFill(((TMP_Text)val3).rectTransform);
			obj2.captionText = (TMP_Text)(object)val3;
			GameObject obj4 = CreateUiObject("Arrow", val.transform);
			RectTransform rectTransform3 = GetRectTransform(obj4);
			rectTransform3.anchorMin = new Vector2(1f, 0.5f);
			rectTransform3.anchorMax = new Vector2(1f, 0.5f);
			rectTransform3.pivot = new Vector2(1f, 0.5f);
			rectTransform3.sizeDelta = new Vector2(20f, 20f);
			rectTransform3.anchoredPosition = new Vector2(-8f, 0f);
			StretchToFill(((TMP_Text)CreateText(obj4.transform, "v", 16f, TextPrimaryColor, (TextAlignmentOptions)514)).rectTransform);
			GameObject val4 = CreateUiObject("Template", val.transform);
			RectTransform rectTransform4 = GetRectTransform(val4);
			rectTransform4.anchorMin = new Vector2(0f, 0f);
			rectTransform4.anchorMax = new Vector2(1f, 0f);
			rectTransform4.pivot = new Vector2(0.5f, 1f);
			rectTransform4.sizeDelta = new Vector2(0f, 180f);
			rectTransform4.anchoredPosition = new Vector2(0f, -4f);
			((Graphic)val4.AddComponent<Image>()).color = FieldColor;
			AddOutline(val4, BorderColor);
			ScrollRect obj5 = val4.AddComponent<ScrollRect>();
			obj5.horizontal = false;
			obj5.scrollSensitivity = 24f;
			obj5.movementType = (MovementType)2;
			GameObject val5 = CreateUiObject("Viewport", val4.transform);
			RectTransform rectTransform5 = GetRectTransform(val5);
			StretchToFill(rectTransform5);
			((Graphic)val5.AddComponent<Image>()).color = Color.clear;
			val5.AddComponent<Mask>().showMaskGraphic = false;
			GameObject val6 = CreateUiObject("Content", val5.transform);
			RectTransform rectTransform6 = GetRectTransform(val6);
			rectTransform6.anchorMin = new Vector2(0f, 1f);
			rectTransform6.anchorMax = new Vector2(1f, 1f);
			rectTransform6.pivot = new Vector2(0.5f, 1f);
			rectTransform6.anchoredPosition = Vector2.zero;
			VerticalLayoutGroup obj6 = val6.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj6).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj6).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj6).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj6).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj6).spacing = 2f;
			val6.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			obj5.viewport = rectTransform5;
			obj5.content = rectTransform6;
			GameObject val7 = CreateUiObject("Item", val6.transform);
			GetRectTransform(val7).sizeDelta = new Vector2(0f, 30f);
			Toggle obj7 = val7.AddComponent<Toggle>();
			Image val8 = val7.AddComponent<Image>();
			((Graphic)val8).color = ButtonColor;
			((Selectable)obj7).targetGraphic = (Graphic)(object)val8;
			GameObject obj8 = CreateUiObject("ItemCheckmark", val7.transform);
			RectTransform rectTransform7 = GetRectTransform(obj8);
			rectTransform7.anchorMin = new Vector2(0f, 0.5f);
			rectTransform7.anchorMax = new Vector2(0f, 0.5f);
			rectTransform7.pivot = new Vector2(0f, 0.5f);
			rectTransform7.sizeDelta = new Vector2(18f, 18f);
			rectTransform7.anchoredPosition = new Vector2(6f, 0f);
			Image val9 = obj8.AddComponent<Image>();
			((Graphic)val9).color = ButtonActiveColor;
			obj7.graphic = (Graphic)(object)val9;
			GameObject obj9 = CreateUiObject("ItemLabel", val7.transform);
			RectTransform rectTransform8 = GetRectTransform(obj9);
			rectTransform8.anchorMin = Vector2.zero;
			rectTransform8.anchorMax = Vector2.one;
			rectTransform8.offsetMin = new Vector2(28f, 2f);
			rectTransform8.offsetMax = new Vector2(-6f, -2f);
			TextMeshProUGUI val10 = CreateText(obj9.transform, "Option", 16f, TextPrimaryColor, (TextAlignmentOptions)4097);
			StretchToFill(((TMP_Text)val10).rectTransform);
			obj2.template = rectTransform4;
			obj2.itemText = (TMP_Text)(object)val10;
			obj2.captionText = (TMP_Text)(object)val3;
			val4.SetActive(false);
			return obj2;
		}

		private TMP_InputField CreateInputField(Transform parent, float width, float height)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject("InputField", parent);
			RectTransform rectTransform = GetRectTransform(val);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredWidth = width;
			obj.preferredHeight = height;
			rectTransform.sizeDelta = new Vector2(width, height);
			((Graphic)val.AddComponent<Image>()).color = FieldColor;
			AddOutline(val, BorderColor);
			TMP_InputField obj2 = val.AddComponent<TMP_InputField>();
			GameObject obj3 = CreateUiObject("TextArea", val.transform);
			RectTransform rectTransform2 = GetRectTransform(obj3);
			rectTransform2.anchorMin = Vector2.zero;
			rectTransform2.anchorMax = Vector2.one;
			rectTransform2.offsetMin = new Vector2(10f, 5f);
			rectTransform2.offsetMax = new Vector2(-10f, -5f);
			TextMeshProUGUI val2 = CreateText(obj3.transform, string.Empty, 17f, TextPrimaryColor, (TextAlignmentOptions)4097);
			StretchToFill(((TMP_Text)val2).rectTransform);
			TextMeshProUGUI val3 = CreateText(obj3.transform, "...", 17f, TextMutedColor, (TextAlignmentOptions)4097);
			StretchToFill(((TMP_Text)val3).rectTransform);
			obj2.textViewport = rectTransform2;
			obj2.textComponent = (TMP_Text)(object)val2;
			obj2.placeholder = (Graphic)(object)val3;
			obj2.caretColor = TextPrimaryColor;
			obj2.selectionColor = new Color(0.35f, 0.58f, 0.84f, 0.35f);
			return obj2;
		}

		private static void CreateEmptyState(Transform parent, string text)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			((Component)CreateText(parent, text, 22f, TextMutedColor, (TextAlignmentOptions)514)).gameObject.AddComponent<LayoutElement>().minHeight = 200f;
		}

		private static TextMeshProUGUI CreateText(Transform parent, string text, float fontSize, Color color, TextAlignmentOptions alignment)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI obj = CreateUiObject("Text", parent).AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).text = text;
			((TMP_Text)obj).fontSize = fontSize;
			((Graphic)obj).color = color;
			((TMP_Text)obj).alignment = alignment;
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			TryApplyDefaultFont(obj);
			return obj;
		}

		private static void TryApplyDefaultFont(TextMeshProUGUI text)
		{
			if (!((Object)(object)text == (Object)null))
			{
				GUIManager instance = GUIManager.instance;
				TextMeshProUGUI val = (((Object)(object)instance?.itemPromptMain != (Object)null) ? instance.itemPromptMain : instance?.interactNameText);
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)text).font = ((TMP_Text)val).font;
					((TMP_Text)text).fontSharedMaterial = ((TMP_Text)val).fontSharedMaterial;
				}
				else if ((Object)(object)TMP_Settings.defaultFontAsset != (Object)null)
				{
					((TMP_Text)text).font = TMP_Settings.defaultFontAsset;
				}
			}
		}

		private static void EnsureEventSystem()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				GameObject gameObject = ((Component)EventSystem.current).gameObject;
				if ((Object)(object)gameObject.GetComponent<StandaloneInputModule>() == (Object)null)
				{
					gameObject.AddComponent<StandaloneInputModule>();
				}
			}
			else
			{
				GameObject val = new GameObject("ShootZombiesConfigEventSystem");
				val.AddComponent<EventSystem>();
				val.AddComponent<StandaloneInputModule>();
				Object.DontDestroyOnLoad((Object)val);
			}
		}

		private static bool IsTypingIntoInputField()
		{
			EventSystem current = EventSystem.current;
			GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			return (Object)(object)val.GetComponentInParent<TMP_InputField>() != (Object)null;
		}

		private static T GetOrAddComponent<T>(GameObject gameObject) where T : Component
		{
			T val = gameObject.GetComponent<T>();
			if ((Object)(object)val == (Object)null)
			{
				val = gameObject.AddComponent<T>();
			}
			return val;
		}

		private static RectTransform GetRectTransform(GameObject gameObject)
		{
			RectTransform val = gameObject.GetComponent<RectTransform>();
			if ((Object)(object)val == (Object)null)
			{
				val = gameObject.AddComponent<RectTransform>();
			}
			return val;
		}

		private static GameObject CreateUiObject(string name, Transform parent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			if ((Object)(object)parent != (Object)null)
			{
				val.transform.SetParent(parent, false);
			}
			val.layer = 5;
			return val;
		}

		private static void DestroyChildren(Transform parent)
		{
			if (!((Object)(object)parent == (Object)null))
			{
				for (int num = parent.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)parent.GetChild(num)).gameObject);
				}
			}
		}

		private static void StretchToFill(RectTransform rectTransform, float horizontalPadding = 0f, float verticalPadding = 0f)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rectTransform == (Object)null))
			{
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = new Vector2(horizontalPadding, verticalPadding);
				rectTransform.offsetMax = new Vector2(0f - horizontalPadding, 0f - verticalPadding);
			}
		}

		private static void AddOutline(GameObject gameObject, Color color)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Outline obj = gameObject.AddComponent<Outline>();
			((Shadow)obj).effectColor = color;
			((Shadow)obj).effectDistance = new Vector2(1f, -1f);
		}
	}
	[HarmonyPatch(typeof(CursorHandler), "Update")]
	internal static class LobbyConfigPanelCursorPatch
	{
		[HarmonyPrefix]
		private static bool Prefix()
		{
			if (!LobbyConfigPanel.IsCursorOwnershipActive())
			{
				return true;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			return false;
		}
	}
	[BepInPlugin("com.github.Thanks.ShootZombies", "ShootZombies", "1.3.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private sealed class ReferenceIdentityComparer : IEqualityComparer<object>
		{
			public static readonly ReferenceIdentityComparer Instance = new ReferenceIdentityComparer();

			public new bool Equals(object x, object y)
			{
				return x == y;
			}

			public int GetHashCode(object obj)
			{
				return RuntimeHelpers.GetHashCode(obj);
			}
		}

		private sealed class DiagnosticGraphHit
		{
			public string Path;

			public string Summary;

			public int Score;
		}

		private sealed class RoomConfigCallbackProxy : IInRoomCallbacks, IOnEventCallback
		{
			public void OnPlayerEnteredRoom(Player newPlayer)
			{
				Instance?.HandleRoomPlayerListChanged();
			}

			public void OnPlayerLeftRoom(Player otherPlayer)
			{
				Instance?.HandleRoomPlayerListChanged();
			}

			public void OnRoomPropertiesUpdate(Hashtable propertiesThatChanged)
			{
				Instance?.HandleRoomPropertiesUpdated(propertiesThatChanged);
			}

			public void OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
			{
				Instance?.HandlePlayerPropertiesUpdated(targetPlayer, changedProps);
			}

			public void OnMasterClientSwitched(Player newMasterClient)
			{
				Instance?.HandleMasterClientChanged();
			}

			public void OnEvent(EventData photonEvent)
			{
				Instance?.HandlePhotonEvent(photonEvent);
			}
		}

		private sealed class WeaponVariantDefinition
		{
			public string SelectionKey;

			public string DisplayName;

			public string[] PrefabAliases;

			public string[] IconAliases;

			public float ScaleMultiplier = 1f;

			public Vector3 PositionOffset = Vector3.zero;
		}

		private sealed class MuzzleFlashInstance
		{
			public GameObject Root;

			public Light Light;

			public float DisableAtTime;
		}

		private sealed class RemoteGunshotAudioInstance
		{
			public GameObject Root;

			public AudioSource AudioSource;

			public float ReleaseAtTime;
		}

		private readonly struct ZombieBehaviorDifficultyPreset
		{
			public readonly float MoveSpeedMultiplier;

			public readonly float HitKnockbackForce;

			public readonly float TargetSearchInterval;

			public readonly float BiteRecoveryTime;

			public readonly float SamePlayerBiteCooldown;

			public readonly float SprintDistance;

			public readonly float ChaseTimeBeforeSprint;

			public readonly float LungeDistance;

			public readonly float LungeTime;

			public readonly float LungeRecoveryTime;

			public readonly float LookAngleBeforeWakeup;

			public readonly float DistanceBeforeWakeup;

			public ZombieBehaviorDifficultyPreset(float moveSpeedMultiplier, float hitKnockbackForce, float targetSearchInterval, float biteRecoveryTime, float samePlayerBiteCooldown, float sprintDistance, float chaseTimeBeforeSprint, float lungeDistance, float lungeTime, float lungeRecoveryTime, float lookAngleBeforeWakeup, float distanceBeforeWakeup)
			{
				MoveSpeedMultiplier = moveSpeedMultiplier;
				HitKnockbackForce = hitKnockbackForce;
				TargetSearchInterval = targetSearchInterval;
				BiteRecoveryTime = biteRecoveryTime;
				SamePlayerBiteCooldown = samePlayerBiteCooldown;
				SprintDistance = sprintDistance;
				ChaseTimeBeforeSprint = chaseTimeBeforeSprint;
				LungeDistance = lungeDistance;
				LungeTime = lungeTime;
				LungeRecoveryTime = lungeRecoveryTime;
				LookAngleBeforeWakeup = lookAngleBeforeWakeup;
				DistanceBeforeWakeup = distanceBeforeWakeup;
			}
		}

		private sealed class DartImpactVfxInstance
		{
			public GameObject Root;

			public int PrefabId;

			public float ReleaseAtTime;

			public float EstimatedLifetime;

			public AudioSource[] AudioSources;
		}

		private readonly struct MemberAccessorCacheKey : IEquatable<MemberAccessorCacheKey>
		{
			public readonly Type OwnerType;

			public readonly string MemberName;

			public readonly Type ValueType;

			public MemberAccessorCacheKey(Type ownerType, string memberName, Type valueType)
			{
				OwnerType = ownerType;
				MemberName = memberName ?? string.Empty;
				ValueType = valueType;
			}

			public bool Equals(MemberAccessorCacheKey other)
			{
				if (OwnerType == other.OwnerType && ValueType == other.ValueType)
				{
					return string.Equals(MemberName, other.MemberName, StringComparison.Ordinal);
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is MemberAccessorCacheKey other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (((((OwnerType != null) ? OwnerType.GetHashCode() : 0) * 397) ^ ((ValueType != null) ? ValueType.GetHashCode() : 0)) * 397) ^ StringComparer.Ordinal.GetHashCode(MemberName);
			}
		}

		private sealed class ReflectionMemberCacheEntry
		{
			public FieldInfo Field;

			public PropertyInfo Property;
		}

		private sealed class ZombieSpeedReflectionCache
		{
			public FieldInfo AgentField;

			public FieldInfo BaseSpeedField;

			public Type AgentType;

			public PropertyInfo SpeedProperty;
		}

		private struct WeaponItemUiInteractionState
		{
			public bool HasDisplayState;

			public string ItemName;

			public Texture2D Icon;

			public Texture2D AltIcon;

			public bool CanDrop;

			public bool CanThrow;

			public bool CanBackpack;
		}

		[CompilerGenerated]
		private sealed class <BuildConfigDefinitionAliases>d__133 : IEnumerable<ConfigDefinition>, IEnumerable, IEnumerator<ConfigDefinition>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private ConfigDefinition <>2__current;

			private int <>l__initialThreadId;

			private string section;

			public string <>3__section;

			private string key;

			public string <>3__key;

			private HashSet<string> <hashSet>5__2;

			private string[] <array2>5__3;

			private string[] <>7__wrap3;

			private int <>7__wrap4;

			private string <text>5__6;

			private string[] <>7__wrap6;

			private int <>7__wrap7;

			ConfigDefinition IEnumerator<ConfigDefinition>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <BuildConfigDefinitionAliases>d__133(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<hashSet>5__2 = null;
				<array2>5__3 = null;
				<>7__wrap3 = null;
				<text>5__6 = null;
				<>7__wrap6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_011a;
				}
				<>1__state = -1;
				<hashSet>5__2 = new HashSet<string>(StringComparer.Ordinal);
				string[] array = new string[2]
				{
					section,
					GetLocalizedSectionName(section, isChinese: true)
				};
				<array2>5__3 = new string[2]
				{
					key,
					GetLocalizedKeyName(key, isChinese: true)
				};
				string[] array2 = array;
				<>7__wrap3 = array2;
				<>7__wrap4 = 0;
				goto IL_0154;
				IL_0154:
				if (<>7__wrap4 < <>7__wrap3.Length)
				{
					<text>5__6 = <>7__wrap3[<>7__wrap4];
					if (!string.IsNullOrWhiteSpace(<text>5__6))
					{
						string[] array3 = <array2>5__3;
						<>7__wrap6 = array3;
						<>7__wrap7 = 0;
						goto IL_0128;
					}
					goto IL_0146;
				}
				<>7__wrap3 = null;
				return false;
				IL_011a:
				<>7__wrap7++;
				goto IL_0128;
				IL_0146:
				<>7__wrap4++;
				goto IL_0154;
				IL_0128:
				if (<>7__wrap7 < <>7__wrap6.Length)
				{
					string text = <>7__wrap6[<>7__wrap7];
					if (!string.IsNullOrWhiteSpace(text))
					{
						string item = <text>5__6 + "\n" + text;
						if (<hashSet>5__2.Add(item))
						{
							<>2__current = new ConfigDefinition(<text>5__6, text);
							<>1__state = 1;
							return true;
						}
					}
					goto IL_011a;
				}
				<>7__wrap6 = null;
				<text>5__6 = null;
				goto IL_0146;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<ConfigDefinition> IEnumerable<ConfigDefinition>.GetEnumerator()
			{
				<BuildConfigDefinitionAliases>d__133 <BuildConfigDefinitionAliases>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<BuildConfigDefinitionAliases>d__ = this;
				}
				else
				{
					<BuildConfigDefinitionAliases>d__ = new <BuildConfigDefinitionAliases>d__133(0);
				}
				<BuildConfigDefinitionAliases>d__.section = <>3__section;
				<BuildConfigDefinitionAliases>d__.key = <>3__key;
				return <BuildConfigDefinitionAliases>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<ConfigDefinition>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <DeferredInitialLocalizationRefresh>d__760 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredInitialLocalizationRefresh>d__760(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					goto IL_0059;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0059;
				case 2:
					{
						<>1__state = -1;
						<i>5__2++;
						break;
					}
					IL_0059:
					if (<i>5__2 < 20)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<i>5__2 = 0;
					break;
				}
				if (<i>5__2 < 180 && !plugin.TryResolveGameLanguage(out var _, out var _, out var _))
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				try
				{
					plugin.ReinitializeConfig();
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("[ShootZombies] DeferredInitialLocalizationRefresh failed: " + ex.Message));
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedReplaceBlowgunModel>d__1130 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedReplaceBlowgunModel>d__1130(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!((Object)Instance == (Object)null))
					{
						Instance.ReplaceBlowgunInstances();
					}
					<>2__current = (object)new WaitForSeconds(0.75f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!((Object)Instance == (Object)null))
					{
						Instance.ReplaceBlowgunInstances();
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DestroyZombieAfterDelay>d__75 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			public Character zombie;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DestroyZombieAfterDelay>d__75(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!((Object)(object)zombie != (Object)null) || !((Object)(object)((Component)zombie).gameObject != (Object)null))
					{
						return false;
					}
					PhotonView component = ((Component)zombie).GetComponent<PhotonView>();
					if ((Object)(object)component != (Object)null)
					{
						if (component.IsMine)
						{
							PhotonNetwork.Destroy(((Component)zombie).gameObject);
						}
						else if (PhotonNetwork.IsMasterClient)
						{
							PhotonNetwork.Destroy(component);
						}
					}
					else
					{
						Object.Destroy((Object)(object)((Component)zombie).gameObject);
					}
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateAkSoundDirectories>d__1199 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private HashSet<string> <hashSet>5__2;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnumerateAkSoundDirectories>d__1199(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<hashSet>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				string currentDirectory;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<hashSet>5__2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
					string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
					if (!string.IsNullOrWhiteSpace(directoryName) && <hashSet>5__2.Add(directoryName))
					{
						<>2__current = Path.Combine(directoryName, "AK_Sounds");
						<>1__state = 1;
						return true;
					}
					goto IL_007d;
				}
				case 1:
					<>1__state = -1;
					goto IL_007d;
				case 2:
					<>1__state = -1;
					goto IL_00c0;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_00c0:
					currentDirectory = Directory.GetCurrentDirectory();
					if (!string.IsNullOrWhiteSpace(currentDirectory) && <hashSet>5__2.Add(currentDirectory))
					{
						<>2__current = Path.Combine(currentDirectory, "AK_Sounds");
						<>1__state = 3;
						return true;
					}
					break;
					IL_007d:
					if (!string.IsNullOrWhiteSpace(Paths.PluginPath) && <hashSet>5__2.Add(Paths.PluginPath))
					{
						<>2__current = Path.Combine(Paths.PluginPath, "AK_Sounds");
						<>1__state = 2;
						return true;
					}
					goto IL_00c0;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateAkSoundDirectories>d__1199(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateCandidateTransforms>d__159 : IEnumerable<Transform>, IEnumerable, IEnumerator<Transform>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Transform <>2__current;

			private int <>l__initialThreadId;

			private Type menuType;

			public Type <>3__menuType;

			private object menuInstance;

			public object <>3__menuInstance;

			Transform IEnumerator<Transform>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnumerateCandidateTransforms>d__159(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					object obj = menuType.GetProperty("Content", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
					Transform val = (Transform)((obj is Transform) ? obj : null);
					if ((Object)(object)val != (Object)null)
					{
						<>2__current = val;
						<>1__state = 1;
						return true;
					}
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Transform> IEnumerable<Transform>.GetEnumerator()
			{
				<EnumerateCandidateTransforms>d__159 <EnumerateCandidateTransforms>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateCandidateTransforms>d__ = this;
				}
				else
				{
					<EnumerateCandidateTransforms>d__ = new <EnumerateCandidateTransforms>d__159(0);
				}
				<EnumerateCandidateTransforms>d__.menuInstance = <>3__menuInstance;
				<EnumerateCandidateTransforms>d__.menuType = <>3__menuType;
				return <EnumerateCandidateTransforms>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Transform>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateModConfigUiRoots>d__158 : IEnumerable<Transform>, IEnumerable, IEnumerator<Transform>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Transform <>2__current;

			private int <>l__initialThreadId;

			public Plugin <>4__this;

			private object menuInstance;

			public object <>3__menuInstance;

			private Type menuType;

			public Type <>3__menuType;

			private HashSet<int> <hashSet>5__2;

			private IEnumerator<Transform> <>7__wrap2;

			Transform IEnumerator<Transform>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnumerateModConfigUiRoots>d__158(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<hashSet>5__2 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					Plugin plugin = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<hashSet>5__2 = new HashSet<int>();
						<>7__wrap2 = plugin.EnumerateCandidateTransforms(menuInstance, menuType).GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap2.MoveNext())
					{
						Transform current = <>7__wrap2.Current;
						if (!((Object)(object)current == (Object)null) && <hashSet>5__2.Add(((Object)current).GetInstanceID()))
						{
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap2 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap2 != null)
				{
					<>7__wrap2.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Transform> IEnumerable<Transform>.GetEnumerator()
			{
				<EnumerateModConfigUiRoots>d__158 <EnumerateModConfigUiRoots>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateModConfigUiRoots>d__ = this;
				}
				else
				{
					<EnumerateModConfigUiRoots>d__ = new <EnumerateModConfigUiRoots>d__158(0)
					{
						<>4__this = <>4__this
					};
				}
				<EnumerateModConfigUiRoots>d__.menuInstance = <>3__menuInstance;
				<EnumerateModConfigUiRoots>d__.menuType = <>3__menuType;
				return <EnumerateModConfigUiRoots>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Transform>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateRelevantModConfigMemberValues>d__217 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private int <>l__initialThreadId;

			private object instance;

			public object <>3__instance;

			private HashSet<string> <hashSet>5__2;

			private Type <current>5__3;

			private FieldInfo[] <>7__wrap3;

			private int <>7__wrap4;

			private PropertyInfo[] <>7__wrap5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnumerateRelevantModConfigMemberValues>d__217(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<hashSet>5__2 = null;
				<current>5__3 = null;
				<>7__wrap3 = null;
				<>7__wrap5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				PropertyInfo[] properties;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (instance == null)
					{
						return false;
					}
					<hashSet>5__2 = new HashSet<string>(StringComparer.Ordinal);
					<current>5__3 = instance.GetType();
					goto IL_0201;
				case 1:
					<>1__state = -1;
					goto IL_00ec;
				case 2:
					{
						<>1__state = -1;
						goto IL_01c8;
					}
					IL_01d6:
					if (<>7__wrap4 < <>7__wrap5.Length)
					{
						PropertyInfo propertyInfo = <>7__wrap5[<>7__wrap4];
						if (!(propertyInfo == null) && propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0 && <hashSet>5__2.Add("P:" + propertyInfo.Name) && ShouldInspectRelevantModConfigMember(propertyInfo.PropertyType, propertyInfo.Name))
						{
							object obj = null;
							try
							{
								obj = propertyInfo.GetValue(instance, null);
							}
							catch
							{
							}
							if (obj != null)
							{
								<>2__current = obj;
								<>1__state = 2;
								return true;
							}
						}
						goto IL_01c8;
					}
					<>7__wrap5 = null;
					<current>5__3 = <current>5__3.BaseType;
					goto IL_0201;
					IL_0201:
					if (<current>5__3 != null)
					{
						FieldInfo[] fields = <current>5__3.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						<>7__wrap3 = fields;
						<>7__wrap4 = 0;
						goto IL_00fa;
					}
					<current>5__3 = null;
					return false;
					IL_01c8:
					<>7__wrap4++;
					goto IL_01d6;
					IL_00ec:
					<>7__wrap4++;
					goto IL_00fa;
					IL_00fa:
					if (<>7__wrap4 < <>7__wrap3.Length)
					{
						FieldInfo fieldInfo = <>7__wrap3[<>7__wrap4];
						if (!(fieldInfo == null) && <hashSet>5__2.Add("F:" + fieldInfo.Name) && ShouldInspectRelevantModConfigMember(fieldInfo.FieldType, fieldInfo.Name))
						{
							object obj3 = null;
							try
							{
								obj3 = fieldInfo.GetValue(instance);
							}
							catch
							{
							}
							if (obj3 != null)
							{
								<>2__current = obj3;
								<>1__state = 1;
								return true;
							}
						}
						goto IL_00ec;
					}
					<>7__wrap3 = null;
					properties = <current>5__3.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					<>7__wrap5 = properties;
					<>7__wrap4 = 0;
					goto IL_01d6;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<object> IEnumerable<object>.GetEnumerator()
			{
				<EnumerateRelevantModConfigMemberValues>d__217 <EnumerateRelevantModConfigMemberValues>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateRelevantModConfigMemberValues>d__ = this;
				}
				else
				{
					<EnumerateRelevantModConfigMemberValues>d__ = new <EnumerateRelevantModConfigMemberValues>d__217(0);
				}
				<EnumerateRelevantModConfigMemberValues>d__.instance = <>3__instance;
				return <EnumerateRelevantModConfigMemberValues>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<object>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <FindBundleCandidatePaths>d__1027 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private HashSet<string> <seen>5__2;

			private string[] <array>5__3;

			private IEnumerator<string> <>7__wrap3;

			private string <item>5__5;

			private string[] <>7__wrap5;

			private int <>7__wrap6;

			private string[] <>7__wrap7;

			private int <>7__wrap8;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FindBundleCandidatePaths>d__1027(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<seen>5__2 = null;
				<array>5__3 = null;
				<>7__wrap3 = null;
				<item>5__5 = null;
				<>7__wrap5 = null;
				<>7__wrap7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					string[] array;
					string[] array4;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<seen>5__2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
						<array>5__3 = new string[4] { "Weapons_shootzombies.bundle", "ak47_shootzombies.peakbundle", "shootzombies_weapons.peakbundle", "ak.peakbundle" };
						<>7__wrap3 = GetBundleSearchRoots().GetEnumerator();
						<>1__state = -3;
						goto IL_0146;
					case 1:
						<>1__state = -3;
						goto IL_011a;
					case 2:
						{
							<>1__state = -4;
							goto IL_0249;
						}
						IL_0146:
						while (<>7__wrap3.MoveNext())
						{
							<item>5__5 = <>7__wrap3.Current;
							if (string.IsNullOrWhiteSpace(<item>5__5) || !Directory.Exists(<item>5__5))
							{
								continue;
							}
							goto IL_00b1;
						}
						<>m__Finally1();
						<>7__wrap3 = null;
						<>7__wrap3 = GetBundleSearchRoots().GetEnumerator();
						<>1__state = -4;
						goto IL_029d;
						IL_0128:
						if (<>7__wrap6 < <>7__wrap5.Length)
						{
							string path = <>7__wrap5[<>7__wrap6];
							string text = Path.Combine(<item>5__5, path);
							if (File.Exists(text) && <seen>5__2.Add(text))
							{
								<>2__current = text;
								<>1__state = 1;
								return true;
							}
							goto IL_011a;
						}
						<>7__wrap5 = null;
						<item>5__5 = null;
						goto IL_0146;
						IL_029d:
						do
						{
							if (<>7__wrap3.MoveNext())
							{
								<item>5__5 = <>7__wrap3.Current;
								continue;
							}
							<>m__Finally2();
							<>7__wrap3 = null;
							return false;
						}
						while (string.IsNullOrWhiteSpace(<item>5__5) || !Directory.Exists(<item>5__5));
						array = <array>5__3;
						<>7__wrap5 = array;
						<>7__wrap6 = 0;
						goto IL_027c;
						IL_011a:
						<>7__wrap6++;
						goto IL_0128;
						IL_027c:
						if (<>7__wrap6 < <>7__wrap5.Length)
						{
							string searchPattern = <>7__wrap5[<>7__wrap6];
							string[] array2 = Array.Empty<string>();
							try
							{
								array2 = Directory.GetFiles(<item>5__5, searchPattern, SearchOption.AllDirectories);
							}
							catch
							{
							}
							string[] array3 = array2;
							<>7__wrap7 = array3;
							<>7__wrap8 = 0;
							goto IL_0257;
						}
						<>7__wrap5 = null;
						<item>5__5 = null;
						goto IL_029d;
						IL_0249:
						<>7__wrap8++;
						goto IL_0257;
						IL_00b1:
						array4 = <array>5__3;
						<>7__wrap5 = array4;
						<>7__wrap6 = 0;
						goto IL_0128;
						IL_0257:
						if (<>7__wrap8 < <>7__wrap7.Length)
						{
							string item = <>7__wrap7[<>7__wrap8];
							if (<seen>5__2.Add(item))
							{
								<>2__current = item;
								<>1__state = 2;
								return true;
							}
							goto IL_0249;
						}
						<>7__wrap7 = null;
						<>7__wrap6++;
						goto IL_027c;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <FindBundleCandidatePaths>d__1027(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GameplayLoadoutBootstrapCoroutine>d__1087 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			private float <deadline>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GameplayLoadoutBootstrapCoroutine>d__1087(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e8: 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_00cb: Expected O, but got Unknown
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<deadline>5__2 = Time.unscaledTime + 8f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Time.unscaledTime < <deadline>5__2 && IsGameplayScene(SceneManager.GetActiveScene()))
				{
					plugin.ProcessPendingRemoteGrantRequests(force: true);
					Character val = Character.localCharacter ?? _localCharacter;
					if ((Object)(object)val != (Object)null && IsLoadoutGrantEligible(val))
					{
						int characterGrantTrackingId = GetCharacterGrantTrackingId(val);
						if (characterGrantTrackingId != int.MinValue)
						{
							if (CharacterAlreadyHasShootZombiesWeapon(val))
							{
								MarkWeaponGrantedForCharacter(val);
								plugin._gameplayLoadoutBootstrapCoroutine = null;
								return false;
							}
							if (!HasWeaponGrantRecord(characterGrantTrackingId) && !IsPendingRemoteWeaponGrant(characterGrantTrackingId) && !HasRecentWeaponDrop(characterGrantTrackingId))
							{
								TryGiveItemTo(val);
							}
							if (CharacterAlreadyHasShootZombiesWeapon(val))
							{
								MarkWeaponGrantedForCharacter(val);
								plugin._gameplayLoadoutBootstrapCoroutine = null;
								return false;
							}
						}
					}
					<>2__current = (object)new WaitForSecondsRealtime(0.2f);
					<>1__state = 1;
					return true;
				}
				plugin._gameplayLoadoutBootstrapCoroutine = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <GetBundleSearchRoots>d__1028 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string <text2>5__2;

			private string <text3>5__3;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetBundleSearchRoots>d__1028(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<text2>5__2 = null;
				<text3>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string value = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty;
					<text2>5__2 = Paths.PluginPath ?? string.Empty;
					<text3>5__3 = ((string.IsNullOrWhiteSpace(<text2>5__2) || !Directory.Exists(<text2>5__2)) ? string.Empty : (Directory.GetParent(<text2>5__2)?.FullName ?? string.Empty));
					if (!string.IsNullOrWhiteSpace(value))
					{
						<>2__current = value;
						<>1__state = 1;
						return true;
					}
					goto IL_00b9;
				}
				case 1:
					<>1__state = -1;
					goto IL_00b9;
				case 2:
					<>1__state = -1;
					goto IL_00e2;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_00b9:
					if (!string.IsNullOrWhiteSpace(<text2>5__2))
					{
						<>2__current = <text2>5__2;
						<>1__state = 2;
						return true;
					}
					goto IL_00e2;
					IL_00e2:
					if (!string.IsNullOrWhiteSpace(<text3>5__3))
					{
						<>2__current = <text3>5__3;
						<>1__state = 3;
						return true;
					}
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetBundleSearchRoots>d__1028(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetDesiredModConfigSectionOrder>d__230 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetDesiredModConfigSectionOrder>d__230(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = "Weapon";
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = "Zombie";
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = "Features";
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetDesiredModConfigSectionOrder>d__230(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <LoadAudioClipFromFile>d__1201 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string filePath;

			public string selection;

			public Plugin <>4__this;

			private UnityWebRequest <www>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadAudioClipFromFile>d__1201(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<www>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Invalid comparison between Unknown and I4
				bool result;
				try
				{
					int num = <>1__state;
					Plugin plugin = <>4__this;
					switch (num)
					{
					default:
						result = false;
						break;
					case 0:
					{
						<>1__state = -1;
						string text = "file://" + filePath;
						<www>5__2 = UnityWebRequestMultimedia.GetAudioClip(text, GetAudioTypeForPath(filePath));
						<>1__state = -3;
						<>2__current = <www>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					}
					case 1:
					{
						<>1__state = -3;
						if ((int)<www>5__2.result == 1)
						{
							AudioClip content = DownloadHandlerAudioClip.GetContent(<www>5__2);
							if ((Object)(object)content != (Object)null)
							{
								((Object)content).name = Path.GetFileNameWithoutExtension(filePath);
								_externalGunshotSounds[selection] = content;
								if (string.Equals(NormalizeAkSoundSelection(AkSoundSelection?.Value), NormalizeAkSoundSelection(selection), StringComparison.Ordinal))
								{
									plugin.SetGunshotSoundClip(content, selection, isExternal: true);
								}
							}
							result = false;
							<>m__Finally1();
							break;
						}
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogWarning((object)("[ShootZombies] Failed to load AK sound '" + selection + "' from '" + filePath + "': " + <www>5__2.error));
						}
						<>m__Finally1();
						result = false;
						break;
					}
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				_gunshotSoundLoadCoroutine = null;
				((IDisposable)<www>5__2)?.Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <LocalizeModConfigUiCoroutine>d__149 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			public string ownerModName;

			public object menuInstance;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LocalizeModConfigUiCoroutine>d__149(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					if (!plugin.IsOwnedModConfigContextStillValid(ownerModName))
					{
						return false;
					}
					plugin.TryLocalizeVisibleModConfigUi(menuInstance, ownerModName);
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 4)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <PeriodicPlayerScan>d__905 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PeriodicPlayerScan>d__905(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (HasGameplayAuthority() && IsGameplayScene(SceneManager.GetActiveScene()) && IsWeaponFeatureEnabled())
				{
					try
					{
						foreach (Character allCharacter in Character.AllCharacters)
						{
							if ((Object)(object)allCharacter == (Object)null || allCharacter.isBot || allCharacter.isZombie)
							{
								continue;
							}
							int characterGrantTrackingId = GetCharacterGrantTrackingId(allCharacter);
							int firstAidGrantTrackingId = GetFirstAidGrantTrackingId(allCharacter);
							if ((characterGrantTrackingId == int.MinValue && firstAidGrantTrackingId == int.MinValue) || !IsLoadoutGrantEligible(allCharacter))
							{
								continue;
							}
							if (characterGrantTrackingId != int.MinValue)
							{
								RepairMissingWeaponGrantRecord(allCharacter, characterGrantTrackingId);
							}
							bool flag = characterGrantTrackingId != int.MinValue && HasWeaponGrantRecord(characterGrantTrackingId);
							bool flag2 = firstAidGrantTrackingId != int.MinValue && HasFirstAidGrantRecord(firstAidGrantTrackingId);
							if (!(flag && flag2))
							{
								if (!flag2 && firstAidGrantTrackingId != int.MinValue)
								{
									TryGrantFirstAidWithAuthority(allCharacter, firstAidGrantTrackingId);
								}
								if (!flag && characterGrantTrackingId != int.MinValue)
								{
									TryGrantWeaponWithAuthority(allCharacter, characterGrantTrackingId);
								}
							}
						}
					}
					catch (Exception)
					{
					}
				}
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 2;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <RefreshLocalizedUiAfterStartup>d__959 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RefreshLocalizedUiAfterStartup>d__959(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 3:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 120 && !plugin.TryResolveGameLanguage(out var _, out var _, out var _))
				{
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				if (!IsModConfigUiRuntimeSafe())
				{
					return false;
				}
				plugin.ReinitializeConfig();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <StabilizeOwnedModConfigUiCoroutine>d__155 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			public string ownerModName;

			public object menuInstance;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <StabilizeOwnedModConfigUiCoroutine>d__155(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				bool result;
				try
				{
					int num = <>1__state;
					Plugin plugin = <>4__this;
					if (num == 0)
					{
						<>1__state = -1;
						<>1__state = -3;
						<i>5__2 = 0;
						goto IL_01c9;
					}
					if (num == 1)
					{
						<>1__state = -3;
						if (!plugin.IsOwnedModConfigContextStillValid(ownerModName))
						{
							result = false;
							goto IL_01de;
						}
						if (IsModConfigUiRuntimeSafe())
						{
							if (!TryGetModConfigMenuInstance(out var menuType, out var obj))
							{
								if (menuInstance == null)
								{
									goto IL_01b7;
								}
								obj = menuInstance;
								menuType = menuInstance.GetType();
							}
							Behaviour val = (Behaviour)((obj is Behaviour) ? obj : null);
							if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)null))
							{
								bool flag;
								try
								{
									flag = val.isActiveAndEnabled && ((Component)val).gameObject.activeInHierarchy;
								}
								catch
								{
									flag = false;
								}
								if (flag)
								{
									plugin.SyncActiveModConfigName(obj, menuType);
									if (!plugin.IsOwnedModConfigContextStillValid(ownerModName))
									{
										result = false;
										goto IL_01de;
									}
									plugin.EnsureOwnedModConfigEntriesRegistered(menuType);
									bool flag2 = plugin.NeedsOwnedModConfigSectionRebuild(obj, menuType);
									bool isChinese = plugin.IsChineseLanguage();
									if (flag2)
									{
										plugin.RepairOwnedModConfigSections(obj, menuType);
									}
									plugin.RepairOwnedModConfigState(obj, menuType);
									NormalizeOwnedSectionTabCategories(obj, menuType, isChinese);
									LocalizeOwnedModConfigSectionTabs(obj, menuType, isChinese);
									Dictionary<string, string> map = plugin.BuildModConfigUiLocalizationMap(isChinese);
									foreach (Transform item in plugin.EnumerateModConfigUiRoots(obj, menuType))
									{
										plugin.ApplyTextLocalizationToRoot(item, map);
									}
									if (!plugin.NeedsOwnedModConfigSectionRebuild(obj, menuType) && AreOwnedSectionTabLabelsStable(obj, menuType, isChinese))
									{
										goto IL_01d6;
									}
								}
							}
						}
						goto IL_01b7;
					}
					result = false;
					goto end_IL_0000;
					IL_01b7:
					<i>5__2++;
					goto IL_01c9;
					IL_01de:
					<>m__Finally1();
					goto end_IL_0000;
					IL_01d6:
					<>m__Finally1();
					result = false;
					goto end_IL_0000;
					IL_01c9:
					if (<i>5__2 >= 20)
					{
						goto IL_01d6;
					}
					<>2__current = null;
					<>1__state = 1;
					result = true;
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				Plugin plugin = <>4__this;
				plugin._modConfigStabilizeCoroutine = null;
				if (string.Equals(plugin._modConfigStabilizeOwnerName, NormalizeModConfigContextName(ownerModName), StringComparison.OrdinalIgnoreCase))
				{
					plugin._modConfigStabilizeOwnerName = string.Empty;
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ZombieHitEffect>d__73 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Character zombie;

			private Vector3 <originalPosition>5__2;

			private int <i>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ZombieHitEffect>d__73(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Expected O, but got Unknown
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				Vector3 val = default(Vector3);
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)zombie == (Object)null)
					{
						return false;
					}
					<originalPosition>5__2 = ((Component)zombie).transform.position;
					val = default(Vector3);
					<i>5__3 = 0;
					goto IL_0127;
				case 1:
					<>1__state = -1;
					if (!((Object)(object)zombie == (Object)null))
					{
						((Component)zombie).transform.position = <originalPosition>5__2;
						<>2__current = (object)new WaitForSeconds(0.05f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					{
						<>1__state = -1;
						<i>5__3++;
						goto IL_0127;
					}
					IL_0127:
					if (<i>5__3 < 3 && !((Object)(object)zombie == (Object)null))
					{
						((Vector3)(ref val))..ctor(Random.Range(-0.1f, 0.1f), 0f, Random.Range(-0.1f, 0.1f));
						((Component)zombie).transform.position = <originalPosition>5__2 + val;
						<>2__current = (object)new WaitForSeconds(0.05f);
						<>1__state = 1;
						return true;
					}
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly string[] PreferredAkItemContentAssetNames = new string[1] { "assets/_ak/ic_ak.asset" };

		private static readonly string[] PreferredAkPrefabAssetNames = new string[4] { "assets/codexbuild/generated/weapon_bundle.prefab", "assets/weapon/weapon.prefab", "assets/_ak/ak.prefab", "assets/_ak/prefabs/ak.prefab" };

		private static readonly string[] PreferredAkIconAssetNames = new string[5] { "assets/weapon/ak47_icon.png", "assets/weapon/mpx_icon.png", "assets/weapon/hk416_icon.png", "assets/_ak/textures/ak_icon.asset", "assets/_ak/ak_icon.asset" };

		private static readonly string[] PreferredAkVfxAssetNames = new string[2] { "assets/_ak/vfx_ak.prefab", "VFX_AK" };

		private static readonly bool EnableDiagnosticLogs = false;

		private static readonly bool EnableVerboseInfoLogs = false;

		private const string LegacyPluginId = "com.github.PeakTest.ShootZombies";

		public const string Id = "com.github.Thanks.ShootZombies";

		public const string Name = "ShootZombies";

		public const string Version = "1.3.6";

		private const string CanonicalConfigFileName = "Thanks.ShootZombies.cfg";

		private const string PreviousCanonicalConfigFileName = "com.github.Thanks.ShootZombies.cfg";

		private const string LegacyCanonicalConfigFileName = "com.github.PeakTest.ShootZombies.cfg";

		private const string LocalizedConfigMirrorFileName = "Thanks.ShootZombies.localized.cfg";

		private const string PreviousLocalizedConfigMirrorFileName = "com.github.Thanks.ShootZombies.localized.cfg";

		private const string LegacyLocalizedConfigMirrorFileName = "com.github.PeakTest.ShootZombies.localized.cfg";

		private const string ConfigMetadataZombieDifficultyPrefix = "## ShootZombiesZombieDifficulty: ";

		private const string FeaturesConfigSectionName = "Features";

		private const string WeaponConfigSectionName = "Weapon";

		private const string ZombieConfigSectionName = "Zombie";

		private static HashSet<int> _receivedItem = new HashSet<int>();

		private static HashSet<int> _persistentReceivedItem = new HashSet<int>();

		private static HashSet<int> _receivedFirstAid = new HashSet<int>();

		private static HashSet<int> _persistentReceivedFirstAid = new HashSet<int>();

		private static HashSet<int> _pendingRemoteWeaponGrantActors = new HashSet<int>();

		private static HashSet<int> _pendingRemoteFirstAidGrantActors = new HashSet<int>();

		private static Dictionary<int, float> _lastWeaponGrantTimeByActor = new Dictionary<int, float>();

		private static Dictionary<int, float> _lastFirstAidGrantTimeByActor = new Dictionary<int, float>();

		private static Dictionary<int, float> _weaponMissingSinceByActor = new Dictionary<int, float>();

		private static Dictionary<int, float> _recentWeaponDropTimeByActor = new Dictionary<int, float>();

		private static Character _localCharacter;

		private static float _lastFireTime;

		private static bool _hasWeapon;

		private static Coroutine _scanCoroutine;

		private Coroutine _gameplayLoadoutBootstrapCoroutine;

		private static string _activeSceneBucket = string.Empty;

		private static Transform _localWeaponVisualRoot;

		private static Transform _localWeaponVisualModel;

		private static Transform _localWeaponMuzzle;

		private static Transform _localHeldDebugSphereRoot;

		private static Material _localHeldDebugSphereMaterial;

		private static bool _localFirstPersonHandsSuppressed;

		private static Character _weaponVisualOwner;

		private static int _localWeaponSourceItemId;

		private static float _lastHeldWeaponSeenTime;

		private static Item _cachedHeldBlowgunItem;

		private static float _lastHeldBlowgunSearchTime = -10f;

		private static readonly Vector3 _localWeaponOffset = new Vector3(-0.08f, -0.18f, 0.62f);

		private static readonly Vector3 _localHeldDebugSphereOffset = new Vector3(0.24f, -0.12f, 0.72f);

		private static readonly Vector3 _localHeldDebugSphereScale = Vector3.one * 0.18f;

		private static readonly Vector3 _localWeaponEuler = Vector3.zero;

		private static readonly Vector3 _localWeaponRootScale = Vector3.one;

		private static readonly Vector3 _localWeaponModelOffset = Vector3.zero;

		private static readonly Vector3 _localWeaponModelEuler = Vector3.zero;

		private static readonly Vector3 _localWeaponViewEulerOffset = new Vector3(0f, 180f, 0f);

		private static readonly Vector3 _localWeaponModelScale = Vector3.one;

		private static readonly Vector3 _weaponBaseEuler = new Vector3(0f, -90f, 0f);

		private const float LocalWeaponModelBaseScaleMultiplier = 1.275f;

		private static readonly string[] LocalWeaponExcludedRendererKeywords = new string[10] { "hand", "arm", "finger", "collider", "trigger", "vfx", "effect", "spawn", "holiday", "smoke" };

		private static readonly string[] LocalFirstPersonHandSuppressionKeywords = new string[7] { "hand", "arm", "finger", "glove", "wrist", "forearm", "sleeve" };

		private static Vector3 _localWeaponModelBaseScale = Vector3.one;

		private static Vector3 _localWeaponModelBasePosition = Vector3.zero;

		private static Quaternion _localWeaponModelBaseRotation = Quaternion.identity;

		private static bool _localWeaponModelUsesPreparedPose;

		private static bool _pendingLocalWeaponVisualModelRefresh;

		private const float LocalWeaponMissingTolerance = 4f;

		private static readonly bool EnableLocalWeaponVisualFollower = false;

		private const bool EnableLocalHeldDebugSphere = false;

		private const bool PreferStableLocalFirstPersonPose = true;

		private const float LocalWeaponFirstPersonFinalTargetSize = 0.9f;

		private const float LocalWeaponFirstPersonMinBaseSize = 0.24f;

		private const float LocalWeaponFirstPersonMaxBaseSize = 0.8f;

		private const float LocalWeaponModelScaleClampMin = 0.01f;

		private const float LocalWeaponModelScaleClampMax = 96f;

		private const string DefaultAkSoundOption = "ak_sound1";

		private static readonly string[] AkSoundSelectionValues = new string[3] { "ak_sound1", "ak_sound2", "ak_sound3" };

		private const string DefaultConfigPanelThemeOption = "dark";

		private static readonly string[] ConfigPanelThemeValues = new string[3] { "dark", "light", "transparent" };

		private const string DefaultWeaponSelection = "AK47";

		private const string PlayerWeaponSelectionPropertyKey = "sz.weapon";

		private const string PlayerAkSoundSelectionPropertyKey = "sz.sound";

		private static readonly string[] WeaponSelectionValues = new string[3] { "AK47", "MPX", "HK416" };

		private const string DefaultZombieBehaviorDifficulty = "Easy";

		private const int DefaultMaxZombieCount = 2;

		private const int DefaultZombieSpawnCount = 1;

		private const float DefaultZombieKnockbackForce = 200f;

		private static readonly string[] ZombieBehaviorDifficultyValues = new string[5] { "Easy", "Standard", "Hard", "Insane", "Nightmare" };

		private static readonly ZombieBehaviorDifficultyPreset[] ZombieBehaviorDifficultyPresets = new ZombieBehaviorDifficultyPreset[5]
		{
			new ZombieBehaviorDifficultyPreset(1f, 650f, 10f, 3f, 5f, 20f, 3f, 8f, 1.5f, 5f, 30f, 30f),
			new ZombieBehaviorDifficultyPreset(1.05f, 500f, 6f, 2.5f, 4f, 22f, 2.25f, 10f, 1.65f, 4f, 40f, 34f),
			new ZombieBehaviorDifficultyPreset(1.15f, 425f, 3f, 1.5f, 2.75f, 26f, 1.25f, 12f, 1.85f, 2.5f, 55f, 44f),
			new ZombieBehaviorDifficultyPreset(1.25f, 350f, 1.5f, 0.9f, 1.75f, 30f, 0.85f, 13f, 2f, 1.5f, 72f, 58f),
			new ZombieBehaviorDifficultyPreset(1.35f, 275f, 0.75f, 0.55f, 1.1f, 34f, 0.65f, 14f, 2.15f, 0.85f, 90f, 72f)
		};

		private static readonly WeaponVariantDefinition[] WeaponVariantDefinitions = new WeaponVariantDefinition[3]
		{
			new WeaponVariantDefinition
			{
				SelectionKey = "AK47",
				DisplayName = "AK47",
				PrefabAliases = new string[2] { "ak47", "ak" },
				IconAliases = new string[2] { "ak47icon", "akicon" },
				ScaleMultiplier = 1f,
				PositionOffset = Vector3.zero
			},
			new WeaponVariantDefinition
			{
				SelectionKey = "MPX",
				DisplayName = "MPX",
				PrefabAliases = new string[1] { "mpx" },
				IconAliases = new string[1] { "mpxicon" },
				ScaleMultiplier = 0.729f,
				PositionOffset = new Vector3(0f, -0.015f, 0f)
			},
			new WeaponVariantDefinition
			{
				SelectionKey = "HK416",
				DisplayName = "HK416",
				PrefabAliases = new string[2] { "hk416", "hk417" },
				IconAliases = new string[2] { "hk416icon", "hk417icon" },
				ScaleMultiplier = 1f,
				PositionOffset = Vector3.zero
			}
		};

		public static AudioClip _gunshotSound;

		private static readonly Dictionary<string, AudioClip> _externalGunshotSounds = new Dictionary<string, AudioClip>(StringComparer.OrdinalIgnoreCase);

		private static Coroutine _gunshotSoundLoadCoroutine;

		private static string _currentGunshotSoundSelection = "ak_sound1";

		private static bool _resourcesLoaded;

		private const float GameplaySceneWarmupSeconds = 10f;

		private const float LobbySceneWarmupSeconds = 1.5f;

		private const float OtherSceneWarmupSeconds = 0.5f;

		private static float _sceneWarmupUntilUnscaledTime;

		private static string _sceneWarmupSceneName = string.Empty;

		public static GameObject _ak47Prefab;

		private static AssetBundle _ak47Bundle;

		private static GameObject _ak47VFX;

		private static object _ak47ItemContent;

		private static Material _localVisualFallbackMaterial;

		public static Texture2D _ak47IconTexture;

		private static readonly Dictionary<string, GameObject> _resolvedWeaponPrefabs = new Dictionary<string, GameObject>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Texture2D> _resolvedWeaponIcons = new Dictionary<string, Texture2D>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<int, string> _playerWeaponSelectionsByActor = new Dictionary<int, string>();

		private static readonly Dictionary<int, string> _playerAkSoundSelectionsByActor = new Dictionary<int, string>();

		private static readonly List<GameObject> _runtimeWeaponPrefabClones = new List<GameObject>();

		private static GameObject _genericResolvedWeaponPrefab;

		private static Texture2D _genericResolvedWeaponIcon;

		private static bool _useExplicitSelectedWeaponIcon;

		private static readonly HashSet<string> _diagnosticLogKeys = new HashSet<string>(StringComparer.Ordinal);

		private static Type _actionRaycastDartType;

		private static Type _actionConsumeType;

		private static Type _actionConsumeAndSpawnType;

		private static MethodInfo _characterAddForceMethod;

		private static MethodInfo _characterCanDoInputMethod;

		private static FieldInfo _dartVfxField;

		private static MethodInfo _actionRunActionMethod;

		private static FieldInfo _actionRaycastDartSpawnTransformField;

		private static Material _muzzleFlashMaterial;

		private static readonly List<MuzzleFlashInstance> _muzzleFlashPool = new List<MuzzleFlashInstance>();

		private static int _nextMuzzleFlashPoolIndex;

		private static readonly List<RemoteGunshotAudioInstance> _remoteGunshotAudioPool = new List<RemoteGunshotAudioInstance>();

		private static int _nextRemoteGunshotAudioPoolIndex;

		private static readonly List<DartImpactVfxInstance> _dartImpactVfxPool = new List<DartImpactVfxInstance>();

		private static int _nextDartImpactVfxPoolIndex;

		private static FieldInfo _castProgressField;

		private static float _lastChargeSyncTime;

		private static int _lastChargeSyncItemId = int.MinValue;

		private static MethodInfo _itemGetDataGenericMethod;

		private static Type _optionableIntItemDataType;

		private static object _usesDataKey;

		private static FieldInfo _optionableIntValueField;

		private static bool _characterCanDoInputMethodInitialized;

		private static float _lastUseSyncTime;

		private static AudioSource _sharedAudioSource;

		private static AudioSource _sharedFallbackGunshotAudioSource;

		private static float _lastSoundTime;

		public static OrbFogHandler _orbFogHandler;

		private static GameObject _fogUIObject;

		private static GameObject _fogTimerUIObject;

		private static RectTransform _fogUIContainerRect;

		private static GameObject _fogModeLobbyNoticeObject;

		private static TextMeshProUGUI _fogModeLobbyNoticeText;

		private static RectTransform _fogModeLobbyNoticeRect;

		private static GameObject _sharedFogBottomLeftRootObject;

		private static RectTransform _sharedFogBottomLeftRootRect;

		private static Canvas _sharedFogBottomLeftRootCanvas;

		private static string _lastFogModeLobbyNoticeText = string.Empty;

		private static GameObject _weaponLobbyNoticeObject;

		private static TextMeshProUGUI _weaponLobbyNoticeText;

		private static RectTransform _weaponLobbyNoticeRect;

		private static string _lastWeaponLobbyNoticeText = string.Empty;

		private static float _lastWeaponLobbyNoticeLayoutTime = -10f;

		private static RectTransform _cachedVersionLabelRect;

		private static float _lastVersionLabelSearchTime;

		private const float LobbyNoticeRightOffset = 28f;

		private const float LobbyNoticeDownOffset = 96f;

		private const float LobbyNoticeWidth = 980f;

		private const float LobbyNoticeSingleLineHeight = 108f;

		private const float LobbyNoticeMultiLineHeight = 166f;

		private const float LobbyNoticeFontSizeMultiplier = 1.6f;

		private const float LobbyNoticeLineSpacing = 1.5f;

		private const float FogUiVersionHorizontalGap = 28f;

		private const float FogUiAnchorLeftNudge = -8f;

		private const float FogUiAnchorTopNudge = 4f;

		private const float FogUiMainWidth = 410f;

		private const float FogUiTimerWidth = 220f;

		private const float FogUiComponentGap = 3f;

		private const float FogUiRowHeight = 38f;

		private const float FogUiContainerHeight = 40f;

		private const float FogUiCanvasOverflowXRatio = 0.25f;

		private const float FogUiCanvasOverflowYRatio = 0.25f;

		private const float FogUiCanvasOverflowXMax = 320f;

		private const float FogUiCanvasOverflowYMax = 220f;

		private const float FogUiSharedTopReferenceHeight = 108f;

		private const float FogModeLobbyNoticeWidth = 700f;

		private const float FogModeLobbyNoticeFontSizeMultiplier = 1.05f;

		private const float FogModeForcedSpeed = 2f;

		private const float FogModeForcedWaitTime = 90f;

		private const float WeaponLobbyNoticeRightOffset = 36f;

		private const float WeaponLobbyNoticeBottomOffset = 76f;

		private const float WeaponLobbyNoticeWidth = 420f;

		private const float WeaponLobbyNoticeMinWidth = 120f;

		private const float WeaponLobbyNoticeSingleLineHeight = 56f;

		private const float WeaponLobbyNoticeMultiLineHeight = 96f;

		private const float WeaponLobbyNoticeFontSizeMultiplier = 1.05f;

		private const float WeaponLobbyNoticeCompassVerticalGap = 2f;

		private const float WeaponLobbyNoticeScaleMultiplier = 0.75f;

		private const string LobbyNoticeKeyColor = "#FF3B30";

		private const byte ZombieHitEventCode = 178;

		private const byte RemoteLoadoutGrantEventCode = 180;

		private const byte RemoteShotEffectsEventCode = 181;

		private const byte RemoteLoadoutGrantAckEventCode = 182;

		private const byte PlayerShotStatusEventCode = 183;

		private const byte ZombieHealthEventCode = 184;

		private const float PlayerShotSporeReductionFraction = 0.05f;

		private const float PlayerShotColdFraction = 0.025f;

		private const int RemoteLoadoutGrantWeapon = 1;

		private const int RemoteLoadoutGrantFirstAid = 2;

		private const string RoomConfigPropertyKey = "ShootZombies.HostConfig";

		private const float RoomConfigPublishInterval = 0.35f;

		private const float RoomConfigPollInterval = 1f;

		private const float ZombieSpeedRefreshInterval = 1.5f;

		private const float DefaultZombieTimeReductionSeconds = 25f;

		private const float DefaultHitScanDistance = 100f;

		private const float DefaultHitScanRadius = 0.1f;

		private const float HeldBlowgunSearchInterval = 0.15f;

		private const float PlayerScanInitialDelay = 2f;

		private const float PlayerScanInterval = 5f;

		private const float LanguagePollInterval = 0.5f;

		private const float ChargeStateSyncInterval = 0.2f;

		private const float PendingRemoteGrantRetryInterval = 0.5f;

		private const float ScheduledRoomConfigSyncInterval = 0.1f;

		private const float ScheduledConfigCheckInterval = 0.1f;

		private const float ScheduledLobbyNoticeInterval = 0.25f;

		private const float ScheduledZombieTimerInterval = 0.25f;

		private const float ScheduledZombieSpeedInterval = 0.5f;

		private const float ScheduledZombieHealthBarInterval = 0.25f;

		private const float ScheduledLocalCharacterRefreshInterval = 0.1f;

		private const float ScheduledPendingRemoteGrantInterval = 0.25f;

		private const float ScheduledWeaponOwnershipInterval = 0.25f;

		private const float GameplayLoadoutBootstrapRetryInterval = 0.2f;

		private const float GameplayLoadoutBootstrapDuration = 8f;

		private const float MuzzleFlashDuration = 0.08f;

		private const int MaxMuzzleFlashPoolSize = 8;

		private const int MaxRemoteGunshotAudioPoolSize = 12;

		private const float RemoteGunshotAudioReleasePadding = 0.1f;

		private const int MaxDartImpactVfxPoolSizePerPrefab = 8;

		private const float DefaultDartImpactVfxLifetime = 2f;

		private const float RemoteLoadoutGrantRetryTimeout = 2.5f;

		private const float LoadoutRepairGracePeriod = 4f;

		private const float LoadoutMissingConfirmDuration = 1.5f;

		private const float WeaponDropGrantSuppressDuration = 15f;

		private const float LobbyNoticeLayoutRefreshInterval = 1f;

		private const float NightTestHoldDuration = 5f;

		private const float NightTestTargetTimeOfDay = 23.75f;

		private const KeyCode NightTestKey = 92;

		private static HashSet<Material> _processedMaterials = new HashSet<Material>();

		private static float _lastMaterialUpdateTime = 0f;

		private static bool _pendingAkVisualRefresh = true;

		private static bool _pendingAkVisualForceRefresh;

		private static bool _pendingAkUiRefresh = true;

		private static HashSet<GameObject> _replacedBlowguns = new HashSet<GameObject>();

		private bool _lastLanguageSetting;

		private bool _cachedIsChineseLanguage;

		private float _lastLanguagePollTime = -10f;

		private float _lastZombieMoveSpeed;

		private float _lastZombieKnockbackForce;

		private bool _lastZombieSpawnEnabled;

		private float _lastZombieSpawnInterval;

		private float _lastZombieSpawnIntervalRandom;

		private int _lastZombieSpawnCount;

		private int _lastZombieSpawnCountRandom;

		private float _lastZombieSpawnRadius;

		private int _lastMaxZombies;

		private float _lastZombieMaxLifetime;

		private float _lastDistanceBeforeWakeup;

		private float _lastZombieSprintDistance;

		private float _lastChaseTimeBeforeSprint;

		private float _lastZombieLungeDistance;

		private float _lastZombieBiteRecoveryTime;

		private float _lastZombieLungeTime;

		private float _lastZombieLungeRecoveryTime;

		private float _lastZombieLookAngleBeforeWakeup;

		private string _lastZombieBehaviorDifficulty = "Easy";

		private string _loadedZombieBehaviorDifficultyMetadata = string.Empty;

		private bool _lastModEnabled;

		private bool _lastWeaponEnabled;

		private bool _restoredVanillaBlowgunFunctionalityForDisabledFeature;

		private string _lastWeaponSelection = "AK47";

		private string _lastPublishedLocalWeaponSelection = string.Empty;

		private string _lastPublishedLocalAkSoundSelection = string.Empty;

		private float _lastWeaponModelPitch;

		private float _lastWeaponModelYaw;

		private float _lastWeaponModelRoll;

		private float _lastWeaponModelScale;

		private float _lastWeaponModelOffsetX;

		private float _lastWeaponModelOffsetY;

		private float _lastWeaponModelOffsetZ;

		private float _lastFireInterval;

		private float _lastFireVolume;

		private float _lastZombieTimeReduction;

		private float _nightTestHoldStartTime = -1f;

		private bool _nightTestTriggeredThisHold;

		private bool _isRefreshingLanguage;

		private bool _applyingRoomConfigPayload;

		private string _activeRoomConfigRoomName = string.Empty;

		private string _lastPublishedRoomConfigPayload = string.Empty;

		private string _lastAppliedRoomConfigPayload = string.Empty;

		private string _localRoomConfigBackupPayload = string.Empty;

		private bool _hasLocalRoomConfigBackup;

		private bool _wasRoomMasterClient;

		private float _lastRoomConfigPublishTime = -10f;

		private float _lastRoomConfigPollTime = -10f;

		private bool _roomConfigDirty = true;

		private bool _roomConfigCallbacksRegistered;

		private bool _pendingRemoteWeaponGrant;

		private bool _pendingRemoteFirstAidGrant;

		private float _lastPendingRemoteGrantAttemptTime = -10f;

		private ConfigFile _pluginConfig;

		private string _pluginConfigPath = string.Empty;

		private readonly Dictionary<ConfigEntryBase, Delegate> _observedConfigEntries = new Dictionary<ConfigEntryBase, Delegate>();

		private RoomConfigCallbackProxy _roomConfigCallbackProxy;

		private int _lastLocalizedModConfigUiFrame = -1;

		private static readonly HashSet<ConfigEntryBase> _ownedConfigEntries = new HashSet<ConfigEntryBase>();

		private static readonly bool DisableModConfigRuntimePatches = false;

		private bool _repairingModConfigUi;

		private string _activeModConfigName = string.Empty;

		private Coroutine _modConfigStabilizeCoroutine;

		private string _modConfigStabilizeOwnerName = string.Empty;

		private static float _lastZombieSpeedUpdateTime = 0f;

		private static Dictionary<Character, float> _zombieBaseSpeeds = new Dictionary<Character, float>();

		private static bool _pendingZombieSpeedRefresh = true;

		private static readonly Dictionary<MemberAccessorCacheKey, ReflectionMemberCacheEntry> _reflectionMemberCache = new Dictionary<MemberAccessorCacheKey, ReflectionMemberCacheEntry>();

		private static readonly Dictionary<Type, ZombieSpeedReflectionCache> _zombieSpeedReflectionCache = new Dictionary<Type, ZombieSpeedReflectionCache>();

		private float _nextRoomConfigSyncTime = -10f;

		private float _nextConfigCheckTime = -10f;

		private float _nextLobbyNoticeUpdateTime = -10f;

		private float _nextZombieTimerUpdateTime = -10f;

		private float _nextZombieSpeedUpdateCheckTime = -10f;

		private float _nextZombieHealthBarRefreshTime = -10f;

		private float _nextLocalCharacterRefreshTime = -10f;

		private float _nextPendingRemoteGrantProcessTime = -10f;

		private float _nextWeaponOwnershipUpdateTime = -10f;

		private LobbyConfigPanel _lobbyConfigPanel;

		private static readonly Dictionary<ItemUIData, WeaponItemUiInteractionState> _weaponItemUiInteractionStateByData = new Dictionary<ItemUIData, WeaponItemUiInteractionState>();

		private ConfigFile PluginConfig => _pluginConfig ?? ((BaseUnityPlugin)this).Config;

		public static Plugin Instance { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		public static ConfigEntry<float> FireInterval { get; private set; }

		public static ConfigEntry<float> ZombieTimeReduction { get; private set; }

		public static ConfigEntry<float> FireVolume { get; private set; }

		public static ConfigEntry<float> WeaponModelPitch { get; private set; }

		public static ConfigEntry<float> WeaponModelYaw { get; private set; }

		public static ConfigEntry<float> WeaponModelRoll { get; private set; }

		public static ConfigEntry<float> WeaponModelScale { get; private set; }

		public static ConfigEntry<float> WeaponModelOffsetX { get; private set; }

		public static ConfigEntry<float> WeaponModelOffsetY { get; private set; }

		public static ConfigEntry<float> WeaponModelOffsetZ { get; private set; }

		public static ConfigEntry<string> AkSoundSelection { get; private set; }

		public static ConfigEntry<string> WeaponSelection { get; private set; }

		public static ConfigEntry<KeyCode> SpawnWeaponKey { get; private set; }

		public static ConfigEntry<KeyCode> OpenConfigPanelKey { get; private set; }

		public static ConfigEntry<string> ConfigPanelTheme { get; private set; }

		public static ConfigEntry<bool> ModEnabled { get; private set; }

		public static ConfigEntry<bool> WeaponEnabled { get; private set; }

		public static ConfigEntry<float> ZombieMoveSpeed { get; private set; }

		public static ConfigEntry<float> ZombieAggressiveness { get; private set; }

		public static ConfigEntry<float> ZombieKnockbackForce { get; private set; }

		public static ConfigEntry<bool> ZombieSpawnEnabled { get; private set; }

		public static ConfigEntry<float> ZombieSpawnInterval { get; private set; }

		public static ConfigEntry<float> ZombieSpawnIntervalRandom { get; private set; }

		public static ConfigEntry<float> ZombieSpawnRadius { get; private set; }

		public static ConfigEntry<int> ZombieSpawnCount { get; private set; }

		public static ConfigEntry<int> ZombieSpawnCountRandom { get; private set; }

		public static ConfigEntry<int> MaxZombies { get; private set; }

		public static ConfigEntry<float> ZombieMaxLifetime { get; private set; }

		public static ConfigEntry<float> ZombieDestroyDistance { get; private set; }

		public static ConfigEntry<float> DistanceBeforeWakeup { get; private set; }

		public static ConfigEntry<float> DistanceBeforeChase { get; private set; }

		public static ConfigEntry<float> ZombieSprintDistance { get; private set; }

		public static ConfigEntry<float> ChaseTimeBeforeSprint { get; private set; }

		public static ConfigEntry<float> ZombieLungeDistance { get; private set; }

		public static ConfigEntry<string> ZombieBehaviorDifficulty { get; private set; }

		public static ConfigEntry<float> ZombieTargetSearchInterval { get; private set; }

		public static ConfigEntry<float> ZombieBiteRecoveryTime { get; private set; }

		public static ConfigEntry<float> ZombieSamePlayerBiteCooldown { get; private set; }

		public static ConfigEntry<float> ZombieLungeTime { get; private set; }

		public static ConfigEntry<float> ZombieLungeRecoveryTime { get; private set; }

		public static ConfigEntry<float> ZombieLookAngleBeforeWakeup { get; private set; }

		private void EnsureVanillaBlowgunFunctionalityWhenWeaponDisabled()
		{
			if (IsWeaponFeatureEnabled())
			{
				_restoredVanillaBlowgunFunctionalityForDisabledFeature = false;
			}
			else if (!_restoredVanillaBlowgunFunctionalityForDisabledFeature)
			{
				RestoreVanillaBlowgunFeatureState();
			}
		}

		private void RestoreVanillaBlowgunFeatureState()
		{
			BlowgunInfiniteUsePatch.RestoreVanillaSingleUseOnAllBlowguns();
			RestoreWeaponItemInteractionRestrictionsOnAllBlowguns();
			HideUseItemProgressPatch.RestoreVanillaUseProgressOnAllUi();
			ItemUIDataPatch.ForceRefreshVisibleUi();
			_lastChargeSyncItemId = int.MinValue;
			_hasWeapon = false;
			_restoredVanillaBlowgunFunctionalityForDisabledFeature = true;
		}

		private void CheckNightTestHotkey()
		{
			if (!IsModFeatureEnabled() || !IsGameplayScene())
			{
				ResetNightTestHotkeyState();
				return;
			}
			if (!Input.GetKey((KeyCode)92))
			{
				ResetNightTestHotkeyState();
				return;
			}
			if (_nightTestHoldStartTime < 0f)
			{
				_nightTestHoldStartTime = Time.unscaledTime;
			}
			if (!_nightTestTriggeredThisHold && !(Time.unscaledTime - _nightTestHoldStartTime < 5f))
			{
				_nightTestTriggeredThisHold = true;
				SwitchToNightForTesting();
			}
		}

		private void ResetNightTestHotkeyState()
		{
			_nightTestHoldStartTime = -1f;
			_nightTestTriggeredThisHold = false;
		}

		private void SwitchToNightForTesting()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			if (!HasGameplayAuthority())
			{
				if (EnableVerboseInfoLogs)
				{
					bool cachedChineseLanguageSetting = GetCachedChineseLanguageSetting();
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogInfo((object)(cachedChineseLanguageSetting ? "[ShootZombies] 夜晚测试按键仅支持单机或房主使用。" : "[ShootZombies] The night test hotkey only works offline or for the room host."));
					}
				}
				return;
			}
			DayNightManager instance = DayNightManager.instance;
			if ((Object)instance == (Object)null)
			{
				bool cachedChineseLanguageSetting2 = GetCachedChineseLanguageSetting();
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)(cachedChineseLanguageSetting2 ? "[ShootZombies] 未找到 DayNightManager，无法切换到夜晚。" : "[ShootZombies] DayNightManager was not found, so night switching could not be applied."));
				}
				return;
			}
			instance.setTimeOfDay(23.75f);
			instance.UpdateCycle();
			PhotonView component = ((Component)instance).GetComponent<PhotonView>();
			if ((Object)component != (Object)null && HasOnlineRoomSession() && PhotonNetwork.IsMasterClient)
			{
				component.RPC("RPCA_SyncTime", (RpcTarget)0, new object[1] { 23.75f });
			}
			if (EnableVerboseInfoLogs)
			{
				bool cachedChineseLanguageSetting3 = GetCachedChineseLanguageSetting();
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogInfo((object)(cachedChineseLanguageSetting3 ? "[ShootZombies] 已切换到夜晚测试时间。长按 \\ 键 5 秒可再次触发。" : "[ShootZombies] Switched to night test time. Hold \\ for 5 seconds to trigger it again."));
				}
			}
		}

		private void LogNightTestHotkeyHint()
		{
			if (EnableVerboseInfoLogs)
			{
				bool cachedIsChineseLanguage = _cachedIsChineseLanguage;
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)(cachedIsChineseLanguage ? "[ShootZombies] 测试按键：在游戏内长按 \\ 键 5 秒可切换到夜晚。" : "[ShootZombies] Test hotkey: hold \\ for 5 seconds during gameplay to switch to night."));
				}
			}
		}

		private void SpawnWeaponAtPlayer()
		{
			Character val = _localCharacter ?? Character.localCharacter;
			if (!((Object)(object)val == (Object)null) && !val.isBot && !val.isZombie && !CharacterAlreadyHasShootZombiesWeapon(val) && !TryGiveItemTo(val) && (!TryResolveBaseWeaponItem(out var item) || !TrySpawnWeaponViaCharacterItems(val, item)))
			{
				Log.LogWarning((object)("[ShootZombies] Hotkey weapon grant failed for " + val.characterName));
			}
		}

		private void SpawnCompassAtPlayer()
		{
		}

		private void UpdateZombieSpeed(bool forceRefresh = false)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			float zombieMoveSpeedMultiplierRuntime = GetZombieMoveSpeedMultiplierRuntime();
			bool flag = Mathf.Approximately(zombieMoveSpeedMultiplierRuntime, 1f);
			if (!HasGameplayAuthority() || !IsGameplayScene(SceneManager.GetActiveScene()) || (flag && _zombieBaseSpeeds.Count == 0 && !_pendingZombieSpeedRefresh && !forceRefresh) || (!forceRefresh && !_pendingZombieSpeedRefresh && Time.time - _lastZombieSpeedUpdateTime < 1.5f))
			{
				return;
			}
			_lastZombieSpeedUpdateTime = Time.time;
			_pendingZombieSpeedRefresh = false;
			Character[] array = Object.FindObjectsByType<Character>((FindObjectsSortMode)0);
			List<Character> list = new List<Character>();
			foreach (KeyValuePair<Character, float> zombieBaseSpeed in _zombieBaseSpeeds)
			{
				if ((Object)(object)zombieBaseSpeed.Key == (Object)null)
				{
					list.Add(zombieBaseSpeed.Key);
				}
			}
			foreach (Character item in list)
			{
				_zombieBaseSpeeds.Remove(item);
			}
			Character[] array2 = array;
			foreach (Character val in array2)
			{
				if ((Object)(object)val == (Object)null || (!val.isZombie && !val.isBot) || !TryGetZombieSpeedReflectionCache(val, out var cache))
				{
					continue;
				}
				object value = cache.AgentField.GetValue(val);
				if (value == null || !TryGetZombieSpeedProperty(cache, value, out var property))
				{
					continue;
				}
				float value2 = 3.5f;
				if (!_zombieBaseSpeeds.TryGetValue(val, out value2))
				{
					if (cache.BaseSpeedField != null)
					{
						value2 = (float)cache.BaseSpeedField.GetValue(val);
					}
					_zombieBaseSpeeds[val] = value2;
				}
				property.SetValue(value, flag ? value2 : (value2 * zombieMoveSpeedMultiplierRuntime));
				if (flag)
				{
					_zombieBaseSpeeds.Remove(val);
				}
			}
		}

		private static bool TryGetZombieSpeedReflectionCache(Character zombie, out ZombieSpeedReflectionCache cache)
		{
			cache = null;
			if ((Object)(object)zombie == (Object)null)
			{
				return false;
			}
			Type type = ((object)zombie).GetType();
			if (!_zombieSpeedReflectionCache.TryGetValue(type, out cache))
			{
				cache = new ZombieSpeedReflectionCache
				{
					AgentField = (type.GetField("agent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? type.GetField("_agent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? type.GetField("navMeshAgent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)),
					BaseSpeedField = (type.GetField("baseSpeed", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? type.GetField("_baseSpeed", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
				};
				_zombieSpeedReflectionCache[type] = cache;
			}
			if (cache != null)
			{
				return cache.AgentField != null;
			}
			return false;
		}

		private static bool TryGetZombieSpeedProperty(ZombieSpeedReflectionCache cache, object agent, out PropertyInfo property)
		{
			property = null;
			if (cache == null || agent == null)
			{
				return false;
			}
			Type type = agent.GetType();
			if (cache.SpeedProperty == null || cache.AgentType != type)
			{
				cache.AgentType = type;
				cache.SpeedProperty = type.GetProperty("speed");
			}
			property = cache.SpeedProperty;
			return property != null;
		}

		private void UpdateDartEffectColorsOnce()
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time - _lastMaterialUpdateTime < 5f)
			{
				return;
			}
			_lastMaterialUpdateTime = Time.time;
			try
			{
				Renderer[] array = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
				foreach (Renderer val in array)
				{
					if ((Object)(object)val == (Object)null || (Object)(object)val.sharedMaterial == (Object)null)
					{
						continue;
					}
					string name = ((Object)((Component)val).gameObject).name;
					if ((name.Contains("Dart") || name.Contains("Trail") || name.Contains("Projectile")) && !name.Contains("HealingDart") && !name.Contains("Hand") && !name.Contains("Blowgun"))
					{
						Material sharedMaterial = val.sharedMaterial;
						if (!_processedMaterials.Contains(sharedMaterial) && sharedMaterial.HasProperty("_Color") && sharedMaterial.GetColor("_Color") != Color.black)
						{
							Material val2 = new Material(sharedMaterial);
							val2.SetColor("_Color", Color.black);
							val.sharedMaterial = val2;
							_processedMaterials.Add(val2);
						}
					}
				}
			}
			catch
			{
			}
		}

		private void ReplaceBlowgunInstanceSound()
		{
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_localCharacter != (Object)null)
				{
					FieldInfo field = ((object)_localCharacter).GetType().GetField("poofSFX", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null && field.GetValue(_localCharacter) is Array array)
					{
						foreach (object item in array)
						{
							if (item == null)
							{
								continue;
							}
							Type type = item.GetType();
							FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							foreach (FieldInfo fieldInfo in fields)
							{
								if (fieldInfo.FieldType == typeof(AudioClip[]))
								{
									if (fieldInfo.GetValue(item) is AudioClip[] array2 && (Object)(object)_gunshotSound != (Object)null)
									{
										for (int j = 0; j < array2.Length; j++)
										{
											array2[j] = _gunshotSound;
										}
									}
								}
								else if (fieldInfo.FieldType == typeof(AudioClip))
								{
									object value = fieldInfo.GetValue(item);
									_ = (AudioClip)((value is AudioClip) ? value : null);
									if ((Object)(object)_gunshotSound != (Object)null)
									{
										fieldInfo.SetValue(item, _gunshotSound);
									}
								}
							}
							PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							foreach (PropertyInfo propertyInfo in properties)
							{
								if (!(propertyInfo.PropertyType == typeof(AudioClip)))
								{
									continue;
								}
								try
								{
									object value2 = propertyInfo.GetValue(item);
									_ = (AudioClip)((value2 is AudioClip) ? value2 : null);
									if ((Object)(object)_gunshotSound != (Object)null && propertyInfo.CanWrite)
									{
										propertyInfo.SetValue(item, _gunshotSound);
									}
								}
								catch
								{
								}
							}
						}
					}
				}
				Item[] array3 = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
				foreach (Item val in array3)
				{
					string name = val.GetName();
					if (!ItemPatch.IsBlowgunLike(val, name))
					{
						continue;
					}
					AudioSource[] componentsInChildren = ((Component)val).GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val2 in componentsInChildren)
					{
						if ((Object)(object)val2.clip != (Object)null && (Object)(object)_gunshotSound != (Object)null)
						{
							val2.clip = _gunshotSound;
						}
					}
					Type type2 = typeof(Item).Assembly.GetType("SFX_Instance");
					if (!(type2 != null))
					{
						continue;
					}
					Component[] componentsInChildren2 = ((Component)val).GetComponentsInChildren(type2, true);
					foreach (Component val3 in componentsInChildren2)
					{
						FieldInfo[] fields = ((object)val3).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						foreach (FieldInfo fieldInfo2 in fields)
						{
							if (fieldInfo2.FieldType == typeof(AudioClip))
							{
								object value3 = fieldInfo2.GetValue(val3);
								_ = (AudioClip)((value3 is AudioClip) ? value3 : null);
								if ((Object)(object)_gunshotSound != (Object)null)
								{
									fieldInfo2.SetValue(val3, _gunshotSound);
								}
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] ReplaceBlowgunInstanceSound error: " + ex.Message));
			}
		}

		private bool IsHoldingBlowgun()
		{
			try
			{
				return (Object)(object)GetHeldBlowgunItem() != (Object)null;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] IsHoldingBlowgun error: " + ex.Message));
			}
			return false;
		}

		private static bool CanProcessLocalWeaponFireInput(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			if (GUIManager.InPauseMenu)
			{
				return false;
			}
			try
			{
				if (!_characterCanDoInputMethodInitialized)
				{
					_characterCanDoInputMethod = typeof(Character).GetMethod("CanDoInput", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					_characterCanDoInputMethodInitialized = true;
				}
				if (_characterCanDoInputMethod != null)
				{
					object obj = _characterCanDoInputMethod.Invoke(character, null);
					if (obj is bool)
					{
						return (bool)obj;
					}
				}
			}
			catch
			{
			}
			return true;
		}

		private void TryFire()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0091: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			if (!IsWeaponFeatureEnabled() || !IsHoldingBlowgun() || !CanProcessLocalWeaponFireInput(_localCharacter))
			{
				return;
			}
			_lastFireTime = Time.time;
			Item heldBlowgunItem = GetHeldBlowgunItem();
			if ((Object)(object)heldBlowgunItem != (Object)null)
			{
				FieldInfo field = ((object)heldBlowgunItem).GetType().GetField("<castProgress>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					field.SetValue(heldBlowgunItem, 0f);
				}
			}
			Vector3 val2;
			Vector3 val3;
			if ((Object)(object)Camera.main != (Object)null)
			{
				Ray val = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0f));
				val2 = ((Ray)(ref val)).origin + ((Ray)(ref val)).direction * 0.08f;
				val3 = ((Ray)(ref val)).direction;
			}
			else
			{
				val2 = ((Component)_localCharacter.refs.view).transform.position;
				val3 = ((Component)_localCharacter.refs.view).transform.forward;
			}
			UpdateLocalWeaponMuzzle();
			Transform val4 = ResolveCurrentWeaponMuzzle(heldBlowgunItem);
			Vector3 val5 = (((Object)(object)val4 != (Object)null) ? val4.position : GetWeaponPosition());
			if (val5 == Vector3.zero)
			{
				val5 = val2;
			}
			Vector3 val6 = (((Object)(object)val4 != (Object)null) ? val4.forward : val3);
			RaycastHit hit = default(RaycastHit);
			Character hitCharacter = null;
			bool flag = TryGetAimHit(val2, val2, val3, heldBlowgunItem, out hit, out hitCharacter);
			if (flag)
			{
				Vector3 val7 = ((RaycastHit)(ref hit)).point - val5;
				if (((Vector3)(ref val7)).sqrMagnitude > 1E-06f)
				{
					val6 = ((Vector3)(ref val7)).normalized;
				}
			}
			bool flag2 = flag && (Object)(object)((RaycastHit)(ref hit)).collider != (Object)null;
			Component val8 = TryGetRaycastDartComponent(heldBlowgunItem);
			if (flag && (Object)(object)hitCharacter == (Object)null && flag2)
			{
				SpawnDartImpactVisualOnly(heldBlowgunItem, ((RaycastHit)(ref hit)).point);
			}
			if (flag && flag2)
			{
				if ((Object)(object)hitCharacter == (Object)null)
				{
					hitCharacter = ResolveHitCharacter(((RaycastHit)(ref hit)).collider);
				}
				if ((Object)(object)hitCharacter != (Object)null && (Object)(object)hitCharacter != (Object)(object)_localCharacter)
				{
					if (hitCharacter.isZombie || hitCharacter.isBot)
					{
						if (!TriggerDartImpactEffect(heldBlowgunItem, hit, val5, hitCharacter))
						{
							if ((Object)(object)val8 != (Object)null)
							{
								HandleZombieDartImpactVisual(val8, ((RaycastHit)(ref hit)).point);
							}
							HitZombie(hitCharacter, val5);
						}
					}
					else
					{
						SpawnDartImpactVisualOnly(heldBlowgunItem, ((RaycastHit)(ref hit)).point);
						HandlePlayerShotStatus(hitCharacter);
					}
				}
			}
			Vector3 preferredSoundPosition = GetPreferredSoundPosition(val5, val6);
			if ((Object)(object)_localCharacter != (Object)null)
			{
				CreateMuzzleFlash(val5, val6);
				if ((Object)(object)_gunshotSound != (Object)null)
				{
					PlayGunshotSound(preferredSoundPosition);
				}
				else
				{
					PlayFallbackGunshotSound(preferredSoundPosition);
				}
			}
			TrySendRemoteShotEffects(val5, val6, preferredSoundPosition, flag && flag2, (flag && flag2) ? ((RaycastHit)(ref hit)).point : Vector3.zero);
		}

		private bool TryGetAimHit(Vector3 aimOrigin, Vector3 weaponOrigin, Vector3 direction, Item heldBlowgunItem, out RaycastHit hit, out Character hitCharacter)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			hit = default(RaycastHit);
			hitCharacter = null;
			try
			{
				Component raycastDartComponent = TryGetRaycastDartComponent(heldBlowgunItem);
				float configuredHitScanDistance = GetConfiguredHitScanDistance(raycastDartComponent);
				float num = Mathf.Max(GetConfiguredBulletSize(raycastDartComponent), 0.01f);
				List<RaycastHit> list = new List<RaycastHit>();
				RaycastHit[] array = Physics.RaycastAll(aimOrigin, direction, configuredHitScanDistance, -5, (QueryTriggerInteraction)1);
				if (array != null && array.Length != 0)
				{
					list.AddRange(array);
				}
				RaycastHit[] array2 = Physics.SphereCastAll(aimOrigin, num, direction, configuredHitScanDistance, -5, (QueryTriggerInteraction)1);
				if (array2 != null && array2.Length != 0)
				{
					list.AddRange(array2);
				}
				if (list.Count > 0)
				{
					list.Sort((RaycastHit a, RaycastHit b) => ((RaycastHit)(ref a)).distance.CompareTo(((RaycastHit)(ref b)).distance));
					foreach (RaycastHit item in list)
					{
						RaycastHit current = item;
						if (!((Object)(object)((RaycastHit)(ref current)).collider == (Object)null) && !IsSelfHit(((RaycastHit)(ref current)).collider))
						{
							hit = current;
							hitCharacter = ResolveHitCharacter(((RaycastHit)(ref current)).collider);
							return true;
						}
					}
				}
				RaycastHit val = default(RaycastHit);
				if (!Physics.Raycast(aimOrigin, direction, ref val, configuredHitScanDistance, LayerMask.op_Implicit(HelperFunctions.terrainMapMask), (QueryTriggerInteraction)1))
				{
					((RaycastHit)(ref val)).distance = configuredHitScanDistance;
					((RaycastHit)(ref val)).point = aimOrigin + direction * configuredHitScanDistance;
				}
				hit = val;
				return true;
			}
			catch
			{
				if (Physics.Raycast(aimOrigin, direction, ref hit, 100f) && !IsSelfHit(((RaycastHit)(ref hit)).collider))
				{
					hitCharacter = ResolveHitCharacter(((RaycastHit)(ref hit)).collider);
					return true;
				}
			}
			return false;
		}

		private static Character ResolveHitCharacter(Collider collider)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if (!((Object)collider != (Object)null))
			{
				return null;
			}
			return ((Component)collider).GetComponentInParent<Character>();
		}

		private bool IsSelfHit(Collider collider)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)collider == (Object)null || (Object)(object)_localCharacter == (Object)null)
			{
				return false;
			}
			Item componentInParent = ((Component)collider).GetComponentInParent<Item>();
			if ((Object)(object)componentInParent != (Object)null && ((Object)(object)componentInParent.holderCharacter == (Object)(object)_localCharacter || (Object)(object)componentInParent.trueHolderCharacter == (Object)(object)_localCharacter))
			{
				return true;
			}
			Character componentInParent2 = ((Component)collider).GetComponentInParent<Character>();
			if ((Object)(object)componentInParent2 != (Object)null && (Object)(object)componentInParent2 == (Object)(object)_localCharacter)
			{
				return true;
			}
			if ((Object)(object)componentInParent2 != (Object)null && (componentInParent2.isZombie || componentInParent2.isBot))
			{
				return false;
			}
			return ((Component)collider).transform.IsChildOf(((Component)_localCharacter).transform);
		}

		private static bool TriggerDartImpactEffect(Item heldBlowgunItem, RaycastHit hit, Vector3 origin, Character hitCharacter)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)heldBlowgunItem == (Object)null)
				{
					return false;
				}
				Component val = TryGetRaycastDartComponent(heldBlowgunItem);
				if ((Object)(object)val == (Object)null || _actionRaycastDartType == null)
				{
					return false;
				}
				if ((Object)(object)hitCharacter != (Object)null && (hitCharacter.isZombie || hitCharacter.isBot))
				{
					HandleZombieDartImpactVisual(val, ((RaycastHit)(ref hit)).point);
					Instance?.HitZombie(hitCharacter, origin);
					return true;
				}
				TrySpawnDartVfxFromAction(val, ((RaycastHit)(ref hit)).point);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[ShootZombies] TriggerDartImpactEffect failed: " + ex.Message));
				}
			}
			return false;
		}

		private static void SpawnDartImpactVisualOnly(Item heldBlowgunItem, Vector3 endpoint)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Component val = TryGetRaycastDartComponent(heldBlowgunItem);
				if ((Object)(object)val != (Object)null)
				{
					TrySpawnDartVfxFromAction(val, endpoint);
				}
			}
			catch
			{
			}
		}

		private static Component TryGetRaycastDartComponent(Item heldBlowgunItem)
		{
			if ((Object)(object)heldBlowgunItem == (Object)null)
			{
				return null;
			}
			if (_actionRaycastDartType == null)
			{
				_actionRaycastDartType = typeof(Item).Assembly.GetType("Action_RaycastDart");
			}
			if (_actionRaycastDartType == null)
			{
				return null;
			}
			NormalizeRaycastDartComponents(heldBlowgunItem);
			NormalizeRaycastDartComponents(heldBlowgunItem.isSecretlyOtherItemPrefab);
			Component val = ((Component)heldBlowgunItem).GetComponentInChildren(_actionRaycastDartType, true);
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)heldBlowgunItem).GetComponent(_actionRaycastDartType);
			}
			return val;
		}

		private static void NormalizeRaycastDartComponents(Item heldBlowgunItem)
		{
			try
			{
				if ((Object)(object)heldBlowgunItem == (Object)null)
				{
					return;
				}
				if (_actionRaycastDartType == null)
				{
					_actionRaycastDartType = typeof(Item).Assembly.GetType("Action_RaycastDart");
				}
				if (_actionRaycastDartType == null)
				{
					return;
				}
				Component[] componentsInChildren = ((Component)heldBlowgunItem).GetComponentsInChildren(_actionRaycastDartType, true);
				if (componentsInChildren == null || componentsInChildren.Length <= 1)
				{
					return;
				}
				for (int i = 1; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
					}
				}
			}
			catch
			{
			}
		}

		private static void TrySpawnDartVfxFromAction(Component actionRaycastDart, Vector3 endpoint)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)actionRaycastDart == (Object)null) && !(_actionRaycastDartType == null))
				{
					if (_dartVfxField == null)
					{
						_dartVfxField = _actionRaycastDartType.GetField("dartVFX", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					}
					object obj = _dartVfxField?.GetValue(actionRaycastDart);
					GameObject val = (GameObject)((obj is GameObject) ? obj : null);
					if ((Object)(object)val != (Object)null)
					{
						PlayDartImpactVfx(val, endpoint, Quaternion.identity);
					}
				}
			}
			catch
			{
			}
		}

		public static void HandleZombieDartImpactVisual(Component actionRaycastDart, Vector3 endpoint)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)actionRaycastDart == (Object)null))
				{
					if (_actionRaycastDartType == null)
					{
						_actionRaycastDartType = ((object)actionRaycastDart).GetType();
					}
					TrySpawnDartVfxFromAction(actionRaycastDart, endpoint);
					if ((Object)(object)GamefeelHandler.instance != (Object)null)
					{
						GamefeelHandler.instance.AddPerlinShakeProximity(endpoint, 5f, 0.2f, 15f, 10f);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[ShootZombies] HandleZombieDartImpactVisual failed: " + ex.Message));
				}
			}
		}

		private void CreateMuzzleFlash(Vector3 position, Vector3 direction)
		{
			//IL_0067: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_005b: 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)
			try
			{
				if (((Vector3)(ref direction)).sqrMagnitude < 1E-06f)
				{
					direction = (((Object)(object)_localWeaponMuzzle != (Object)null) ? _localWeaponMuzzle.forward : (((Object)(object)_localCharacter?.refs?.view != (Object)null) ? ((Component)_localCharacter.refs.view).transform.forward : Vector3.forward));
				}
				MuzzleFlashInstance muzzleFlashInstance = AcquireMuzzleFlashInstance();
				if (muzzleFlashInstance != null && !((Object)(object)muzzleFlashInstance.Root == (Object)null))
				{
					muzzleFlashInstance.Root.transform.position = position;
					muzzleFlashInstance.Root.transform.rotation = Quaternion.LookRotation(direction, Vector3.up);
					if ((Object)(object)muzzleFlashInstance.Light != (Object)null)
					{
						((Behaviour)muzzleFlashInstance.Light).enabled = true;
						muzzleFlashInstance.Light.intensity = 6f;
						muzzleFlashInstance.Light.range = 2f;
						muzzleFlashInstance.Light.color = new Color(1f, 0.72f, 0.35f);
					}
					muzzleFlashInstance.DisableAtTime = Time.time + 0.08f;
					if (!muzzleFlashInstance.Root.activeSelf)
					{
						muzzleFlashInstance.Root.SetActive(true);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static void UpdateMuzzleFlashPool()
		{
			if (_muzzleFlashPool.Count == 0)
			{
				return;
			}
			float time = Time.time;
			for (int num = _muzzleFlashPool.Count - 1; num >= 0; num--)
			{
				MuzzleFlashInstance muzzleFlashInstance = _muzzleFlashPool[num];
				if (muzzleFlashInstance == null || (Object)(object)muzzleFlashInstance.Root == (Object)null)
				{
					_muzzleFlashPool.RemoveAt(num);
					if (_nextMuzzleFlashPoolIndex > num)
					{
						_nextMuzzleFlashPoolIndex--;
					}
				}
				else if (muzzleFlashInstance.Root.activeSelf && time >= muzzleFlashInstance.DisableAtTime)
				{
					if ((Object)(object)muzzleFlashInstance.Light != (Object)null)
					{
						((Behaviour)muzzleFlashInstance.Light).enabled = false;
					}
					muzzleFlashInstance.Root.SetActive(false);
				}
			}
			if (_nextMuzzleFlashPoolIndex < 0)
			{
				_nextMuzzleFlashPoolIndex = 0;
			}
			if (_muzzleFlashPool.Count > 0)
			{
				_nextMuzzleFlashPoolIndex %= _muzzleFlashPool.Count;
			}
			else
			{
				_nextMuzzleFlashPoolIndex = 0;
			}
		}

		private static MuzzleFlashInstance AcquireMuzzleFlashInstance()
		{
			for (int i = 0; i < _muzzleFlashPool.Count; i++)
			{
				MuzzleFlashInstance muzzleFlashInstance = _muzzleFlashPool[i];
				if (muzzleFlashInstance != null && !((Object)(object)muzzleFlashInstance.Root == (Object)null) && !muzzleFlashInstance.Root.activeSelf)
				{
					return muzzleFlashInstance;
				}
			}
			if (_muzzleFlashPool.Count < 8)
			{
				MuzzleFlashInstance muzzleFlashInstance2 = CreateMuzzleFlashInstance();
				if (muzzleFlashInstance2 != null)
				{
					_muzzleFlashPool.Add(muzzleFlashInstance2);
				}
				return muzzleFlashInstance2;
			}
			if (_muzzleFlashPool.Count == 0)
			{
				return null;
			}
			int num = Mathf.Clamp(_nextMuzzleFlashPoolIndex, 0, _muzzleFlashPool.Count - 1);
			MuzzleFlashInstance result = _muzzleFlashPool[num];
			_nextMuzzleFlashPoolIndex = (num + 1) % _muzzleFlashPool.Count;
			return result;
		}

		private static MuzzleFlashInstance CreateMuzzleFlashInstance()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = new GameObject("MuzzleFlash");
				val.SetActive(false);
				Light val2 = val.AddComponent<Light>();
				val2.type = (LightType)2;
				val2.intensity = 6f;
				val2.range = 2f;
				val2.color = new Color(1f, 0.72f, 0.35f);
				((Behaviour)val2).enabled = false;
				return new MuzzleFlashInstance
				{
					Root = val,
					Light = val2,
					DisableAtTime = 0f
				};
			}
			catch
			{
				return null;
			}
		}

		private static void CleanupMuzzleFlashPool()
		{
			for (int i = 0; i < _muzzleFlashPool.Count; i++)
			{
				MuzzleFlashInstance muzzleFlashInstance = _muzzleFlashPool[i];
				if (muzzleFlashInstance != null && (Object)(object)muzzleFlashInstance.Root != (Object)null)
				{
					Object.Destroy((Object)(object)muzzleFlashInstance.Root);
				}
			}
			_muzzleFlashPool.Clear();
			_nextMuzzleFlashPoolIndex = 0;
		}

		private static void UpdateRemoteGunshotAudioPool()
		{
			if (_remoteGunshotAudioPool.Count == 0)
			{
				return;
			}
			float time = Time.time;
			for (int num = _remoteGunshotAudioPool.Count - 1; num >= 0; num--)
			{
				RemoteGunshotAudioInstance remoteGunshotAudioInstance = _remoteGunshotAudioPool[num];
				if (remoteGunshotAudioInstance == null || (Object)(object)remoteGunshotAudioInstance.Root == (Object)null || (Object)(object)remoteGunshotAudioInstance.AudioSource == (Object)null)
				{
					_remoteGunshotAudioPool.RemoveAt(num);
					if (_nextRemoteGunshotAudioPoolIndex > num)
					{
						_nextRemoteGunshotAudioPoolIndex--;
					}
				}
				else if (remoteGunshotAudioInstance.Root.activeSelf && time >= remoteGunshotAudioInstance.ReleaseAtTime)
				{
					remoteGunshotAudioInstance.AudioSource.Stop();
					remoteGunshotAudioInstance.AudioSource.clip = null;
					remoteGunshotAudioInstance.Root.SetActive(false);
				}
			}
			if (_nextRemoteGunshotAudioPoolIndex < 0)
			{
				_nextRemoteGunshotAudioPoolIndex = 0;
			}
			if (_remoteGunshotAudioPool.Count > 0)
			{
				_nextRemoteGunshotAudioPoolIndex %= _remoteGunshotAudioPool.Count;
			}
			else
			{
				_nextRemoteGunshotAudioPoolIndex = 0;
			}
		}

		private static RemoteGunshotAudioInstance AcquireRemoteGunshotAudioInstance()
		{
			for (int i = 0; i < _remoteGunshotAudioPool.Count; i++)
			{
				RemoteGunshotAudioInstance remoteGunshotAudioInstance = _remoteGunshotAudioPool[i];
				if (remoteGunshotAudioInstance != null && !((Object)(object)remoteGunshotAudioInstance.Root == (Object)null) && !((Object)(object)remoteGunshotAudioInstance.AudioSource == (Object)null) && !remoteGunshotAudioInstance.Root.activeSelf)
				{
					return remoteGunshotAudioInstance;
				}
			}
			if (_remoteGunshotAudioPool.Count < 12)
			{
				RemoteGunshotAudioInstance remoteGunshotAudioInstance2 = CreateRemoteGunshotAudioInstance();
				if (remoteGunshotAudioInstance2 != null)
				{
					_remoteGunshotAudioPool.Add(remoteGunshotAudioInstance2);
				}
				return remoteGunshotAudioInstance2;
			}
			if (_remoteGunshotAudioPool.Count == 0)
			{
				return null;
			}
			int num = Mathf.Clamp(_nextRemoteGunshotAudioPoolIndex, 0, _remoteGunshotAudioPool.Count - 1);
			RemoteGunshotAudioInstance result = _remoteGunshotAudioPool[num];
			_nextRemoteGunshotAudioPoolIndex = (num + 1) % _remoteGunshotAudioPool.Count;
			return result;
		}

		private static RemoteGunshotAudioInstance CreateRemoteGunshotAudioInstance()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			try
			{
				GameObject val = new GameObject("AK47_RemoteGunshotSound");
				val.SetActive(false);
				AudioSource val2 = val.AddComponent<AudioSource>();
				val2.spatialBlend = 1f;
				val2.rolloffMode = (AudioRolloffMode)1;
				val2.minDistance = 1.5f;
				val2.maxDistance = 100f;
				val2.dopplerLevel = 0f;
				val2.spread = 10f;
				val2.priority = 32;
				val2.playOnAwake = false;
				return new RemoteGunshotAudioInstance
				{
					Root = val,
					AudioSource = val2,
					ReleaseAtTime = 0f
				};
			}
			catch
			{
				return null;
			}
		}

		private static void CleanupRemoteGunshotAudioPool()
		{
			for (int i = 0; i < _remoteGunshotAudioPool.Count; i++)
			{
				RemoteGunshotAudioInstance remoteGunshotAudioInstance = _remoteGunshotAudioPool[i];
				if (remoteGunshotAudioInstance != null && (Object)(object)remoteGunshotAudioInstance.Root != (Object)null)
				{
					Object.Destroy((Object)(object)remoteGunshotAudioInstance.Root);
				}
			}
			_remoteGunshotAudioPool.Clear();
			_nextRemoteGunshotAudioPoolIndex = 0;
		}

		private static void PlayDartImpactVfx(GameObject prefab, Vector3 endpoint, Quaternion rotation)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab == (Object)null))
			{
				DartImpactVfxInstance dartImpactVfxInstance = AcquireDartImpactVfxInstance(prefab);
				if (dartImpactVfxInstance != null && !((Object)(object)dartImpactVfxInstance.Root == (Object)null))
				{
					RestartDartImpactVfxInstance(dartImpactVfxInstance, endpoint, rotation);
					dartImpactVfxInstance.ReleaseAtTime = Time.time + Mathf.Max(dartImpactVfxInstance.EstimatedLifetime, 2f);
				}
			}
		}

		private static void UpdateDartImpactVfxPool()
		{
			if (_dartImpactVfxPool.Count == 0)
			{
				return;
			}
			float time = Time.time;
			for (int num = _dartImpactVfxPool.Count - 1; num >= 0; num--)
			{
				DartImpactVfxInstance dartImpactVfxInstance = _dartImpactVfxPool[num];
				if (dartImpactVfxInstance == null || (Object)(object)dartImpactVfxInstance.Root == (Object)null)
				{
					_dartImpactVfxPool.RemoveAt(num);
					if (_nextDartImpactVfxPoolIndex > num)
					{
						_nextDartImpactVfxPoolIndex--;
					}
				}
				else if (dartImpactVfxInstance.Root.activeSelf && time >= dartImpactVfxInstance.ReleaseAtTime)
				{
					if (dartImpactVfxInstance.AudioSources != null)
					{
						AudioSource[] audioSources = dartImpactVfxInstance.AudioSources;
						foreach (AudioSource val in audioSources)
						{
							if (!((Object)(object)val == (Object)null))
							{
								val.Stop();
							}
						}
					}
					dartImpactVfxInstance.Root.SetActive(false);
				}
			}
			if (_nextDartImpactVfxPoolIndex < 0)
			{
				_nextDartImpactVfxPoolIndex = 0;
			}
			if (_dartImpactVfxPool.Count > 0)
			{
				_nextDartImpactVfxPoolIndex %= _dartImpactVfxPool.Count;
			}
			else
			{
				_nextDartImpactVfxPoolIndex = 0;
			}
		}

		private static DartImpactVfxInstance AcquireDartImpactVfxInstance(GameObject prefab)
		{
			int instanceID = ((Object)prefab).GetInstanceID();
			DartImpactVfxInstance dartImpactVfxInstance = null;
			int num = 0;
			for (int i = 0; i < _dartImpactVfxPool.Count; i++)
			{
				DartImpactVfxInstance dartImpactVfxInstance2 = _dartImpactVfxPool[i];
				if (dartImpactVfxInstance2 != null && !((Object)(object)dartImpactVfxInstance2.Root == (Object)null) && dartImpactVfxInstance2.PrefabId == instanceID)
				{
					num++;
					if (!dartImpactVfxInstance2.Root.activeSelf)
					{
						return dartImpactVfxInstance2;
					}
					if (dartImpactVfxInstance == null || dartImpactVfxInstance2.ReleaseAtTime < dartImpactVfxInstance.ReleaseAtTime)
					{
						dartImpactVfxInstance = dartImpactVfxInstance2;
					}
				}
			}
			if (num < 8)
			{
				DartImpactVfxInstance dartImpactVfxInstance3 = CreateDartImpactVfxInstance(prefab);
				if (dartImpactVfxInstance3 != null)
				{
					_dartImpactVfxPool.Add(dartImpactVfxInstance3);
				}
				return dartImpactVfxInstance3;
			}
			if (dartImpactVfxInstance != null)
			{
				return dartImpactVfxInstance;
			}
			if (_dartImpactVfxPool.Count == 0)
			{
				return null;
			}
			int num2 = Mathf.Clamp(_nextDartImpactVfxPoolIndex, 0, _dartImpactVfxPool.Count - 1);
			DartImpactVfxInstance result = _dartImpactVfxPool[num2];
			_nextDartImpactVfxPoolIndex = (num2 + 1) % _dartImpactVfxPool.Count;
			return result;
		}

		private static DartImpactVfxInstance CreateDartImpactVfxInstance(GameObject prefab)
		{
			try
			{
				GameObject val = Object.Instantiate<GameObject>(prefab);
				val.SetActive(false);
				return new DartImpactVfxInstance
				{
					Root = val,
					PrefabId = ((Object)prefab).GetInstanceID(),
					ReleaseAtTime = 0f,
					EstimatedLifetime = EstimateDartImpactVfxLifetime(val),
					AudioSources = val.GetComponentsInChildren<AudioSource>(true)
				};
			}
			catch
			{
				return null;
			}
		}

		private static float EstimateDartImpactVfxLifetime(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return 2f;
			}
			float num = 0f;
			AudioSource[] componentsInChildren = root.GetComponentsInChildren<AudioSource>(true);
			if (componentsInChildren != null)
			{
				AudioSource[] array = componentsInChildren;
				foreach (AudioSource val in array)
				{
					if (!((Object)(object)val == (Object)null) && (Object)(object)val.clip != (Object)null)
					{
						num = Mathf.Max(num, val.clip.length);
					}
				}
			}
			return Mathf.Max(num, 2f);
		}

		private static void RestartDartImpactVfxInstance(DartImpactVfxInstance instance, Vector3 endpoint, Quaternion rotation)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (instance == null || (Object)(object)instance.Root == (Object)null)
			{
				return;
			}
			instance.Root.SetActive(false);
			instance.Root.transform.SetPositionAndRotation(endpoint, rotation);
			AudioSource[] audioSources;
			if (instance.AudioSources != null)
			{
				audioSources = instance.AudioSources;
				foreach (AudioSource val in audioSources)
				{
					if (!((Object)(object)val == (Object)null))
					{
						val.Stop();
						val.time = 0f;
					}
				}
			}
			instance.Root.SetActive(true);
			if (instance.AudioSources == null)
			{
				return;
			}
			audioSources = instance.AudioSources;
			foreach (AudioSource val2 in audioSources)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					val2.Play();
				}
			}
		}

		private static void CleanupDartImpactVfxPool()
		{
			for (int i = 0; i < _dartImpactVfxPool.Count; i++)
			{
				DartImpactVfxInstance dartImpactVfxInstance = _dartImpactVfxPool[i];
				if (dartImpactVfxInstance != null && (Object)(object)dartImpactVfxInstance.Root != (Object)null)
				{
					Object.Destroy((Object)(object)dartImpactVfxInstance.Root);
				}
			}
			_dartImpactVfxPool.Clear();
			_nextDartImpactVfxPoolIndex = 0;
		}

		private static Material GetMuzzleFlashMaterial()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_muzzleFlashMaterial != (Object)null)
			{
				return _muzzleFlashMaterial;
			}
			_muzzleFlashMaterial = new Material(Shader.Find("Universal Render Pipeline/Particles/Unlit") ?? Shader.Find("Particles/Standard Unlit") ?? Shader.Find("Legacy Shaders/Particles/Additive") ?? Shader.Find("Standard"));
			((Object)_muzzleFlashMaterial).name = "ShootZombies_MuzzleFlash";
			if (_muzzleFlashMaterial.HasProperty("_Surface"))
			{
				_muzzleFlashMaterial.SetFloat("_Surface", 1f);
			}
			if (_muzzleFlashMaterial.HasProperty("_Blend"))
			{
				_muzzleFlashMaterial.SetFloat("_Blend", 1f);
			}
			if (_muzzleFlashMaterial.HasProperty("_BaseColor"))
			{
				_muzzleFlashMaterial.SetColor("_BaseColor", new Color(1f, 0.75f, 0.3f, 1f));
			}
			if (_muzzleFlashMaterial.HasProperty("_Color"))
			{
				_muzzleFlashMaterial.SetColor("_Color", new Color(1f, 0.75f, 0.3f, 1f));
			}
			return _muzzleFlashMaterial;
		}

		private Item GetHeldBlowgunItem()
		{
			if ((Object)(object)_localCharacter == (Object)null)
			{
				_cachedHeldBlowgunItem = null;
				return null;
			}
			CharacterData data = _localCharacter.data;
			Item val = (((Object)(object)data != (Object)null) ? data.currentItem : null);
			if (IsHeldBlowgunOwnedByCharacter(val, _localCharacter))
			{
				_cachedHeldBlowgunItem = val;
				return val;
			}
			Item cachedHeldBlowgunItem = _cachedHeldBlowgunItem;
			if (IsHeldBlowgunOwnedByCharacter(cachedHeldBlowgunItem, _localCharacter))
			{
				return cachedHeldBlowgunItem;
			}
			if (Time.time - _lastHeldBlowgunSearchTime < 0.15f)
			{
				return null;
			}
			_lastHeldBlowgunSearchTime = Time.time;
			Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
			foreach (Item val2 in array)
			{
				if (IsHeldBlowgunOwnedByCharacter(val2, _localCharacter))
				{
					_cachedHeldBlowgunItem = val2;
					return val2;
				}
			}
			_cachedHeldBlowgunItem = null;
			return null;
		}

		private static bool IsHeldBlowgunOwnedByCharacter(Item item, Character character)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null || (Object)(object)character == (Object)null || !ItemPatch.IsBlowgunLike(item) || (int)item.itemState != 1)
			{
				return false;
			}
			if ((Object)(object)item.holderCharacter == (Object)(object)character)
			{
				return true;
			}
			return (Object)(object)item.trueHolderCharacter == (Object)(object)character;
		}

		private void SyncBlowgunChargeState(Item heldBlowgunItem)
		{
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			if ((Object)(object)heldBlowgunItem == (Object)null)
			{
				_lastChargeSyncItemId = int.MinValue;
				return;
			}
			int instanceID = ((Object)heldBlowgunItem).GetInstanceID();
			if (_lastChargeSyncItemId == instanceID && Time.time - _lastChargeSyncTime < 0.2f)
			{
				return;
			}
			_lastChargeSyncItemId = instanceID;
			_lastChargeSyncTime = Time.time;
			try
			{
				float value = Mathf.Max(FireInterval?.Value ?? 0.4f, 0.1f);
				float num = 0f;
				if (_castProgressField == null)
				{
					_castProgressField = ((object)heldBlowgunItem).GetType().GetField("<castProgress>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				_castProgressField?.SetValue(heldBlowgunItem, num);
				TrySetFloatFieldOrProperty(heldBlowgunItem, "castProgress", num);
				TrySetFloatFieldOrProperty(heldBlowgunItem, "chargeProgress", num);
				TrySetBoolFieldOrProperty(heldBlowgunItem, "showChargeBar", value2: false);
				TrySetBoolFieldOrProperty(heldBlowgunItem, "showCastBar", value2: false);
				TrySetBoolFieldOrProperty(heldBlowgunItem, "needsCharge", value2: false);
				TrySetBoolFieldOrProperty(heldBlowgunItem, "requiresCharge", value2: false);
				EnsureInfiniteUses(heldBlowgunItem);
				DisableConsumableActions(heldBlowgunItem);
				NormalizeRaycastDartComponents(heldBlowgunItem);
				NormalizeRaycastDartComponents(heldBlowgunItem.isSecretlyOtherItemPrefab);
				if (_actionRaycastDartType == null)
				{
					_actionRaycastDartType = typeof(Item).Assembly.GetType("Action_RaycastDart");
				}
				if (_actionRaycastDartType == null)
				{
					return;
				}
				Component val = ((Component)heldBlowgunItem).GetComponentInChildren(_actionRaycastDartType, true);
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)heldBlowgunItem).GetComponent(_actionRaycastDartType);
				}
				if (!((Object)(object)val == (Object)null))
				{
					Behaviour val2 = (Behaviour)((val is Behaviour) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.enabled = false;
					}
					TrySetFloatFieldOrProperty(val, "castProgress", num);
					TrySetFloatFieldOrProperty(val, "chargeProgress", num);
					TrySetFloatFieldOrProperty(val, "castTime", value);
					TrySetFloatFieldOrProperty(val, "castDuration", value);
					TrySetFloatFieldOrProperty(val, "chargeTime", value);
					TrySetFloatFieldOrProperty(val, "chargeDuration", value);
					TrySetBoolFieldOrProperty(val, "showChargeBar", value2: false);
					TrySetBoolFieldOrProperty(val, "showCastBar", value2: false);
					TrySetBoolFieldOrProperty(val, "needsCharge", value2: false);
					TrySetBoolFieldOrProperty(val, "requiresCharge", value2: false);
				}
			}
			catch
			{
			}
		}

		private static void TrySetFloatFieldOrProperty(object target, string memberName, float value)
		{
			if (target == null || string.IsNullOrEmpty(memberName))
			{
				return;
			}
			ReflectionMemberCacheEntry cachedMemberAccessor = GetCachedMemberAccessor(target.GetType(), memberName, typeof(float));
			FieldInfo field = cachedMemberAccessor.Field;
			if (field != null)
			{
				field.SetValue(target, value);
				return;
			}
			PropertyInfo property = cachedMemberAccessor.Property;
			if (property != null && property.CanWrite)
			{
				property.SetValue(target, value);
			}
		}

		private static bool TryFireViaOriginalDartAction(Item heldBlowgunItem, Vector3 spawnPosition, Vector3 fallbackDirection, out Vector3 shotDirection)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Expected O, but got Unknown
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: 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)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			shotDirection = fallbackDirection;
			GameObject val = null;
			Transform val2 = null;
			Transform val3 = null;
			Component val4 = null;
			float? num = null;
			try
			{
				val4 = TryGetRaycastDartComponent(heldBlowgunItem);
				if ((Object)(object)val4 == (Object)null || _actionRaycastDartType == null)
				{
					return false;
				}
				if (_actionRunActionMethod == null)
				{
					_actionRunActionMethod = _actionRaycastDartType.GetMethod("RunAction", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (_actionRunActionMethod == null)
				{
					return false;
				}
				if (_actionRaycastDartSpawnTransformField == null)
				{
					_actionRaycastDartSpawnTransformField = _actionRaycastDartType.GetField("spawnTransform", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				val2 = (Transform)((_actionRaycastDartSpawnTransformField != null) ? /*isinst with value type is only supported in some contexts*/: null);
				val3 = ResolveDartSpawnTransform(heldBlowgunItem);
				if ((Object)(object)val3 != (Object)null && _actionRaycastDartSpawnTransformField != null)
				{
					Vector3 val5 = ((((Vector3)(ref fallbackDirection)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref fallbackDirection)).normalized : val3.forward);
					Vector3 val6 = spawnPosition;
					if (val6 == Vector3.zero)
					{
						val6 = val3.position;
					}
					val = new GameObject("AK47_RuntimeSpawn");
					((Object)val).hideFlags = (HideFlags)61;
					val.transform.position = val6;
					val.transform.rotation = Quaternion.LookRotation(val5, ResolveShotUpVector(val3, val5));
					_actionRaycastDartSpawnTransformField.SetValue(val4, val.transform);
					shotDirection = val.transform.forward;
				}
				else if ((Object)(object)val2 != (Object)null)
				{
					shotDirection = val2.forward;
				}
				TrySetFloatFieldOrProperty(val4, "maxDistance", Mathf.Max(100f, 1f));
				num = TryGetOptionalFloatFieldOrProperty(val4, "dartCollisionSize");
				TrySetFloatFieldOrProperty(val4, "dartCollisionSize", GetConfiguredBulletSize(val4));
				_actionRunActionMethod.Invoke(val4, null);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[ShootZombies] TryFireViaOriginalDartAction failed: " + ex.Message));
				}
			}
			finally
			{
				if ((Object)val4 != (Object)null && num.HasValue)
				{
					TrySetFloatFieldOrProperty(val4, "dartCollisionSize", num.Value);
				}
				if (_actionRaycastDartSpawnTransformField != null && (Object)val4 != (Object)null)
				{
					_actionRaycastDartSpawnTransformField.SetValue(val4, val2);
				}
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)val);
				}
			}
			return false;
		}

		private static Vector3 ResolveShotUpVector(Transform referenceTransform, Vector3 forward)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((((Vector3)(ref forward)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref forward)).normalized : Vector3.forward);
			Vector3 val2 = (((Object)(object)referenceTransform != (Object)null) ? referenceTransform.up : Vector3.up);
			if (Mathf.Abs(Vector3.Dot(val, ((Vector3)(ref val2)).normalized)) > 0.98f)
			{
				val2 = (((Object)(object)referenceTransform != (Object)null) ? referenceTransform.right : Vector3.right);
			}
			if (((Vector3)(ref val2)).sqrMagnitude <= 1E-06f)
			{
				val2 = Vector3.up;
			}
			return ((Vector3)(ref val2)).normalized;
		}

		private static Transform ResolveDartSpawnTransform(Item heldBlowgunItem)
		{
			Transform val = ResolveCurrentWeaponMuzzle(heldBlowgunItem);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (!((Object)(object)heldBlowgunItem != (Object)null))
			{
				return null;
			}
			return ((Component)heldBlowgunItem).transform;
		}

		private static Transform ResolveCurrentWeaponMuzzle(Item heldBlowgunItem)
		{
			if ((Object)(object)_localWeaponMuzzle != (Object)null)
			{
				return _localWeaponMuzzle;
			}
			Transform val = ItemPatch.TryGetMuzzleMarker(heldBlowgunItem);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return null;
		}

		private static float TryGetFloatFieldOrProperty(object target, string memberName, float fallbackValue)
		{
			if (target == null || string.IsNullOrEmpty(memberName))
			{
				return fallbackValue;
			}
			Type type = target.GetType();
			FieldInfo field = type.GetField(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && field.FieldType == typeof(float))
			{
				return (float)field.GetValue(target);
			}
			PropertyInfo property = type.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanRead && property.PropertyType == typeof(float))
			{
				return (float)property.GetValue(target);
			}
			return fallbackValue;
		}

		private static float? TryGetOptionalFloatFieldOrProperty(object target, string memberName)
		{
			if (target == null || string.IsNullOrEmpty(memberName))
			{
				return null;
			}
			ReflectionMemberCacheEntry cachedMemberAccessor = GetCachedMemberAccessor(target.GetType(), memberName, typeof(float));
			FieldInfo field = cachedMemberAccessor.Field;
			if (field != null)
			{
				return (float)field.GetValue(target);
			}
			PropertyInfo property = cachedMemberAccessor.Property;
			if (property != null && property.CanRead)
			{
				return (float)property.GetValue(target);
			}
			return null;
		}

		private static float GetConfiguredHitScanDistance(object raycastDartComponent = null)
		{
			return Mathf.Max(TryGetFloatFieldOrProperty(raycastDartComponent, "maxDistance", 100f), 0.25f);
		}

		private static float GetConfiguredBulletSize(object raycastDartComponent = null)
		{
			return Mathf.Max(0.1f, 0.01f);
		}

		private static void TrySetBoolFieldOrProperty(object target, string memberName, bool value2)
		{
			if (target == null || string.IsNullOrEmpty(memberName))
			{
				return;
			}
			ReflectionMemberCacheEntry cachedMemberAccessor = GetCachedMemberAccessor(target.GetType(), memberName, typeof(bool));
			FieldInfo field = cachedMemberAccessor.Field;
			if (field != null)
			{
				field.SetValue(target, value2);
				return;
			}
			PropertyInfo property = cachedMemberAccessor.Property;
			if (property != null && property.CanWrite)
			{
				property.SetValue(target, value2);
			}
		}

		private static ReflectionMemberCacheEntry GetCachedMemberAccessor(Type type, string memberName, Type valueType)
		{
			if (type == null)
			{
				return new ReflectionMemberCacheEntry();
			}
			MemberAccessorCacheKey key = new MemberAccessorCacheKey(type, memberName, valueType);
			if (_reflectionMemberCache.TryGetValue(key, out var value))
			{
				return value;
			}
			value = new ReflectionMemberCacheEntry
			{
				Field = type.GetField(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic),
				Property = type.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			};
			if (value.Field != null && value.Field.FieldType != valueType)
			{
				value.Field = null;
			}
			if (value.Property != null && value.Property.PropertyType != valueType)
			{
				value.Property = null;
			}
			_reflectionMemberCache[key] = value;
			return value;
		}

		private static void EnsureInfiniteUses(Item item)
		{
			if ((Object)(object)item == (Object)null || Time.time - _lastUseSyncTime < 0.1f)
			{
				return;
			}
			_lastUseSyncTime = Time.time;
			try
			{
				if (_itemGetDataGenericMethod == null)
				{
					_itemGetDataGenericMethod = typeof(Item).GetMethods(BindingFlags.Instance | BindingFlags.Public).FirstOrDefault((MethodInfo m) => m.Name == "GetData" && m.IsGenericMethod);
				}
				if (_optionableIntItemDataType == null)
				{
					_optionableIntItemDataType = typeof(Item).Assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "OptionableIntItemData");
				}
				if (_itemGetDataGenericMethod == null || _optionableIntItemDataType == null)
				{
					return;
				}
				if (_usesDataKey == null)
				{
					_usesDataKey = typeof(Item).GetField("UsesKey", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
					if (_usesDataKey == null)
					{
						_usesDataKey = (object)(DataEntryKey)2;
					}
				}
				MethodInfo methodInfo = _itemGetDataGenericMethod.MakeGenericMethod(_optionableIntItemDataType);
				ParameterInfo[] parameters = methodInfo.GetParameters();
				object[] array = new object[parameters.Length];
				for (int i = 0; i < parameters.Length; i++)
				{
					if (parameters[i].ParameterType == typeof(DataEntryKey))
					{
						array[i] = _usesDataKey;
					}
					else
					{
						array[i] = null;
					}
				}
				object obj = methodInfo.Invoke(item, array);
				if (obj != null)
				{
					FieldInfo field = obj.GetType().GetField("HasData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						field.SetValue(obj, true);
					}
					if (_optionableIntValueField == null)
					{
						_optionableIntValueField = obj.GetType().GetField("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					}
					if (_optionableIntValueField != null)
					{
						_optionableIntValueField.SetValue(obj, 9999);
					}
				}
			}
			catch
			{
			}
		}

		private static void DisableConsumableActions(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			try
			{
				if (_actionConsumeType == null)
				{
					_actionConsumeType = typeof(Item).Assembly.GetType("Action_Consume");
				}
				if (_actionConsumeAndSpawnType == null)
				{
					_actionConsumeAndSpawnType = typeof(Item).Assembly.GetType("Action_ConsumeAndSpawn");
				}
				DestroyActionsByType(item, _actionConsumeType);
				DestroyActionsByType(item, _actionConsumeAndSpawnType);
			}
			catch
			{
			}
		}

		private static void DestroyActionsByType(Item item, Type actionType)
		{
			if ((Object)(object)item == (Object)null || actionType == null)
			{
				return;
			}
			Component[] componentsInChildren = ((Component)item).GetComponentsInChildren(actionType, true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private float GetBlowgunCastProgress()
		{
			if ((Object)(object)_localCharacter == (Object)null)
			{
				return 0f;
			}
			Item heldBlowgunItem = GetHeldBlowgunItem();
			if ((Object)(object)heldBlowgunItem != (Object)null)
			{
				FieldInfo field = ((object)heldBlowgunItem).GetType().GetField("<castProgress>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return (float)field.GetValue(heldBlowgunItem);
				}
			}
			return 0f;
		}

		private Vector3 GetWeaponPosition()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_004e: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localCharacter == (Object)null)
			{
				return Vector3.zero;
			}
			Item heldBlowgunItem = GetHeldBlowgunItem();
			Transform val = ResolveCurrentWeaponMuzzle(heldBlowgunItem);
			if ((Object)(object)val != (Object)null)
			{
				return val.position;
			}
			if ((Object)(object)heldBlowgunItem != (Object)null)
			{
				if ((Object)(object)heldBlowgunItem.mainRenderer != (Object)null)
				{
					Bounds bounds = heldBlowgunItem.mainRenderer.bounds;
					return ((Bounds)(ref bounds)).center + ((Component)heldBlowgunItem.mainRenderer).transform.forward * Mathf.Max(((Bounds)(ref bounds)).extents.z, 0.05f);
				}
				return ((Component)heldBlowgunItem).transform.position;
			}
			if ((Object)(object)_localCharacter.refs?.view != (Object)null)
			{
				return ((Component)_localCharacter.refs.view).transform.position + ((Component)_localCharacter.refs.view).transform.forward * 0.45f;
			}
			return ((Component)_localCharacter).transform.position + ((Component)_localCharacter).transform.forward * 0.45f;
		}

		private Vector3 GetPreferredSoundPosition(Vector3 weaponPosition, Vector3 aimForward)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_00a6: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			Transform val = null;
			if ((Object)(object)Camera.main != (Object)null)
			{
				val = ((Component)Camera.main).transform;
			}
			else if ((Object)(object)_localCharacter?.refs?.view != (Object)null)
			{
				val = ((Component)_localCharacter.refs.view).transform;
			}
			if ((Object)(object)val == (Object)null)
			{
				return weaponPosition;
			}
			Vector3 val2 = weaponPosition - val.position;
			if (((Vector3)(ref val2)).sqrMagnitude > 1E-06f && Vector3.Dot(val.forward, ((Vector3)(ref val2)).normalized) >= 0.12f)
			{
				return weaponPosition;
			}
			Vector3 val3 = ((((Vector3)(ref aimForward)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref aimForward)).normalized : val.forward);
			return val.position + val3 * 0.55f;
		}

		private bool TrySendRemoteShotEffects(Vector3 muzzlePosition, Vector3 muzzleDirection, Vector3 soundPosition, bool hasImpact, Vector3 impactPosition)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			Character val = Character.localCharacter ?? _localCharacter;
			if (!HasOnlineRoomSession() || PhotonNetwork.OfflineMode || (Object)(object)val == (Object)null)
			{
				return false;
			}
			PhotonView val2 = val.refs?.view;
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)val).GetComponent<PhotonView>() ?? ((Component)val).GetComponentInParent<PhotonView>();
			}
			if (soundPosition == Vector3.zero)
			{
				soundPosition = muzzlePosition;
			}
			object[] array = new object[7]
			{
				((Object)(object)val2 != (Object)null) ? val2.ViewID : 0,
				muzzlePosition,
				muzzleDirection,
				soundPosition,
				hasImpact,
				impactPosition,
				NormalizeAkSoundSelection(AkSoundSelection?.Value)
			};
			RaiseEventOptions val3 = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)0
			};
			return PhotonNetwork.RaiseEvent((byte)181, (object)array, val3, SendOptions.SendReliable);
		}

		public void HitZombie(Character zombie, Vector3? origin = null)
		{
			if (!((Object)(object)zombie == (Object)null) && !TrySendZombieHitEvent(zombie, origin))
			{
				ApplyZombieHitLocal(zombie, origin);
			}
		}

		private static bool TrySendZombieHitEvent(Character zombie, Vector3? origin)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldRelayZombieHitToHost())
			{
				return false;
			}
			PhotonView val = ResolveZombiePhotonView(zombie);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			bool flag = origin.HasValue && IsFiniteVector(origin.Value);
			object[] array = new object[3]
			{
				val.ViewID,
				flag,
				flag ? ((object)origin.Value) : ((object)Vector3.zero)
			};
			RaiseEventOptions val2 = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)1
			};
			return PhotonNetwork.RaiseEvent((byte)178, (object)array, val2, SendOptions.SendReliable);
		}

		private static PhotonView ResolveZombiePhotonView(Character zombie)
		{
			if ((Object)(object)zombie == (Object)null)
			{
				return null;
			}
			MushroomZombie val = ((Component)zombie).GetComponent<MushroomZombie>() ?? ((Component)zombie).GetComponentInParent<MushroomZombie>() ?? ((Component)zombie).GetComponentInChildren<MushroomZombie>(true);
			GameObject val2 = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : ((Component)((Component)zombie).transform.root).gameObject);
			PhotonView obj = ((Component)zombie).GetComponent<PhotonView>();
			if (obj == null)
			{
				obj = ((Component)zombie).GetComponentInParent<PhotonView>();
				if (obj == null)
				{
					if (!((Object)(object)val2 != (Object)null))
					{
						return null;
					}
					obj = val2.GetComponent<PhotonView>();
				}
			}
			return obj;
		}

		private void HandlePlayerShotStatus(Character targetCharacter)
		{
			if (!((Object)(object)targetCharacter == (Object)null) && !targetCharacter.isZombie && !targetCharacter.isBot && !TrySendPlayerShotStatusEvent(targetCharacter))
			{
				ApplyPlayerShotStatusIfOwnedLocal(targetCharacter);
			}
		}

		private static bool TrySendPlayerShotStatusEvent(Character targetCharacter)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (!HasOnlineRoomSession() || PhotonNetwork.OfflineMode || (Object)(object)targetCharacter == (Object)null || targetCharacter.isZombie || targetCharacter.isBot)
			{
				return false;
			}
			PhotonView val = targetCharacter.refs?.view ?? ((Component)targetCharacter).GetComponent<PhotonView>() ?? ((Component)targetCharacter).GetComponentInParent<PhotonView>();
			if ((Object)(object)val == (Object)null || val.IsMine || val.OwnerActorNr <= 0)
			{
				return false;
			}
			object[] array = new object[1] { val.ViewID };
			RaiseEventOptions val2 = new RaiseEventOptions();
			val2.TargetActors = new int[1] { val.OwnerActorNr };
			RaiseEventOptions val3 = val2;
			return PhotonNetwork.RaiseEvent((byte)183, (object)array, val3, SendOptions.SendReliable);
		}

		private static void ApplyPlayerShotStatusIfOwnedLocal(Character targetCharacter)
		{
			if ((Object)(object)targetCharacter == (Object)null || targetCharacter.isZombie || targetCharacter.isBot)
			{
				return;
			}
			PhotonView val = targetCharacter.refs?.view ?? ((Component)targetCharacter).GetComponent<PhotonView>() ?? ((Component)targetCharacter).GetComponentInParent<PhotonView>();
			if ((Object)(object)val != (Object)null && !val.IsMine)
			{
				return;
			}
			CharacterAfflictions val2 = targetCharacter.refs?.afflictions;
			if (!((Object)(object)val2 == (Object)null))
			{
				if (val2.GetCurrentStatus((STATUSTYPE)10) > 0f)
				{
					float num = Mathf.Max(val2.GetStatusCap((STATUSTYPE)10) * 0.05f, 0.025f);
					val2.SubtractStatus((STATUSTYPE)10, num, false, false);
				}
				else
				{
					float num2 = Mathf.Max(val2.GetStatusCap((STATUSTYPE)2) * 0.025f, 0.025f);
					val2.AddStatus((STATUSTYPE)2, num2, false, true, true);
				}
			}
		}

		private void ApplyZombieHitLocal(Character zombie, Vector3? origin = null)
		{
			MushroomZombie val = ((Component)zombie).GetComponent<MushroomZombie>() ?? ((Component)zombie).GetComponentInParent<MushroomZombie>() ?? ((Component)zombie).GetComponentInChildren<MushroomZombie>(true);
			GameObject val2 = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : ((Component)((Component)zombie).transform.root).gameObject);
			if (!CanMutateZombie(((Component)zombie).GetComponent<PhotonView>() ?? ((Component)zombie).GetComponentInParent<PhotonView>() ?? (((Object)(object)val2 != (Object)null) ? val2.GetComponent<PhotonView>() : null)))
			{
				return;
			}
			if ((Object)(object)zombie != (Object)null && (Object)(object)((Component)zombie).gameObject != (Object)null)
			{
				((MonoBehaviour)this).StartCoroutine(ZombieHitEffect(zombie));
			}
			ApplyZombieKnockback(zombie, origin);
			float num = Mathf.Max(ZombieTimeReduction.Value, 0f);
			bool flag = false;
			bool expired = false;
			if ((Object)(object)val2 != (Object)null && num > 0f)
			{
				flag = ZombieSpawner.TryReduceZombieLifetime(val2, num, out expired);
				if (flag)
				{
					float health;
					float health2 = (expired ? 0f : (ZombieSpawner.TryGetZombieHealth01(val2, out health) ? health : 1f));
					ZombieHealthBar.SetHealth(val2, health2);
					BroadcastZombieHealth(zombie, health2);
				}
			}
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			FieldInfo field = ((object)val).GetType().GetField("survivalTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				field = ((object)val).GetType().GetField("lifetime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (field == null)
			{
				field = ((object)val).GetType().GetField("_survivalTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (field == null)
			{
				field = ((object)val).GetType().GetField("_lifetime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (field != null)
			{
				float num2 = Mathf.Max((float)field.GetValue(val) - num, 0f);
				field.SetValue(val, num2);
				if (!flag)
				{
					float health3 = Mathf.Clamp01(num2 / Mathf.Max(ZombieMaxLifetime.Value, 1f));
					ZombieHealthBar.SetHealth(zombie, health3);
					BroadcastZombieHealth(zombie, health3);
				}
				if (!flag && !(num2 > 0f))
				{
					ZombieSpawner.ExpireZombie(val2);
				}
			}
		}

		private static void BroadcastZombieHealth(Character zombie, float health01)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (HasOnlineRoomSession() && !PhotonNetwork.OfflineMode)
			{
				PhotonView val = ResolveZombiePhotonView(zombie);
				if (!((Object)(object)val == (Object)null))
				{
					object[] array = new object[2]
					{
						val.ViewID,
						Mathf.Clamp01(health01)
					};
					RaiseEventOptions val2 = new RaiseEventOptions
					{
						Receivers = (ReceiverGroup)0
					};
					PhotonNetwork.RaiseEvent((byte)184, (object)array, val2, SendOptions.SendUnreliable);
				}
			}
		}

		private static void ApplyZombieKnockback(Character zombie, Vector3? origin = null)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_0091: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)zombie == (Object)null)
			{
				return;
			}
			float zombieKnockbackForceRuntime = GetZombieKnockbackForceRuntime();
			if (zombieKnockbackForceRuntime <= 0f)
			{
				return;
			}
			try
			{
				Vector3 center = zombie.Center;
				Vector3 val = center;
				val = ((origin.HasValue && IsFiniteVector(origin.Value)) ? origin.Value : (((Object)(object)_localWeaponMuzzle != (Object)null) ? _localWeaponMuzzle.position : ((!((Object)(object)_localCharacter != (Object)null)) ? (center - ((Component)zombie).transform.forward * 0.35f) : _localCharacter.Center)));
				Vector3 val2 = center - val;
				val2.y = Mathf.Max(val2.y, 0.18f);
				if (!IsFiniteVector(val2) || ((Vector3)(ref val2)).sqrMagnitude < 1E-06f)
				{
					val2 = ((Component)zombie).transform.forward;
					val2.y = 0.18f;
				}
				((Vector3)(ref val2)).Normalize();
				Vector3 val3 = val2 * zombieKnockbackForceRuntime;
				if (_characterAddForceMethod == null)
				{
					_characterAddForceMethod = typeof(Character).GetMethod("AddForce", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
					{
						typeof(Vector3),
						typeof(float),
						typeof(float)
					}, null);
				}
				if (_characterAddForceMethod != null)
				{
					_characterAddForceMethod.Invoke(zombie, new object[3] { val3, 1f, 1f });
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[ShootZombies] ApplyZombieKnockback failed: " + ex.Message));
				}
			}
		}

		private static bool CanMutateZombie(PhotonView zombieView)
		{
			if (!HasOnlineRoomSession())
			{
				return true;
			}
			if ((Object)(object)zombieView == (Object)null)
			{
				return PhotonNetwork.IsMasterClient;
			}
			if (!zombieView.IsMine)
			{
				return PhotonNetwork.IsMasterClient;
			}
			return true;
		}

		[IteratorStateMachine(typeof(<ZombieHitEffect>d__73))]
		private IEnumerator ZombieHitEffect(Character zombie)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ZombieHitEffect>d__73(0)
			{
				zombie = zombie
			};
		}

		private void TriggerZombieFall(Character zombie)
		{
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Expected O, but got Unknown
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Expected O, but got Unknown
			if ((Object)(object)zombie == (Object)null)
			{
				return;
			}
			try
			{
				MushroomZombie component = ((Component)zombie).GetComponent<MushroomZombie>();
				if ((Object)(object)component != (Object)null)
				{
					((Behaviour)component).enabled = false;
				}
				FieldInfo field = ((object)zombie).GetType().GetField("agent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null)
				{
					field = ((object)zombie).GetType().GetField("_agent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (field == null)
				{
					field = ((object)zombie).GetType().GetField("navMeshAgent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				if (field != null)
				{
					object value = field.GetValue(zombie);
					if (value != null)
					{
						PropertyInfo property = value.GetType().GetProperty("enabled");
						if (property != null)
						{
							property.SetValue(value, false);
						}
					}
				}
				if ((Object)(object)zombie.data != (Object)null)
				{
					FieldInfo field2 = ((object)zombie.data).GetType().GetField("dead", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field2 != null)
					{
						field2.SetValue(zombie.data, true);
					}
				}
				MethodInfo method = ((object)zombie).GetType().GetMethod("Fall", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method != null)
				{
					try
					{
						ParameterInfo[] parameters = method.GetParameters();
						if (parameters.Length == 0)
						{
							method.Invoke(zombie, new object[0]);
						}
						else
						{
							object[] array = new object[parameters.Length];
							for (int i = 0; i < parameters.Length; i++)
							{
								if (parameters[i].HasDefaultValue)
								{
									array[i] = parameters[i].DefaultValue;
								}
								else if (parameters[i].ParameterType == typeof(bool))
								{
									array[i] = true;
								}
								else if (parameters[i].ParameterType == typeof(float))
								{
									array[i] = 0f;
								}
								else
								{
									array[i] = null;
								}
							}
							method.Invoke(zombie, array);
						}
					}
					catch (Exception)
					{
					}
				}
				CharacterRefs refs = zombie.refs;
				if (refs == null)
				{
					return;
				}
				PropertyInfo property2 = ((object)refs).GetType().GetProperty("ragdoll", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property2 != null)
				{
					object value2 = property2.GetValue(refs);
					if (value2 != null)
					{
						MethodInfo method2 = value2.GetType().GetMethod("ToggleRagdoll", BindingFlags.Instance | BindingFlags.Public);
						if (method2 != null)
						{
							method2.Invoke(value2, new object[1] { true });
						}
						PropertyInfo property3 = value2.GetType().GetProperty("ragdollEnabled", BindingFlags.Instance | BindingFlags.Public);
						if (property3 != null)
						{
							property3.SetValue(value2, true);
						}
						FieldInfo field3 = value2.GetType().GetField("enabled", BindingFlags.Instance | BindingFlags.Public);
						if (field3 != null)
						{
							field3.SetValue(value2, true);
						}
					}
				}
				FieldInfo field4 = ((object)refs).GetType().GetField("partList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(field4 != null))
				{
					return;
				}
				object value3 = field4.GetValue(refs);
				if (value3 == null || !(value3 is IList list))
				{
					return;
				}
				int num = 0;
				foreach (object item in list)
				{
					if (item == null)
					{
						continue;
					}
					GameObject val = (GameObject)((item is GameObject) ? item : null);
					if ((Object)(object)val != (Object)null)
					{
						Rigidbody component2 = val.GetComponent<Rigidbody>();
						if ((Object)(object)component2 != (Object)null)
						{
							component2.isKinematic = false;
							component2.useGravity = true;
							num++;
						}
						continue;
					}
					Component val2 = (Component)((item is Component) ? item : null);
					if ((Object)(object)val2 != (Object)null)
					{
						Rigidbody component3 = val2.GetComponent<Rigidbody>();
						if ((Object)(object)component3 != (Object)null)
						{
							component3.isKinematic = false;
							component3.useGravity = true;
							num++;
						}
					}
				}
			}
			catch (Exception)
			{
			}
		}

		[IteratorStateMachine(typeof(<DestroyZombieAfterDelay>d__75))]
		private IEnumerator DestroyZombieAfterDelay(Character zombie, float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DestroyZombieAfterDelay>d__75(0)
			{
				zombie = zombie,
				delay = delay
			};
		}

		private void RefreshLocalizedConfigFiles(bool isChinese)
		{
			try
			{
				ConfigFile config = ((BaseUnityPlugin)this).Config;
				if (config != null)
				{
					config.Save();
				}
				CleanupAuxiliaryConfigFiles();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RefreshLocalizedConfigFiles failed: " + DescribeReflectionException(ex)));
			}
		}

		private void PreparePrimaryConfigFile()
		{
			try
			{
				string canonicalConfigPath = GetCanonicalConfigPath();
				if (!string.IsNullOrWhiteSpace(canonicalConfigPath))
				{
					string directoryName = Path.GetDirectoryName(canonicalConfigPath);
					if (!string.IsNullOrWhiteSpace(directoryName))
					{
						Directory.CreateDirectory(directoryName);
					}
				}
				if (!string.IsNullOrWhiteSpace(canonicalConfigPath) && !File.Exists(canonicalConfigPath))
				{
					string latestExistingConfigPath = GetLatestExistingConfigPath(new string[7]
					{
						GetCanonicalConfigPath(),
						GetPreviousCanonicalConfigPath(),
						GetLegacyCanonicalConfigPath(),
						Path.Combine(Paths.ConfigPath, "Thanks.ShootZombies.zh-CN.cfg"),
						Path.Combine(Paths.ConfigPath, "Thanks.ShootZombies.en.cfg"),
						GetLocalizedConfigMirrorPath(),
						GetPreviousLocalizedConfigMirrorPath()
					});
					if (!string.IsNullOrWhiteSpace(latestExistingConfigPath) && File.Exists(latestExistingConfigPath))
					{
						File.Copy(latestExistingConfigPath, canonicalConfigPath, overwrite: true);
					}
				}
				CleanupAuxiliaryConfigFiles();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] PreparePrimaryConfigFile failed: " + ex.Message));
			}
		}

		private static string GetLatestExistingConfigPath(IEnumerable<string> candidatePaths)
		{
			string text = string.Empty;
			DateTime dateTime = DateTime.MinValue;
			if (candidatePaths == null)
			{
				return text;
			}
			foreach (string candidatePath in candidatePaths)
			{
				if (!string.IsNullOrWhiteSpace(candidatePath) && File.Exists(candidatePath))
				{
					DateTime lastWriteTimeUtc = File.GetLastWriteTimeUtc(candidatePath);
					if (string.IsNullOrWhiteSpace(text) || lastWriteTimeUtc > dateTime)
					{
						text = candidatePath;
						dateTime = lastWriteTimeUtc;
					}
				}
			}
			return text;
		}

		private static string ReadConfigMetadataValue(string configPath, string metadataPrefix)
		{
			if (string.IsNullOrWhiteSpace(configPath) || string.IsNullOrWhiteSpace(metadataPrefix) || !File.Exists(configPath))
			{
				return string.Empty;
			}
			try
			{
				string[] array = File.ReadAllLines(configPath, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
				for (int i = 0; i < array.Length; i++)
				{
					string text = (array[i] ?? string.Empty).Trim();
					if (text.StartsWith(metadataPrefix, StringComparison.Ordinal))
					{
						return text.Substring(metadataPrefix.Length).Trim();
					}
				}
			}
			catch
			{
			}
			return string.Empty;
		}

		private string ReadStoredZombieBehaviorDifficultySelection()
		{
			string value = ReadConfigMetadataValue(GetCanonicalConfigPath(), "## ShootZombiesZombieDifficulty: ");
			if (string.IsNullOrWhiteSpace(value))
			{
				return string.Empty;
			}
			return NormalizeZombieBehaviorDifficultySelection(value);
		}

		private void CleanupAuxiliaryConfigFiles()
		{
			try
			{
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				string canonicalConfigPath = GetCanonicalConfigPath();
				if (!string.IsNullOrWhiteSpace(canonicalConfigPath))
				{
					hashSet.Add(canonicalConfigPath);
				}
				HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				string[] array = new string[7]
				{
					GetPreviousCanonicalConfigPath(),
					GetLegacyCanonicalConfigPath(),
					Path.Combine(Paths.ConfigPath, "Thanks.ShootZombies.zh-CN.cfg"),
					Path.Combine(Paths.ConfigPath, "Thanks.ShootZombies.en.cfg"),
					GetLocalizedConfigMirrorPath(),
					GetPreviousLocalizedConfigMirrorPath(),
					GetLegacyLocalizedConfigMirrorPath()
				};
				foreach (string text in array)
				{
					if (!string.IsNullOrWhiteSpace(text) && !hashSet.Contains(text))
					{
						hashSet2.Add(text);
					}
				}
				foreach (string item in hashSet2)
				{
					if (File.Exists(item))
					{
						File.Delete(item);
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] CleanupAuxiliaryConfigFiles failed: " + ex.Message));
			}
		}

		private void NormalizeCanonicalConfigEncoding()
		{
			try
			{
				string canonicalConfigPath = GetCanonicalConfigPath();
				if (!string.IsNullOrWhiteSpace(canonicalConfigPath) && File.Exists(canonicalConfigPath))
				{
					string contents = File.ReadAllText(canonicalConfigPath, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
					File.WriteAllText(canonicalConfigPath, contents, new UTF8Encoding(encoderShouldEmitUTF8Identifier: true));
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] NormalizeCanonicalConfigEncoding failed: " + ex.Message));
			}
		}

		private static string GetCanonicalConfigPath()
		{
			return Path.Combine(Paths.ConfigPath, "Thanks.ShootZombies.cfg");
		}

		private string GetActivePluginConfigPath()
		{
			if (!string.IsNullOrWhiteSpace(_pluginConfigPath))
			{
				return _pluginConfigPath;
			}
			return GetCanonicalConfigPath();
		}

		private static string GetConfigFilePath(ConfigFile config)
		{
			return (((object)config)?.GetType().GetProperty("ConfigFilePath", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(config) as string) ?? string.Empty;
		}

		private static string GetPreviousCanonicalConfigPath()
		{
			return Path.Combine(Paths.ConfigPath, "com.github.Thanks.ShootZombies.cfg");
		}

		private static string GetLegacyCanonicalConfigPath()
		{
			return Path.Combine(Paths.ConfigPath, "com.github.PeakTest.ShootZombies.cfg");
		}

		private static string GetLocalizedConfigMirrorPath()
		{
			return Path.Combine(Paths.ConfigPath, "Thanks.ShootZombies.localized.cfg");
		}

		private static string GetPreviousLocalizedConfigMirrorPath()
		{
			return Path.Combine(Paths.ConfigPath, "com.github.Thanks.ShootZombies.localized.cfg");
		}

		private static string GetLegacyLocalizedConfigMirrorPath()
		{
			return Path.Combine(Paths.ConfigPath, "com.github.PeakTest.ShootZombies.localized.cfg");
		}

		private void CheckConfigChanges()
		{
			bool flag = false;
			bool flag2 = false;
			if (ModEnabled != null && ModEnabled.Value != _lastModEnabled)
			{
				_lastModEnabled = ModEnabled.Value;
				if (_lastModEnabled)
				{
					if (IsZombieSpawnFeatureEnabled())
					{
						ZombieSpawner.StartZombieSpawning();
					}
				}
				else
				{
					ZombieSpawner.StopZombieSpawning();
					RestoreVanillaBlowgunFeatureState();
				}
				UpdateWeaponLobbyNotice();
			}
			if (WeaponEnabled != null && WeaponEnabled.Value != _lastWeaponEnabled)
			{
				_lastWeaponEnabled = WeaponEnabled.Value;
				if (!_lastWeaponEnabled)
				{
					RestoreVanillaBlowgunFeatureState();
				}
				UpdateWeaponLobbyNotice();
			}
			if (WeaponSelection != null)
			{
				string text = NormalizeWeaponSelection(WeaponSelection.Value);
				if (!string.Equals(WeaponSelection.Value, text, StringComparison.Ordinal))
				{
					WeaponSelection.Value = text;
					SavePluginConfigQuietly();
				}
				if (!string.Equals(text, _lastWeaponSelection, StringComparison.Ordinal))
				{
					_lastWeaponSelection = text;
					ApplySelectedWeaponAssets();
					PublishLocalWeaponSelectionToPlayerProperties(force: true);
					_pendingLocalWeaponVisualModelRefresh = true;
					RequestAkVisualRefresh(includeUiRefresh: true, forceRefresh: true);
					UpdateWeaponLobbyNotice();
				}
			}
			if (WeaponModelPitch != null && !Mathf.Approximately(WeaponModelPitch.Value, _lastWeaponModelPitch))
			{
				_lastWeaponModelPitch = WeaponModelPitch.Value;
				flag = true;
			}
			if (WeaponModelYaw != null && !Mathf.Approximately(WeaponModelYaw.Value, _lastWeaponModelYaw))
			{
				_lastWeaponModelYaw = WeaponModelYaw.Value;
				flag = true;
			}
			if (WeaponModelRoll != null && !Mathf.Approximately(WeaponModelRoll.Value, _lastWeaponModelRoll))
			{
				_lastWeaponModelRoll = WeaponModelRoll.Value;
				flag = true;
			}
			if (WeaponModelScale != null && !Mathf.Approximately(WeaponModelScale.Value, _lastWeaponModelScale))
			{
				_lastWeaponModelScale = WeaponModelScale.Value;
				flag = true;
			}
			if (WeaponModelOffsetX != null && !Mathf.Approximately(WeaponModelOffsetX.Value, _lastWeaponModelOffsetX))
			{
				_lastWeaponModelOffsetX = WeaponModelOffsetX.Value;
				flag = true;
			}
			if (WeaponModelOffsetY != null && !Mathf.Approximately(WeaponModelOffsetY.Value, _lastWeaponModelOffsetY))
			{
				_lastWeaponModelOffsetY = WeaponModelOffsetY.Value;
				flag = true;
			}
			if (WeaponModelOffsetZ != null && !Mathf.Approximately(WeaponModelOffsetZ.Value, _lastWeaponModelOffsetZ))
			{
				_lastWeaponModelOffsetZ = WeaponModelOffsetZ.Value;
				flag = true;
			}
			if (ZombieBehaviorDifficulty != null)
			{
				string text2 = NormalizeZombieBehaviorDifficultySelection(ZombieBehaviorDifficulty.Value);
				if (!string.Equals(ZombieBehaviorDifficulty.Value, text2, StringComparison.Ordinal))
				{
					ZombieBehaviorDifficulty.Value = text2;
					SavePluginConfigQuietly();
				}
				if (!string.Equals(text2, _lastZombieBehaviorDifficulty, StringComparison.Ordinal))
				{
					_lastZombieBehaviorDifficulty = text2;
					ApplyZombieBehaviorDifficultyPreset(text2);
					ApplySimplifiedZombieDerivedValues();
				}
			}
			ZombieBehaviorDifficultyPreset currentZombieBehaviorDifficultyPresetRuntime = GetCurrentZombieBehaviorDifficultyPresetRuntime();
			float zombieMoveSpeedMultiplierRuntime = GetZombieMoveSpeedMultiplierRuntime();
			if (!Mathf.Approximately(zombieMoveSpeedMultiplierRuntime, _lastZombieMoveSpeed))
			{
				_lastZombieMoveSpeed = zombieMoveSpeedMultiplierRuntime;
				_pendingZombieSpeedRefresh = true;
				UpdateZombieSpeed(forceRefresh: true);
			}
			if (!Mathf.Approximately(GetZombieKnockbackForceRuntime(), _lastZombieKnockbackForce))
			{
				_lastZombieKnockbackForce = GetZombieKnockbackForceRuntime();
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.DistanceBeforeWakeup, _lastDistanceBeforeWakeup))
			{
				_lastDistanceBeforeWakeup = currentZombieBehaviorDifficultyPresetRuntime.DistanceBeforeWakeup;
				flag2 = true;
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.SprintDistance, _lastZombieSprintDistance))
			{
				_lastZombieSprintDistance = currentZombieBehaviorDifficultyPresetRuntime.SprintDistance;
				flag2 = true;
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.ChaseTimeBeforeSprint, _lastChaseTimeBeforeSprint))
			{
				_lastChaseTimeBeforeSprint = currentZombieBehaviorDifficultyPresetRuntime.ChaseTimeBeforeSprint;
				flag2 = true;
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.LungeDistance, _lastZombieLungeDistance))
			{
				_lastZombieLungeDistance = currentZombieBehaviorDifficultyPresetRuntime.LungeDistance;
				flag2 = true;
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.BiteRecoveryTime, _lastZombieBiteRecoveryTime))
			{
				_lastZombieBiteRecoveryTime = currentZombieBehaviorDifficultyPresetRuntime.BiteRecoveryTime;
				flag2 = true;
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.LungeTime, _lastZombieLungeTime))
			{
				_lastZombieLungeTime = currentZombieBehaviorDifficultyPresetRuntime.LungeTime;
				flag2 = true;
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.LungeRecoveryTime, _lastZombieLungeRecoveryTime))
			{
				_lastZombieLungeRecoveryTime = currentZombieBehaviorDifficultyPresetRuntime.LungeRecoveryTime;
				flag2 = true;
			}
			if (!Mathf.Approximately(currentZombieBehaviorDifficultyPresetRuntime.LookAngleBeforeWakeup, _lastZombieLookAngleBeforeWakeup))
			{
				_lastZombieLookAngleBeforeWakeup = currentZombieBehaviorDifficultyPresetRuntime.LookAngleBeforeWakeup;
				flag2 = true;
			}
			bool flag3 = IsZombieSpawnFeatureEnabled();
			if (flag3 != _lastZombieSpawnEnabled)
			{
				_lastZombieSpawnEnabled = flag3;
				if (flag3)
				{
					ZombieSpawner.StartZombieSpawning();
				}
				else
				{
					ZombieSpawner.StopZombieSpawning();
				}
			}
			if (flag)
			{
				RefreshWeaponModelVisuals();
			}
			if (flag2)
			{
				ZombieSpawner.RefreshLiveZombieProperties();
			}
			MarkRoomConfigDirtyIfPublishedPayloadChanged();
		}

		private void RemoveLegacyInventorySlotConfig()
		{
			try
			{
				RemoveConfigDefinition("Inventory", "Slot");
				RemoveConfigDefinition("物品栏", "槽位");
				ConfigFile config = ((BaseUnityPlugin)this).Config;
				if (config != null)
				{
					config.Save();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RemoveLegacyInventorySlotConfig failed: " + DescribeReflectionException(ex)));
			}
		}

		private void RemoveLegacyFogModeConfig()
		{
			try
			{
				string[] array = new string[2] { "Fog", "毒雾" };
				string[] array2 = new string[10] { "##FogMode##", "Fog Mode", "Spawn Compass", "Speed", "Start Delay", "Fog UI", "UI X Position", "UI Y Position", "UI Scale", "Pause Fog" };
				string[] array3 = new string[2] { "Features", "功能" };
				string[] array4 = new string[1] { "Night Cold" };
				string[] array5 = array;
				foreach (string section in array5)
				{
					string[] array6 = array2;
					foreach (string key in array6)
					{
						RemoveConfigDefinition(section, key);
					}
				}
				array5 = array3;
				foreach (string section2 in array5)
				{
					string[] array6 = array4;
					foreach (string key2 in array6)
					{
						RemoveConfigDefinition(section2, key2);
					}
				}
				ConfigFile config = ((BaseUnityPlugin)this).Config;
				if (config != null)
				{
					config.Save();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RemoveLegacyFogModeConfig failed: " + DescribeReflectionException(ex)));
			}
		}

		private void RemoveLegacyPlayerShotConfig()
		{
			try
			{
				ConfigFile config = ((BaseUnityPlugin)this).Config;
				IDictionary dictionary = ((config != null) ? (((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(config) as IDictionary) : null);
				foreach (ConfigDefinition item in BuildConfigDefinitionAliases("Weapon", "Player Shot Drowsy"))
				{
					if (config != null)
					{
						config.Remove(item);
					}
					dictionary?.Remove(item);
				}
				if (config != null)
				{
					config.Save();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RemoveLegacyPlayerShotConfig failed: " + DescribeReflectionException(ex)));
			}
		}

		private void RemoveConfigDefinition(string section, string key)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (((BaseUnityPlugin)this).Config != null && !string.IsNullOrWhiteSpace(section) && !string.IsNullOrWhiteSpace(key))
			{
				ConfigDefinition val = new ConfigDefinition(section, key);
				((BaseUnityPlugin)this).Config.Remove(val);
				(((object)((BaseUnityPlugin)this).Config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(((BaseUnityPlugin)this).Config) as IDictionary)?.Remove(val);
			}
		}

		private void ApplyLocalizedConfigMetadata(bool isChinese)
		{
			try
			{
				ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config);
				if (configEntriesSnapshot.Length == 0)
				{
					return;
				}
				ConfigEntryBase[] array = configEntriesSnapshot;
				foreach (ConfigEntryBase val in array)
				{
					if (val != null && !(val.Definition == (ConfigDefinition)null))
					{
						string localizedDescription = GetLocalizedDescription(val.Definition.Key, isChinese);
						if (val.Description != null && !string.IsNullOrEmpty(localizedDescription))
						{
							SetPrivateField(val.Description, "<Description>k__BackingField", localizedDescription);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] ApplyLocalizedConfigMetadata failed: " + ex.Message));
			}
		}

		private void MigrateLegacyLocalizedConfigEntries()
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			try
			{
				ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config);
				IDictionary dictionary = ((object)((BaseUnityPlugin)this).Config)?.GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(((BaseUnityPlugin)this).Config) as IDictionary;
				if (configEntriesSnapshot.Length == 0 || dictionary == null || dictionary.Count == 0)
				{
					return;
				}
				bool flag = false;
				ConfigEntryBase[] array = configEntriesSnapshot;
				foreach (ConfigEntryBase val in array)
				{
					if (((val != null) ? val.Definition : null) == (ConfigDefinition)null)
					{
						continue;
					}
					string legacyConfigSectionAlias = GetLegacyConfigSectionAlias(val);
					string localizedSectionName = GetLocalizedSectionName(val.Definition.Section, isChinese: true);
					string localizedKeyName = GetLocalizedKeyName(val.Definition.Key, isChinese: true);
					List<ConfigDefinition> list = new List<ConfigDefinition>(6)
					{
						new ConfigDefinition(localizedSectionName, val.Definition.Key),
						new ConfigDefinition(val.Definition.Section, localizedKeyName),
						new ConfigDefinition(localizedSectionName, localizedKeyName)
					};
					if (!string.IsNullOrWhiteSpace(legacyConfigSectionAlias) && !string.Equals(legacyConfigSectionAlias, val.Definition.Section, StringComparison.Ordinal))
					{
						string localizedSectionName2 = GetLocalizedSectionName(legacyConfigSectionAlias, isChinese: true);
						list.Add(new ConfigDefinition(legacyConfigSectionAlias, val.Definition.Key));
						list.Add(new ConfigDefinition(legacyConfigSectionAlias, localizedKeyName));
						if (!string.IsNullOrWhiteSpace(localizedSectionName2))
						{
							list.Add(new ConfigDefinition(localizedSectionName2, val.Definition.Key));
							list.Add(new ConfigDefinition(localizedSectionName2, localizedKeyName));
						}
					}
					foreach (ConfigDefinition item in list)
					{
						if (dictionary.Contains(item))
						{
							object obj = dictionary[item];
							if (obj != null)
							{
								val.SetSerializedValue(obj.ToString());
								flag = true;
							}
							dictionary.Remove(item);
						}
					}
				}
				if (flag)
				{
					ConfigFile config = ((BaseUnityPlugin)this).Config;
					if (config != null)
					{
						config.Save();
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] MigrateLegacyLocalizedConfigEntries failed: " + DescribeReflectionException(ex)));
			}
		}

		private static string GetLegacyConfigSectionAlias(ConfigEntryBase entry)
		{
			if (entry == null)
			{
				return string.Empty;
			}
			return GetModConfigSectionForEntry(entry);
		}

		private static void SetPrivateField(object target, string fieldName, object value)
		{
			if (target != null && !string.IsNullOrEmpty(fieldName))
			{
				target.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(target, value);
			}
		}

		private static ConfigEntryBase[] GetConfigEntriesSnapshot(ConfigFile configFile)
		{
			if (configFile == null)
			{
				return Array.Empty<ConfigEntryBase>();
			}
			if (!(((object)configFile).GetType().GetProperty("Entries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(configFile) is IDictionary dictionary) || dictionary.Count == 0)
			{
				return Array.Empty<ConfigEntryBase>();
			}
			return (from entry in dictionary.Values.Cast<object>().OfType<ConfigEntryBase>()
				where entry != null
				select entry).ToArray();
		}

		internal static ConfigEntryBase[] GetConfigEntriesSnapshotRuntime(ConfigFile configFile)
		{
			return GetConfigEntriesSnapshot(configFile);
		}

		internal static string GetLocalizedConfigKeyDisplayRuntime(string key)
		{
			return GetLocalizedKeyName(key, Instance?.GetCachedChineseLanguageSetting() ?? false);
		}

		internal static string GetLocalizedConfigSectionDisplayRuntime(string section)
		{
			return GetLocalizedSectionName(section, Instance?.GetCachedChineseLanguageSetting() ?? false);
		}

		internal static string GetLocalizedConfigDescriptionRuntime(string key)
		{
			return GetLocalizedDescription(key, Instance?.GetCachedChineseLanguageSetting() ?? false);
		}

		internal static int GetOwnedConfigEntrySortIndexRuntime(ConfigEntryBase entry)
		{
			return GetModConfigEntrySortIndex(entry);
		}

		internal static int GetOwnedConfigSectionSortIndexRuntime(string section)
		{
			return GetModConfigSectionSortIndex(section);
		}

		internal static string GetOwnedConfigSectionRuntime(ConfigEntryBase entry)
		{
			return GetModConfigSectionForEntry(entry);
		}

		internal static bool ShouldExposeOwnedConfigEntryRuntime(ConfigEntryBase entry)
		{
			return ShouldExposeOwnedConfigEntry(entry);
		}

		internal static string[] GetOwnedSelectableConfigValuesRuntime(ConfigEntryBase entry)
		{
			if (entry == ConfigPanelTheme)
			{
				return ConfigPanelThemeValues.ToArray();
			}
			if (entry == WeaponSelection)
			{
				return WeaponSelectionValues.ToArray();
			}
			if (entry == AkSoundSelection)
			{
				return AkSoundSelectionValues.ToArray();
			}
			if (entry == ZombieBehaviorDifficulty)
			{
				return ZombieBehaviorDifficultyValues.ToArray();
			}
			return Array.Empty<string>();
		}

		internal static bool ShouldEmitVerboseInfoLogsRuntime()
		{
			return EnableVerboseInfoLogs;
		}

		private static string GetLocalizedSectionName(string section, bool isChinese)
		{
			return NormalizeLocalizedText(GetLocalizedSectionNameCore(NormalizeLocalizedText(section), isChinese));
		}

		private static string GetLocalizedSectionDescription(string section, bool isChinese)
		{
			return NormalizeLocalizedText(GetLocalizedSectionDescriptionCore(NormalizeLocalizedText(section), isChinese));
		}

		private static string GetLocalizedKeyName(string key, bool isChinese)
		{
			return NormalizeLocalizedText(GetLocalizedKeyNameCore(NormalizeLocalizedText(key), isChinese));
		}

		private static string GetLocalizedDescription(string key, bool isChinese)
		{
			return NormalizeLocalizedText(GetLocalizedDescriptionCore(NormalizeLocalizedText(key), isChinese));
		}

		private static string GetLocalizedModDisplayName(bool isChinese)
		{
			return NormalizeLocalizedText(GetLocalizedModDisplayNameCore(isChinese));
		}

		private static string GetLobbyWeaponNoticeTextCore(bool isChinese)
		{
			List<string> list = new List<string>(1);
			if (IsWeaponFeatureEnabled())
			{
				string spawnWeaponKeyLabel = GetSpawnWeaponKeyLabel();
				string text = "<color=#FF3B30>" + spawnWeaponKeyLabel + "</color>";
				string currentWeaponDisplayName = GetCurrentWeaponDisplayName();
				list.Add(isChinese ? ("按 " + text + " 获取 " + currentWeaponDisplayName) : ("Press " + text + " to get " + currentWeaponDisplayName));
			}
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return string.Join("\n", list);
		}

		private static string GetSpawnWeaponKeyLabel()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			KeyCode val = (KeyCode)((SpawnWeaponKey == null || (int)SpawnWeaponKey.Value == 0) ? 116 : ((int)SpawnWeaponKey.Value));
			string text = ((object)(KeyCode)(ref val)).ToString();
			if (string.IsNullOrWhiteSpace(text))
			{
				return "T";
			}
			return text.ToUpperInvariant();
		}

		private static string NormalizeLocalizedText(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			string text = value;
			if (LooksLikeMojibake(text))
			{
				text = TryRepairMojibakeUtf8(text, Encoding.GetEncoding(1252));
				if (LooksLikeMojibake(text))
				{
					text = TryRepairMojibakeUtf8(text, Encoding.GetEncoding(28591));
				}
			}
			if (ContainsUnexpectedControlCharacters(text))
			{
				text = new string(text.Where((char c) => c == '\r' || c == '\n' || c == '\t' || !char.IsControl(c)).ToArray());
			}
			return text;
		}

		private static string TryRepairMojibakeUtf8(string value, Encoding sourceEncoding)
		{
			if (string.IsNullOrEmpty(value) || sourceEncoding == null)
			{
				return value;
			}
			try
			{
				string @string = Encoding.UTF8.GetString(sourceEncoding.GetBytes(value));
				if (IsBetterLocalizedText(value, @string))
				{
					return @string;
				}
			}
			catch
			{
			}
			return value;
		}

		private static bool IsBetterLocalizedText(string original, string candidate)
		{
			if (string.IsNullOrWhiteSpace(candidate) || string.Equals(original, candidate, StringComparison.Ordinal))
			{
				return false;
			}
			return GetLocalizationNoiseScore(candidate) < GetLocalizationNoiseScore(original);
		}

		private static bool LooksLikeMojibake(string value)
		{
			return GetLocalizationNoiseScore(value) > 0;
		}

		private static int GetLocalizationNoiseScore(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return 0;
			}
			int num = 0;
			foreach (char c in value)
			{
				if (c >= '\u0080' && c <= '\u009f')
				{
					num += 6;
				}
				else if (c == '\ufffd')
				{
					num += 8;
				}
				else if ("ÃÂÅÆÇÈÉÊËÌÃ\u008dÃŽÃ\u008fÃ\u0090ÑÒÓÔÕÖÃ\u02dcÙÚÛÜÃ\u009dÞßÃ\u00a0áâãäåæçÃ\u00a8éêëìÃ\u00adîÃ\u00afðñòóÃ\u00b4õöÃ\u00b8ùúûüýþÿ€ŒœÅ\u00a0Å¡Å\u00b8Žž".IndexOf(c) >= 0)
				{
					num += 2;
				}
				else if (c >= '一' && c <= '\u9fff')
				{
					num--;
				}
			}
			return num;
		}

		private static bool ContainsUnexpectedControlCharacters(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			foreach (char c in value)
			{
				if (char.IsControl(c) && c != '\r' && c != '\n' && c != '\t')
				{
					return true;
				}
			}
			return false;
		}

		private static string StripDisplayOrderPrefix(string value)
		{
			string text = NormalizeLocalizedText(value).Trim();
			if (string.IsNullOrWhiteSpace(text) || !char.IsDigit(text[0]))
			{
				return text;
			}
			int i;
			for (i = 0; i < text.Length && char.IsDigit(text[i]); i++)
			{
			}
			for (; i < text.Length && (char.IsWhiteSpace(text[i]) || text[i] == '.' || text[i] == ')' || text[i] == ':' || text[i] == '-'); i++)
			{
			}
			if (i < text.Length)
			{
				return text.Substring(i).Trim();
			}
			return text;
		}

		private static string NormalizeSectionAlias(string section)
		{
			string text = NormalizeLocalizedText(StripDisplayOrderPrefix(section)).Trim();
			switch (text.ToLowerInvariant())
			{
			case "weapon":
			case "weapons":
			case "weapon settings":
			case "武器":
				return "Weapon";
			case "zombie":
			case "zombie behavior":
			case "僵尸":
			case "僵尸行为":
				return "Zombie";
			case "zombie spawning":
			case "僵尸生成":
			case "zombie spawn":
			case "zombie spawn settings":
				return "Zombie Spawn";
			case "feature":
			case "hotkeys":
			case "功能":
			case "features":
			case "快捷键":
				return "Features";
			case "general":
			case "通用":
				return "General";
			default:
				return text;
			}
		}

		private static string NormalizeConfigKeyAlias(string key)
		{
			switch (StripDisplayOrderPrefix(key))
			{
			case "Fire Interval":
			case "射击间隔":
			case "射击间隔（秒）":
				return "Fire Interval";
			case "Fire Volume":
			case "射击音量":
				return "Fire Volume";
			case "Weapon Model X Rotation":
			case "武器X轴旋转":
			case "手持模型X轴旋转":
				return "Weapon Model X Rotation";
			case "Weapon Model Y Rotation":
			case "武器Y轴旋转":
			case "手持模型Y轴旋转":
				return "Weapon Model Y Rotation";
			case "Weapon Model Z Rotation":
			case "武器Z轴旋转":
			case "手持模型Z轴旋转":
				return "Weapon Model Z Rotation";
			case "Weapon Model Scale":
			case "武器模型缩放":
			case "手持模型缩放":
				return "Weapon Model Scale";
			case "Weapon Model X Position":
			case "武器X轴位置":
			case "手持模型X位置":
				return "Weapon Model X Position";
			case "Weapon Model Y Position":
			case "武器Y轴位置":
			case "手持模型Y位置":
				return "Weapon Model Y Position";
			case "Weapon Model Z Position":
			case "武器Z轴位置":
			case "手持模型Z位置":
				return "Weapon Model Z Position";
			case "AK Sound":
			case "AK47音效":
			case "AK射击音效":
				return "AK Sound";
			case "Weapon Selection":
			case "武器选择":
			case "武器模型选择":
				return "Weapon Selection";
			case "default":
			case "Default":
			case "默认":
				return "default";
			case "Max Distance":
			case "最大射程":
				return "Max Distance";
			case "Bullet Size":
			case "子弹大小":
				return "Bullet Size";
			case "Zombie Time Reduction":
			case "Damage":
			case "伤害":
			case "命中僵尸减少的存活时间":
				return "Zombie Time Reduction";
			case "Mod Enabled":
			case "Mod":
			case "模组":
			case "模组总开关":
			case "启用模组":
				return "Mod";
			case "Weapon Enabled":
			case "Weapon":
			case "武器生成":
			case "武器生成启用":
			case "启用武器发放":
				return "Weapon";
			case "Spawn Weapon":
			case "生成武器":
			case "生成武器按键":
				return "Spawn Weapon";
			case "Open Config Panel":
			case "打开配置面板":
			case "打开配置面板按键":
			case "配置面板":
				return "Open Config Panel";
			case "Config Panel Theme":
			case "面板主题":
			case "配置面板主题":
				return "Config Panel Theme";
			case "Zombie Spawn Enabled":
			case "Zombie Spawn":
			case "Enabled":
			case "僵尸生成":
			case "僵尸生成启用":
			case "启用":
				return "Zombie Spawn";
			case "Move Speed":
			case "移动速度":
				return "Move Speed";
			case "Aggressiveness":
			case "进攻欲望":
				return "Aggressiveness";
			case "Knockback Force":
			case "击退力度":
				return "Knockback Force";
			case "Max Count":
			case "Zombie Count":
			case "Zombie Max Count":
			case "Max Zombie Count":
			case "最大数量":
			case "僵尸数量":
			case "僵尸最大数量":
				return "Max Count";
			case "Spawn Interval":
			case "生成间隔":
			case "两次僵尸生成波之间的时间间隔":
				return "Spawn Interval";
			case "Interval Random":
			case "间隔随机":
				return "Interval Random";
			case "Spawn Count":
			case "每次生成数量":
			case "每波生成数量":
				return "Spawn Count";
			case "Count Random":
			case "数量随机":
				return "Count Random";
			case "Spawn Radius":
			case "生成半径":
				return "Spawn Radius";
			case "Max Lifetime":
			case "Lifetime":
			case "Health":
			case "最大存活时间":
			case "生命值":
			case "存活时间":
			case "僵尸最大存活时间":
				return "Max Lifetime";
			case "Destroy Distance":
			case "Despawn Range":
			case "销毁距离":
			case "僵尸销毁范围":
				return "Destroy Distance";
			case "Behavior Difficulty":
			case "Zombie Difficulty":
			case "Difficulty":
			case "僵尸难度":
			case "难度":
			case "难度预设":
				return "Behavior Difficulty";
			case "Wakeup Distance":
			case "唤醒距离":
				return "Wakeup Distance";
			case "Chase Distance":
			case "追击距离":
				return "Chase Distance";
			case "Sprint Distance":
			case "冲刺距离":
				return "Sprint Distance";
			case "Chase Time":
			case "追击时间":
				return "Chase Time";
			case "Lunge Distance":
			case "猛扑距离":
				return "Lunge Distance";
			case "Lunge Time":
			case "猛扑持续时间":
				return "Lunge Time";
			case "Lunge Recovery Time":
			case "猛扑恢复时间":
				return "Lunge Recovery Time";
			case "Wakeup Look Angle":
			case "唤醒视角":
				return "Wakeup Look Angle";
			case "Target Search Interval":
			case "索敌刷新间隔":
				return "Target Search Interval";
			case "Bite Recovery Time":
			case "咬后恢复时间":
				return "Bite Recovery Time";
			case "Same Player Bite Cooldown":
			case "同玩家重复咬击冷却":
				return "Same Player Bite Cooldown";
			default:
				return StripDisplayOrderPrefix(key);
			}
		}

		private static string GetLocalizedSectionNameCore(string section, bool isChinese)
		{
			switch (NormalizeSectionAlias(section))
			{
			case "General":
				if (!isChinese)
				{
					return "General";
				}
				return "通用";
			case "Weapon":
				if (!isChinese)
				{
					return "Weapon";
				}
				return "武器";
			case "Zombie":
				if (!isChinese)
				{
					return "Zombie";
				}
				return "僵尸";
			case "Zombie Spawn":
				if (!isChinese)
				{
					return "Zombie Spawn (Auto)";
				}
				return "僵尸生成（自动）";
			case "Features":
				if (!isChinese)
				{
					return "Features";
				}
				return "功能";
			default:
				return section;
			}
		}

		private static bool TryGetLocalizedSectionDisplayName(string section, bool isChinese, out string displayName)
		{
			switch (NormalizeSectionAlias(section))
			{
			case "Weapon":
				displayName = (isChinese ? "武器" : "Weapon");
				return true;
			case "Zombie":
				displayName = GetLocalizedSectionName("Zombie", isChinese);
				return true;
			case "Zombie Spawn":
				displayName = (isChinese ? "僵尸生成（自动）" : "Zombie Spawn (Auto)");
				return true;
			case "Features":
				displayName = (isChinese ? "功能" : "Features");
				return true;
			default:
				displayName = GetLocalizedSectionName(section, isChinese);
				if (!string.IsNullOrWhiteSpace(displayName))
				{
					return !string.Equals(displayName, section, StringComparison.Ordinal);
				}
				return false;
			}
		}

		private void MigrateFeatureConfigDefinitions()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Expected O, but got Unknown
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Expected O, but got Unknown
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Expected O, but got Unknown
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Expected O, but got Unknown
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Expected O, but got Unknown
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Expected O, but got Unknown
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Expected O, but got Unknown
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Expected O, but got Unknown
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Expected O, but got Unknown
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Expected O, but got Unknown
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Expected O, but got Unknown
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Expected O, but got Unknown
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Expected O, but got Unknown
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Expected O, but got Unknown
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Expected O, but got Unknown
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Expected O, but got Unknown
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Expected O, but got Unknown
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Expected O, but got Unknown
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Expected O, but got Unknown
			//IL_0712: Unknown result type (might be due to invalid IL or missing references)
			//IL_0727: Expected O, but got Unknown
			try
			{
				if (((object)((BaseUnityPlugin)this).Config)?.GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(((BaseUnityPlugin)this).Config) is IDictionary dictionary && dictionary.Count != 0 && (false | MigrateCurrentConfigEntryAliases(dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ModEnabled, "General", "Mod", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)OpenConfigPanelKey, "General", "Open Config Panel", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ConfigPanelTheme, "General", "Config Panel Theme", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponEnabled, "General", "Weapon", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponSelection, "General", "Weapon Selection", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)SpawnWeaponKey, "General", "Spawn Weapon", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)FireInterval, "General", "Fire Interval", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)FireVolume, "General", "Fire Volume", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)AkSoundSelection, "General", "AK Sound", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieTimeReduction, "General", "Zombie Time Reduction", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelScale, "General", "Weapon Model Scale", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelPitch, "General", "Weapon Model X Rotation", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelYaw, "General", "Weapon Model Y Rotation", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelRoll, "General", "Weapon Model Z Rotation", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelOffsetX, "General", "Weapon Model X Position", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelOffsetY, "General", "Weapon Model Y Position", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelOffsetZ, "General", "Weapon Model Z Position", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)MaxZombies, "General", "Max Count", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieSpawnCount, "General", "Spawn Count", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieSpawnInterval, "General", "Spawn Interval", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieMaxLifetime, "General", "Max Lifetime", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieBehaviorDifficulty, "General", "Behavior Difficulty", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieKnockbackForce, "General", "Knockback Force", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)SpawnWeaponKey, "Hotkeys", "Spawn Weapon", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)SpawnWeaponKey, "Features", "Spawn Weapon", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Max Distance", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Bullet Size", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Zombie Spawn", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Enabled", dictionary) | RemoveLegacyConfigEntryValue("Features", "Zombie Spawn Enabled", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Zombie Spawn Enabled", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)MaxZombies, "Zombie Spawn", "Max Count", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieSpawnInterval, "Zombie Spawn", "Spawn Interval", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieSpawnCount, "Zombie Spawn", "Spawn Count", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieMaxLifetime, "Zombie Spawn", "Max Lifetime", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Destroy Distance", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ModEnabled, "Hotkeys", "Mod Enabled", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ModEnabled, "Features", "Mod Enabled", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponEnabled, "Features", "Weapon Enabled", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponEnabled, "Features", "Weapon", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelPitch, "Weapon", "Weapon Model X Rotation", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelYaw, "Weapon", "Weapon Model Y Rotation", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelRoll, "Weapon", "Weapon Model Z Rotation", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelOffsetX, "Weapon", "Weapon Model X Position", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelOffsetY, "Weapon", "Weapon Model Y Position", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)WeaponModelOffsetZ, "Weapon", "Weapon Model Z Position", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Interval Random", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Spawn Count", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Count Random", dictionary) | RemoveLegacyConfigEntryValue("Zombie Spawn", "Spawn Radius", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Move Speed", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Aggressiveness", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieKnockbackForce, "Zombie", "Knockback Force", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Wakeup Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Chase Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Sprint Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Chase Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Lunge Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Target Search Interval", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Bite Recovery Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Same Player Bite Cooldown", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Lunge Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Lunge Recovery Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Wakeup Look Angle", dictionary) | RemoveLegacyConfigEntryValue("Zombie", "Destroy Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Wakeup Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Chase Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Sprint Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Chase Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Lunge Distance", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Target Search Interval", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Bite Recovery Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Same Player Bite Cooldown", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Lunge Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Lunge Recovery Time", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Wakeup Look Angle", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Move Speed", dictionary) | RemoveLegacyConfigEntryValue("Zombie AI", "Aggressiveness", dictionary) | MigrateLegacyConfigEntryValue((ConfigEntryBase)ZombieKnockbackForce, "Zombie AI", "Knockback Force", dictionary) | RemoveLegacyConfigEntryValue("Hotkeys", "Spawn Compass", dictionary) | RemoveLegacyConfigEntryValue("Features", "Night Cold Enabled", dictionary) | RemoveLegacyConfigEntryValue("Features", "Night Cold", dictionary) | RemoveLegacyConfigEntryValue("Hotkeys", "Pause Fog", dictionary) | RemoveLegacyConfigEntryValue("Features", "Pause Fog", dictionary) | RemoveLegacyConfigEntryValue("Fog", "Fog Mode", dictionary) | RemoveLegacyConfigEntryValue("Features", "Fog Mode", dictionary) | RemoveLegacyConfigEntryValue("Fog", "UI Enabled", dictionary) | RemoveLegacyConfigEntryValue("Features", "Fog UI Enabled", dictionary) | RemoveLegacyConfigEntryValue("Fog", "Fog UI Enabled", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Player Shot Drowsy", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Recoil", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Enable Recoil", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Recoil Pitch", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Recoil Yaw", dictionary) | RemoveLegacyConfigEntryValue("Weapon", "Recoil Max Angle", dictionary) | RemoveLegacyConfigEntryValue("Features", "Recoil", dictionary) | RemoveLegacyConfigEntryValue("Features", "Enable Recoil", dictionary) | RemoveLegacyConfigEntryValue("Hotkeys", "Toggle Mod", dictionary)))
				{
					ConfigFile config = ((BaseUnityPlugin)this).Config;
					if (config != null)
					{
						config.Save();
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] MigrateFeatureConfigDefinitions failed: " + DescribeReflectionException(ex)));
			}
		}

		private bool MigrateCurrentConfigEntryAliases(IDictionary orphanedEntries)
		{
			if (orphanedEntries == null)
			{
				return false;
			}
			bool flag = false;
			ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config);
			foreach (ConfigEntryBase val in configEntriesSnapshot)
			{
				if (val != null && !(val.Definition == (ConfigDefinition)null))
				{
					string modConfigSectionForEntry = GetModConfigSectionForEntry(val);
					string text = NormalizeConfigKeyAlias(val.Definition.Key);
					if (!string.IsNullOrWhiteSpace(modConfigSectionForEntry) && !string.IsNullOrWhiteSpace(text))
					{
						flag |= MigrateLegacyConfigEntryValue(val, modConfigSectionForEntry, text, orphanedEntries);
					}
				}
			}
			return flag;
		}

		private static bool MigrateLegacyConfigEntryValue(ConfigEntryBase target, string legacySection, string legacyKey, IDictionary orphanedEntries)
		{
			if (target == null || orphanedEntries == null || string.IsNullOrWhiteSpace(legacySection) || string.IsNullOrWhiteSpace(legacyKey))
			{
				return false;
			}
			foreach (ConfigDefinition item in BuildConfigDefinitionAliases(legacySection, legacyKey))
			{
				if (orphanedEntries.Contains(item))
				{
					object obj = orphanedEntries[item];
					if (obj != null)
					{
						target.SetSerializedValue(obj.ToString());
					}
					orphanedEntries.Remove(item);
					return true;
				}
			}
			return false;
		}

		private static bool RemoveLegacyConfigEntryValue(string legacySection, string legacyKey, IDictionary orphanedEntries)
		{
			if (orphanedEntries == null)
			{
				return false;
			}
			bool result = false;
			foreach (ConfigDefinition item in BuildConfigDefinitionAliases(legacySection, legacyKey))
			{
				if (orphanedEntries.Contains(item))
				{
					orphanedEntries.Remove(item);
					result = true;
				}
			}
			return result;
		}

		[IteratorStateMachine(typeof(<BuildConfigDefinitionAliases>d__133))]
		private static IEnumerable<ConfigDefinition> BuildConfigDefinitionAliases(string section, string key)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BuildConfigDefinitionAliases>d__133(-2)
			{
				<>3__section = section,
				<>3__key = key
			};
		}

		private static string GetLocalizedSectionDescriptionCore(string section, bool isChinese)
		{
			switch (NormalizeSectionAlias(section))
			{
			case "General":
				if (!isChinese)
				{
					return "General settings.";
				}
				return "通用设置。";
			case "Weapon":
				if (!isChinese)
				{
					return "AK presentation, firing, audio, and held-model settings.";
				}
				return "AK 外观替换、射击、音效与手持模型设置。";
			case "Zombie":
				if (!isChinese)
				{
					return "Zombie max count, per-wave spawn count, health, spawn timing, destroy range, and behavior settings including targeting, sprinting, lunging, and wake-up rules.";
				}
				return "僵尸最大数量、每波生成数量、生命值、生成间隔、销毁范围，以及索敌、冲刺、猛扑和唤醒相关设置。";
			case "Zombie Spawn":
				if (!isChinese)
				{
					return "Internal auto-derived spawn parameters used by the zombie system. They are not meant to be a second player-facing configuration set.";
				}
				return "僵尸生成系统自动派生出的内部参数缓存。正常不需要调整，也不代表第二套玩家配置。";
			case "Features":
				if (!isChinese)
				{
					return "Master toggles and shared world-rule settings.";
				}
				return "模组总开关与共享环境规则。";
			default:
				return string.Empty;
			}
		}

		private static string GetLocalizedKeyNameCore(string key, bool isChinese)
		{
			switch (NormalizeConfigKeyAlias(key))
			{
			case "Fire Interval":
				if (!isChinese)
				{
					return "Fire Interval (s)";
				}
				return "射击间隔（秒）";
			case "Fire Volume":
				if (!isChinese)
				{
					return "Shot Volume";
				}
				return "射击音量";
			case "Weapon Model X Rotation":
				if (!isChinese)
				{
					return "Held Model X Rotation";
				}
				return "手持模型X轴旋转";
			case "Weapon Model Y Rotation":
				if (!isChinese)
				{
					return "Held Model Yaw";
				}
				return "手持模型Y轴旋转";
			case "Weapon Model Z Rotation":
				if (!isChinese)
				{
					return "Held Model Z Rotation";
				}
				return "手持模型Z轴旋转";
			case "Weapon Model Scale":
				if (!isChinese)
				{
					return "Held Model Scale";
				}
				return "手持模型缩放";
			case "Weapon Model X Position":
				if (!isChinese)
				{
					return "Held Model X";
				}
				return "手持模型X位置";
			case "Weapon Model Y Position":
				if (!isChinese)
				{
					return "Held Model Y";
				}
				return "手持模型Y位置";
			case "Weapon Model Z Position":
				if (!isChinese)
				{
					return "Held Model Z";
				}
				return "手持模型Z位置";
			case "AK Sound":
				if (!isChinese)
				{
					return "AK Fire Sound";
				}
				return "AK射击音效";
			case "Weapon Selection":
				if (!isChinese)
				{
					return "Weapon Selection";
				}
				return "武器选择";
			case "Max Distance":
				if (!isChinese)
				{
					return "Hit Scan Distance";
				}
				return "命中检测距离";
			case "Bullet Size":
				if (!isChinese)
				{
					return "Hit Scan Radius";
				}
				return "命中检测半径";
			case "Zombie Time Reduction":
				if (!isChinese)
				{
					return "Damage";
				}
				return "伤害";
			case "Mod":
				if (!isChinese)
				{
					return "Enable Mod";
				}
				return "启用模组";
			case "Weapon":
				if (!isChinese)
				{
					return "Enable Weapon Grants";
				}
				return "启用武器发放";
			case "Spawn Weapon":
				if (!isChinese)
				{
					return "Spawn Weapon Key";
				}
				return "生成武器按键";
			case "Open Config Panel":
				if (!isChinese)
				{
					return "Open Config Panel Key";
				}
				return "打开配置面板按键";
			case "Config Panel Theme":
				if (!isChinese)
				{
					return "Panel Theme";
				}
				return "面板主题";
			case "Zombie Spawn":
				if (!isChinese)
				{
					return "Enable Zombie Spawns";
				}
				return "启用僵尸生成";
			case "Move Speed":
				if (!isChinese)
				{
					return "Move Speed Multiplier";
				}
				return "移动速度倍率";
			case "Aggressiveness":
				if (!isChinese)
				{
					return "Aggro Multiplier";
				}
				return "进攻欲望倍率";
			case "Knockback Force":
				if (!isChinese)
				{
					return "Hit Knockback Force";
				}
				return "命中击退力度";
			case "Max Count":
				if (!isChinese)
				{
					return "Zombie Max Count";
				}
				return "僵尸最大数量";
			case "Spawn Interval":
				if (!isChinese)
				{
					return "Spawn Interval";
				}
				return "生成间隔";
			case "Interval Random":
				if (!isChinese)
				{
					return "Spawn Interval Jitter (Auto)";
				}
				return "生成间隔浮动（自动）";
			case "Spawn Count":
				if (!isChinese)
				{
					return "Spawn Count Per Wave";
				}
				return "每波生成数量";
			case "Count Random":
				if (!isChinese)
				{
					return "Per-Wave Count Jitter (Auto)";
				}
				return "每波数量浮动（自动）";
			case "Spawn Radius":
				if (!isChinese)
				{
					return "Spawn Search Radius (Auto)";
				}
				return "生成搜索半径（自动）";
			case "Max Lifetime":
				if (!isChinese)
				{
					return "Health";
				}
				return "生命值";
			case "Destroy Distance":
				if (!isChinese)
				{
					return "Despawn Range";
				}
				return "销毁范围";
			case "Behavior Difficulty":
				if (!isChinese)
				{
					return "Difficulty";
				}
				return "难度";
			case "Wakeup Distance":
				if (!isChinese)
				{
					return "Wakeup Distance";
				}
				return "唤醒距离";
			case "Chase Distance":
				if (!isChinese)
				{
					return "Chase Distance";
				}
				return "追击距离";
			case "Sprint Distance":
				if (!isChinese)
				{
					return "Sprint Distance";
				}
				return "冲刺距离";
			case "Chase Time":
				if (!isChinese)
				{
					return "Sprint Delay (s)";
				}
				return "冲刺延迟（秒）";
			case "Lunge Distance":
				if (!isChinese)
				{
					return "Lunge Distance";
				}
				return "猛扑距离";
			case "Lunge Time":
				if (!isChinese)
				{
					return "Lunge Duration (s)";
				}
				return "猛扑持续时间（秒）";
			case "Lunge Recovery Time":
				if (!isChinese)
				{
					return "Lunge Recovery (s)";
				}
				return "猛扑恢复时间（秒）";
			case "Wakeup Look Angle":
				if (!isChinese)
				{
					return "Wakeup View Angle (deg)";
				}
				return "唤醒视角（度）";
			case "Target Search Interval":
				if (!isChinese)
				{
					return "Target Refresh Interval (s)";
				}
				return "索敌刷新间隔（秒）";
			case "Bite Recovery Time":
				if (!isChinese)
				{
					return "Post-Bite Recovery (s)";
				}
				return "咬后恢复时间（秒）";
			case "Same Player Bite Cooldown":
				if (!isChinese)
				{
					return "Repeat Bite Cooldown (s)";
				}
				return "同玩家重复咬击冷却（秒）";
			default:
				return key;
			}
		}

		private static string GetLocalizedDescriptionCore(string key, bool isChinese)
		{
			switch (NormalizeConfigKeyAlias(key))
			{
			case "Fire Interval":
				if (!isChinese)
				{
					return "Minimum time between shots. Lower values produce a faster fire rate.";
				}
				return "每次开火之间的最短时间，数值越小，射速越快。";
			case "Fire Volume":
				if (!isChinese)
				{
					return "Playback volume for the AK firing sound. Use 0 to mute it.";
				}
				return "AK 射击音效的播放音量，0 为静音。";
			case "Weapon Model X Rotation":
				if (!isChinese)
				{
					return "Adjusts the held AK rotation around the X axis to correct pitch and upside-down orientation.";
				}
				return "调整手持 AK 围绕握持点的 X 轴旋转，用于修正上下翻转和俯仰方向。";
			case "Weapon Model Y Rotation":
				if (!isChinese)
				{
					return "Adjusts the local AK yaw around the held anchor to correct weapon facing.";
				}
				return "调整手持 AK 围绕握持点的 Y 轴朝向，用于修正枪口方向。";
			case "Weapon Model Z Rotation":
				if (!isChinese)
				{
					return "Adjusts the held AK rotation around the Z axis to correct roll and sideways tilt.";
				}
				return "调整手持 AK 围绕握持点的 Z 轴旋转，用于修正左右倾斜方向。";
			case "Weapon Model Scale":
				if (!isChinese)
				{
					return "Scales the locally displayed AK model used in hand and local presentation.";
				}
				return "调整手持与本地显示用 AK 模型的整体大小。";
			case "Weapon Model X Position":
				if (!isChinese)
				{
					return "Adjusts the left-right local position offset of the held AK.";
				}
				return "调整手持 AK 相对握持点的左右位置偏移。";
			case "Weapon Model Y Position":
				if (!isChinese)
				{
					return "Adjusts the up-down local position offset of the held AK.";
				}
				return "调整手持 AK 相对握持点的上下位置偏移。";
			case "Weapon Model Z Position":
				if (!isChinese)
				{
					return "Adjusts the forward-back local position offset of the held AK.";
				}
				return "调整手持 AK 相对握持点的前后位置偏移。";
			case "AK Sound":
				if (!isChinese)
				{
					return "Selects the AK firing sound from ak_sound1, ak_sound2, and ak_sound3 inside the AK_Sounds folder. Changes apply to the next shot immediately.";
				}
				return "从 AK_Sounds 文件夹中的 ak_sound1、ak_sound2、ak_sound3 里切换射击音效。更改后会立即影响后续射击声音。";
			case "Weapon Selection":
				if (!isChinese)
				{
					return "Selects which weapon model and icon replace the blowgun. This option is local only and is not synchronized to other players.";
				}
				return "选择替换吹箭筒时使用的武器模型与图标。该选项只在本地生效，不会同步给其他玩家。";
			case "default":
				return string.Empty;
			case "Max Distance":
				if (!isChinese)
				{
					return "Maximum distance used by the weapon hit scan.";
				}
				return "射击命中检测的最大距离。";
			case "Bullet Size":
				if (!isChinese)
				{
					return "Hit-scan radius. Slightly larger values make close-range shots feel more forgiving.";
				}
				return "射击检测半径。略微增大可以让近距离手感更稳定。";
			case "Zombie Time Reduction":
				if (!isChinese)
				{
					return "Each hit reduces a zombie's remaining health. Internally this mod models health through remaining lifetime, so higher values kill zombies faster.";
				}
				return "每次命中会削减僵尸的剩余生命值。本模组内部用存活时间来近似生命值，所以数值越大，僵尸死得越快。";
			case "Mod":
				if (!isChinese)
				{
					return "Master switch for the whole mod. Turning it off disables the weapon and zombie systems.";
				}
				return "当前模组总开关。关闭后武器和僵尸相关逻辑都会停止接管。";
			case "Weapon":
				if (!isChinese)
				{
					return "Controls automatic blowgun and first-aid grants and whether the AK replacement logic is active.";
				}
				return "控制大厅/游戏内是否发放吹箭筒与急救包，以及是否启用 AK 替换逻辑。";
			case "Spawn Weapon":
				if (!isChinese)
				{
					return "Local backup hotkey for spawning the weapon if automatic grants fail or for testing.";
				}
				return "本地备用发枪按键，用于测试或在自动发枪失效时补发。";
			case "Open Config Panel":
				if (!isChinese)
				{
					return "Hotkey used in the lobby to open or close the custom configuration panel.";
				}
				return "在大厅中打开或关闭自定义配置面板的按键。";
			case "Config Panel Theme":
				if (!isChinese)
				{
					return "Selects the configuration panel appearance. Supports dark, light, and transparent themes and saves your local choice.";
				}
				return "选择配置面板的外观主题。支持黑色、白色和透明三种版本，并会保存你的本地选择。";
			case "Zombie Spawn":
				if (!isChinese)
				{
					return "Turns the zombie spawn system on or off. Disabling it stops new zombie waves from spawning.";
				}
				return "控制僵尸生成系统是否运行。关闭后不会继续刷出新的僵尸。";
			case "Move Speed":
				if (!isChinese)
				{
					return "Multiplier for zombie base movement speed. A value of 1 matches vanilla speed.";
				}
				return "僵尸基础移动速度倍率。1 为原版速度。";
			case "Aggressiveness":
				if (!isChinese)
				{
					return "Scales how aggressively zombies commit to chasing and keeping pressure on players.";
				}
				return "提高僵尸更积极追击与维持仇恨的倾向。";
			case "Knockback Force":
				if (!isChinese)
				{
					return "Knockback force applied when a zombie is hit by a shot.";
				}
				return "子弹命中僵尸时施加的击退力度。";
			case "Max Count":
				if (!isChinese)
				{
					return "Maximum number of zombies allowed to stay alive at the same time. No matter how many a wave tries to spawn, the live total never exceeds this cap.";
				}
				return "同一时间允许存在的僵尸上限。无论每波生成多少，场上总数都不会超过这个值。";
			case "Spawn Interval":
				if (!isChinese)
				{
					return "Base delay between zombie spawn waves. The system automatically adds a few seconds of jitter around this value.";
				}
				return "两次僵尸生成波之间的基础时间间隔。系统会围绕这个值自动上下浮动几秒。";
			case "Interval Random":
				if (!isChinese)
				{
					return "An internal jitter value derived from the spawn interval so waves do not feel too rigid. It is not a separate player-facing setting.";
				}
				return "由生成间隔自动推导出的内部浮动值，用来让刷怪节奏不那么死板；它不是单独的玩家配置项。";
			case "Spawn Count":
				if (!isChinese)
				{
					return "Each wave attempts to spawn this many zombies. If the current live total plus the next wave would exceed the zombie max count, the wave is automatically capped to the remaining capacity.";
				}
				return "每一波会尝试生成该数量的僵尸。若当前场上僵尸加上下一波会超过僵尸最大数量，则会自动把本波数量压到剩余容量。";
			case "Count Random":
				if (!isChinese)
				{
					return "An internal jitter value derived from the per-wave spawn count so waves are not perfectly fixed. It is not a second count setting.";
				}
				return "由每波生成数量自动推导出的内部浮动值，用来避免每一波都完全固定；它不是第二套数量配置。";
			case "Spawn Radius":
				if (!isChinese)
				{
					return "An internal search radius derived from the current zombie settings and used to find suitable spawn points. It is not a separate player-facing setting.";
				}
				return "由当前僵尸设置自动推导出的内部搜索半径，用来寻找合适刷怪点；它不是单独的玩家配置项。";
			case "Max Lifetime":
				if (!isChinese)
				{
					return "Base health for an individual zombie. Internally this mod represents it through maximum lifetime, so higher values make zombies harder to kill.";
				}
				return "单个僵尸的基础生命值。本模组内部用最长存活时间来表示，所以数值越大，僵尸越耐打。";
			case "Destroy Distance":
				if (!isChinese)
				{
					return "A zombie is destroyed when it is farther than this distance from every player.";
				}
				return "当僵尸与所有玩家的距离都超过该值时，会被直接销毁。";
			case "Behavior Difficulty":
				if (!isChinese)
				{
					return "Five behavior presets. The first Easy preset keeps vanilla lunge, post-bite recovery, and bite cadence, while spawned zombies still wake and pursue promptly so they do not stand idle for long periods. The remaining four presets progressively tighten target-search cadence, post-bite recovery, sprint and chase timing, lunge distance/duration/recovery, plus wake-up angle and distance; those enhanced presets still clamp lunges back down to close range so zombies do not keep sliding into long-range pounces. Easy is the default.";
				}
				return "五档行为预设。第一档简单保留原版扑击、咬后恢复和咬人节奏，但对刷出的僵尸保持及时唤醒与追击，避免长时间站立。后四档会逐步提高索敌频率、咬后恢复、追击冲刺、猛扑距离/持续/恢复，以及唤醒角度和唤醒距离；这些增强档仍会把猛扑收紧在近身范围，避免远距离滑扑。默认是第一档简单。";
			case "Wakeup Distance":
				if (!isChinese)
				{
					return "Distance at which zombies wake up and become active.";
				}
				return "僵尸开始被激活的距离。";
			case "Chase Distance":
				if (!isChinese)
				{
					return "Distance at which zombies commit to chasing players. Set this to 0 for immediate pursuit once a target is found.";
				}
				return "僵尸开始稳定追击玩家的距离。设为 0 表示一旦锁定目标就立刻追击。";
			case "Sprint Distance":
				if (!isChinese)
				{
					return "Distance threshold that allows zombies to enter sprint pursuit.";
				}
				return "僵尸进入冲刺追击所需的距离阈值。";
			case "Chase Time":
				if (!isChinese)
				{
					return "How long a zombie must chase before sprinting is allowed. Set this to 0 to allow immediate sprinting once distance conditions are met.";
				}
				return "僵尸追击玩家多久后允许进入冲刺。设为 0 可在满足距离条件时立即冲刺。";
			case "Lunge Distance":
				if (!isChinese)
				{
					return "Distance at which zombies can trigger their close-range lunge attack. The default has been restored near vanilla, with a practical range of 4 to 20.";
				}
				return "僵尸触发近身猛扑攻击的距离。默认值已调回接近原版，常用范围为 4 到 20。";
			case "Lunge Time":
				if (!isChinese)
				{
					return "How long zombies stay in the lunging state. Higher values extend the forward pressure window.";
				}
				return "僵尸维持猛扑动作的持续时间。数值越大，突进压迫感越强。";
			case "Lunge Recovery Time":
				if (!isChinese)
				{
					return "How long regular lunge recovery lasts before the zombie can resume chasing.";
				}
				return "普通猛扑结束后，僵尸恢复到继续追击所需的时间。";
			case "Wakeup Look Angle":
				if (!isChinese)
				{
					return "Maximum facing angle that still allows players looking toward the zombie to trigger wake-up.";
				}
				return "玩家面向僵尸时，允许触发唤醒判定的最大视角。";
			case "Target Search Interval":
				if (!isChinese)
				{
					return "How often zombies refresh their nearest-target search. Lower values make them reacquire and swap targets more quickly.";
				}
				return "僵尸重新搜索最近目标的时间间隔。数值越小，越容易快速重新锁定或换目标。";
			case "Bite Recovery Time":
				if (!isChinese)
				{
					return "How long a zombie takes to recover after successfully biting a player. Lower values keep pressure on players much more consistently.";
				}
				return "僵尸成功咬到玩家后，自身恢复到继续追击所需的时间。数值越小，连续压迫越强。";
			case "Same Player Bite Cooldown":
				if (!isChinese)
				{
					return "How long the same zombie must wait before it can bite the same player again. Lower values make repeated bites much more dangerous.";
				}
				return "同一只僵尸再次咬到同一名玩家前必须等待的时间。数值越小，连咬威胁越高。";
			default:
				return string.Empty;
			}
		}

		private void RefreshRealModConfigUi()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			try
			{
				if (!((Object)GameHandler.Instance == (Object)null) && Chainloader.PluginInfos.TryGetValue("com.github.PEAKModding.PEAKLib.ModConfig", out var value) && (Object)((value != null) ? value.Instance : null) != (Object)null)
				{
					Type type = ((object)value.Instance).GetType();
					(type.GetProperty("EntriesProcessed", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) as IList)?.Clear();
					(type.GetProperty("ModdedKeys", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) as IList)?.Clear();
					(type.GetProperty("GetValidKeyPaths", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) as IList)?.Clear();
					type.GetMethod("GenerateValidKeyPaths", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(null, null);
					type.GetMethod("ProcessModEntries", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(null, null);
					type.GetMethod("LoadModSettings", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(null, null);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RefreshRealModConfigUi cache refresh failed: " + DescribeReflectionException(ex)));
			}
		}

		private void PatchModConfigUiMethods(Harmony harmony)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			if (harmony == null)
			{
				return;
			}
			try
			{
				Type type = ResolveLoadedType("PEAKLib.ModConfig.Components.ModdedSettingsMenu", "com.github.PEAKModding.PEAKLib.ModConfig");
				if (type == null)
				{
					return;
				}
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ModConfigMenuUiChangedPostfix", (Type[])null, (Type[])null));
				string[] array = new string[1] { "OnEnable" };
				foreach (string name in array)
				{
					MethodInfo[] array2 = (from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
						where string.Equals(m.Name, name, StringComparison.Ordinal)
						select m).ToArray();
					foreach (MethodInfo methodInfo in array2)
					{
						harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
				}
				MethodInfo methodInfo2 = AccessTools.Method(type, "ShowSettings", new Type[1] { typeof(string) }, (Type[])null);
				HarmonyMethod val2 = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ModConfigShowSettingsPrefix", (Type[])null, (Type[])null));
				HarmonyMethod val3 = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ModConfigShowSettingsPostfix", (Type[])null, (Type[])null));
				if (methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo2, val2, val3, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo3 = AccessTools.Method(type, "UpdateSectionTabs", new Type[1] { typeof(string) }, (Type[])null);
				HarmonyMethod val4 = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ModConfigUpdateSectionTabsPrefix", (Type[])null, (Type[])null));
				if (methodInfo3 != null)
				{
					harmony.Patch((MethodBase)methodInfo3, val4, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo4 = AccessTools.Method(type, "SetSection", new Type[1] { typeof(string) }, (Type[])null);
				HarmonyMethod val5 = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ModConfigSetSectionPrefix", (Type[])null, (Type[])null));
				if (methodInfo4 != null)
				{
					harmony.Patch((MethodBase)methodInfo4, val5, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo5 = AccessTools.Method(type.Assembly.GetType("PEAKLib.ModConfig.Components.ModdedTABSButton"), "Update", Type.EmptyTypes, (Type[])null);
				HarmonyMethod val6 = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ModConfigTabsButtonUpdatePostfix", (Type[])null, (Type[])null));
				if (methodInfo5 != null)
				{
					harmony.Patch((MethodBase)methodInfo5, (HarmonyMethod)null, val6, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				PatchModConfigSettingOptionMethods(harmony, type.Assembly);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] PatchModConfigUiMethods failed: " + DescribeReflectionException(ex)));
			}
		}

		private void PatchModConfigSettingOptionMethods(Harmony harmony, Assembly assembly)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (harmony == null || assembly == null)
			{
				return;
			}
			HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "ModConfigGetDisplayNamePostfix", (Type[])null, (Type[])null));
			foreach (Type item in from t in GetLoadableTypes(assembly)
				where t != null && !t.IsAbstract && !t.IsInterface && !string.IsNullOrWhiteSpace(t.FullName) && t.FullName.StartsWith("PEAKLib.ModConfig.SettingOptions.BepInEx", StringComparison.Ordinal)
				select t)
			{
				MethodInfo methodInfo = AccessTools.Method(item, "GetDisplayName", Type.EmptyTypes, (Type[])null);
				if (methodInfo != null)
				{
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void ModConfigMenuUiChangedPostfix(object __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)Instance != (Object)null && IsModConfigUiRuntimeSafe())
			{
				Instance.LocalizeModConfigUiNextFrame(__instance);
			}
		}

		private static void ModConfigShowSettingsPostfix(object __instance, string __0)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)Instance == (Object)null || !IsModConfigUiRuntimeSafe())
			{
				return;
			}
			string text = NormalizeModConfigContextName(__0);
			if (!string.IsNullOrWhiteSpace(__0))
			{
				Instance._activeModConfigName = text;
			}
			else if (__instance != null)
			{
				string selectedModConfigCategory = GetSelectedModConfigCategory(__instance, __instance.GetType());
				if (!string.IsNullOrWhiteSpace(selectedModConfigCategory))
				{
					Instance._activeModConfigName = selectedModConfigCategory;
				}
			}
			string modName = (string.IsNullOrWhiteSpace(text) ? NormalizeModConfigContextName(Instance._activeModConfigName) : text);
			if (!Instance.IsOwnedModConfigName(modName))
			{
				Instance.StopOwnedModConfigStabilizer(restoreRuntimeState: true);
			}
			else
			{
				Instance.LocalizeModConfigUiNextFrame(__instance);
			}
		}

		private static void ModConfigShowSettingsPrefix(object __instance, string __0)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)Instance == (Object)null || __instance == null)
			{
				return;
			}
			try
			{
				string text = NormalizeModConfigContextName(__0);
				if (!string.IsNullOrWhiteSpace(text))
				{
					Instance._activeModConfigName = text;
					if (!Instance.IsOwnedModConfigName(text))
					{
						Instance.StopOwnedModConfigStabilizer(restoreRuntimeState: true);
						return;
					}
				}
				Type type = __instance.GetType();
				CleanupDestroyedModConfigCells(__instance, type);
				if (Instance.IsOwnedModConfigName(Instance._activeModConfigName))
				{
					Instance.NormalizeOwnedModConfigSections(type.Assembly, __instance, type);
					Instance.EnsureOwnedModConfigEntriesRegistered(type);
				}
				else
				{
					Instance.StopOwnedModConfigStabilizer(restoreRuntimeState: true);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] ModConfigShowSettingsPrefix cleanup failed: " + DescribeReflectionException(ex)));
			}
		}

		private static bool ModConfigUpdateSectionTabsPrefix(object __instance, string __0)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)Instance == (Object)null)
			{
				return true;
			}
			try
			{
				string text = NormalizeLocalizedText(__0).Trim();
				if (!string.IsNullOrWhiteSpace(text))
				{
					Instance._activeModConfigName = text;
				}
				else if (__instance != null)
				{
					string selectedModConfigCategory = GetSelectedModConfigCategory(__instance, __instance.GetType());
					if (!string.IsNullOrWhiteSpace(selectedModConfigCategory))
					{
						Instance._activeModConfigName = selectedModConfigCategory;
					}
				}
				if (!Instance.IsOwnedModConfigName(Instance._activeModConfigName))
				{
					Instance.StopOwnedModConfigStabilizer(restoreRuntimeState: true);
					return true;
				}
				if (__instance != null && Instance.IsOwnedModConfigName(Instance._activeModConfigName))
				{
					Instance.NormalizeOwnedModConfigSections(__instance.GetType().Assembly, __instance, __instance.GetType());
				}
			}
			catch
			{
			}
			return true;
		}

		private static bool ModConfigSetSectionPrefix(object __instance, ref string __0)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)Instance == (Object)null || __instance == null)
			{
				return true;
			}
			try
			{
				Type type = __instance.GetType();
				string selectedModConfigCategory = GetSelectedModConfigCategory(__instance, type);
				if (!string.IsNullOrWhiteSpace(selectedModConfigCategory))
				{
					Instance._activeModConfigName = selectedModConfigCategory;
				}
				if (!Instance.IsOwnedModConfigName(Instance._activeModConfigName))
				{
					Instance.StopOwnedModConfigStabilizer(restoreRuntimeState: true);
					return true;
				}
				if (Instance.IsOwnedModConfigName(Instance._activeModConfigName) && TryGetOwnedCanonicalSectionName(__0, out var canonicalSectionName) && !string.IsNullOrWhiteSpace(canonicalSectionName))
				{
					__0 = canonicalSectionName;
					FieldInfo field = type.GetField("selectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						field.SetValue(__instance, canonicalSectionName);
					}
					else
					{
						PropertyInfo propertyInfo = type.GetProperty("selectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? type.GetProperty("SelectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (propertyInfo != null && propertyInfo.CanWrite)
						{
							propertyInfo.SetValue(__instance, canonicalSectionName, null);
						}
					}
				}
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] ModConfigSetSectionPrefix failed: " + DescribeReflectionException(ex)));
				return true;
			}
		}

		private static void CleanupDestroyedModConfigCells(object menuInstance, Type menuType)
		{
			if (menuInstance == null || menuType == null)
			{
				return;
			}
			try
			{
				if (!(GetFieldInHierarchy(menuType, "m_spawnedCells")?.GetValue(menuInstance) is IList list))
				{
					return;
				}
				for (int num = list.Count - 1; num >= 0; num--)
				{
					object obj = list[num];
					if (obj == null)
					{
						list.RemoveAt(num);
					}
					else
					{
						Object val = (Object)((obj is Object) ? obj : null);
						if (val != null && val == (Object)null)
						{
							list.RemoveAt(num);
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void ModConfigGetDisplayNamePostfix(object __instance, ref string __result)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (IsOwnedConfigEntry(TryGetConfigEntryBaseFromSettingOption(__instance)))
			{
				bool isChinese = (Object)Instance != (Object)null && Instance.IsChineseLanguage();
				string canonicalConfigKey = GetCanonicalConfigKey(__instance);
				string displayName;
				if (!string.IsNullOrWhiteSpace(canonicalConfigKey))
				{
					__result = GetLocalizedKeyName(canonicalConfigKey, isChinese);
				}
				else if (TryGetLocalizedOwnedConfigDisplayName(__result, isChinese, out displayName))
				{
					__result = displayName;
				}
				else
				{
					__result = LocalizeModConfigText(__result);
				}
			}
		}

		private static void ModConfigTabsButtonUpdatePostfix(object __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			if ((Object)Instance == (Object)null || __instance == null)
			{
				return;
			}
			try
			{
				Type type = __instance.GetType();
				FieldInfo field = type.GetField("category", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				FieldInfo? field2 = type.GetField("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				string text = field?.GetValue(__instance) as string;
				object obj = field2?.GetValue(__instance);
				TMP_Text val = (TMP_Text)((obj is TMP_Text) ? obj : null);
				Component val2 = (Component)((__instance is Component) ? __instance : null);
				Component val3 = ((val2 != null) ? val2 : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				string text2 = ((!string.IsNullOrWhiteSpace(text)) ? text : val.text);
				bool flag = false;
				if (TryGetModConfigMenuInstance(out var menuType, out var menuInstance))
				{
					flag = IsOwnedModConfigContext(menuInstance, menuType);
				}
				if (!ShouldLocalizeOwnedModConfigButton(text2, flag))
				{
					return;
				}
				if (flag && TryGetOwnedCanonicalSectionName(text2, out var canonicalSectionName) && !string.IsNullOrWhiteSpace(canonicalSectionName))
				{
					if (field != null && !string.Equals(text, canonicalSectionName, StringComparison.Ordinal))
					{
						field.SetValue(__instance, canonicalSectionName);
						text = canonicalSectionName;
					}
					if ((Object)(object)val3 != (Object)null && !string.Equals(((Object)val3.gameObject).name, canonicalSectionName, StringComparison.Ordinal))
					{
						((Object)val3.gameObject).name = canonicalSectionName;
					}
					text2 = canonicalSectionName;
				}
				string displayName;
				string text3 = (TryGetLocalizedSectionDisplayName(text2, Instance.IsChineseLanguage(), out displayName) ? displayName : LocalizeModConfigText(text2));
				if (!string.IsNullOrWhiteSpace(text3) && !string.Equals(val.text, text3, StringComparison.Ordinal))
				{
					val.text = text3;
				}
			}
			catch
			{
			}
		}

		private void LocalizeModConfigUiNextFrame(object menuInstance)
		{
			if (IsModConfigUiRuntimeSafe())
			{
				string text = NormalizeModConfigContextName(_activeModConfigName);
				if (!IsOwnedModConfigName(text))
				{
					StopOwnedModConfigStabilizer();
				}
				else if (_lastLocalizedModConfigUiFrame != Time.frameCount)
				{
					_lastLocalizedModConfigUiFrame = Time.frameCount;
					((MonoBehaviour)this).StartCoroutine(LocalizeModConfigUiCoroutine(menuInstance, text));
				}
			}
		}

		[IteratorStateMachine(typeof(<LocalizeModConfigUiCoroutine>d__149))]
		private IEnumerator LocalizeModConfigUiCoroutine(object menuInstance, string ownerModName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LocalizeModConfigUiCoroutine>d__149(0)
			{
				<>4__this = this,
				menuInstance = menuInstance,
				ownerModName = ownerModName
			};
		}

		private void TryLocalizeVisibleModConfigUi(object menuInstance = null, string ownerModName = null)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (!IsModConfigUiRuntimeSafe())
			{
				return;
			}
			if (!TryGetModConfigMenuInstance(out var menuType, out var menuInstance2))
			{
				if (menuInstance == null)
				{
					return;
				}
				menuInstance2 = menuInstance;
				menuType = menuInstance.GetType();
			}
			Behaviour val = (Behaviour)((menuInstance2 is Behaviour) ? menuInstance2 : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				if (!val.isActiveAndEnabled || !((Component)val).gameObject.activeInHierarchy)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			bool isChinese = IsChineseLanguage();
			SyncActiveModConfigName(menuInstance2, menuType);
			if (!string.IsNullOrWhiteSpace(ownerModName) && !IsOwnedModConfigContextStillValid(ownerModName))
			{
				StopOwnedModConfigStabilizer();
				return;
			}
			if (!IsOwnedModConfigName(_activeModConfigName))
			{
				StopOwnedModConfigStabilizer();
				return;
			}
			EnsureOwnedModConfigEntriesRegistered(menuType);
			EnsureOwnedModConfigStabilizer(menuInstance2);
			if (NeedsOwnedModConfigSectionRebuild(menuInstance2, menuType))
			{
				RepairOwnedModConfigSections(menuInstance2, menuType);
			}
			RepairOwnedModConfigState(menuInstance2, menuType);
			NormalizeOwnedSectionTabCategories(menuInstance2, menuType, isChinese);
			LocalizeOwnedModConfigSectionTabs(menuInstance2, menuType, isChinese);
			Dictionary<string, string> map = BuildModConfigUiLocalizationMap(isChinese);
			foreach (Transform item in EnumerateModConfigUiRoots(menuInstance2, menuType))
			{
				ApplyTextLocalizationToRoot(item, map);
			}
		}

		private void EnsureOwnedModConfigStabilizer(object menuInstance)
		{
			string text = NormalizeModConfigContextName(_activeModConfigName);
			if (!IsOwnedModConfigName(text))
			{
				StopOwnedModConfigStabilizer();
				return;
			}
			if (_modConfigStabilizeCoroutine != null)
			{
				if (string.Equals(_modConfigStabilizeOwnerName, text, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
				StopOwnedModConfigStabilizer();
			}
			_modConfigStabilizeOwnerName = text;
			_modConfigStabilizeCoroutine = ((MonoBehaviour)this).StartCoroutine(StabilizeOwnedModConfigUiCoroutine(menuInstance, text));
		}

		private static string NormalizeModConfigContextName(string modName)
		{
			return NormalizeLocalizedText(modName).Trim();
		}

		private bool IsOwnedModConfigContextStillValid(string ownerModName)
		{
			ownerModName = NormalizeModConfigContextName(ownerModName);
			if (string.IsNullOrWhiteSpace(ownerModName) || !IsOwnedModConfigName(ownerModName))
			{
				return false;
			}
			string text = NormalizeModConfigContextName(_activeModConfigName);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return string.Equals(text, ownerModName, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private void StopOwnedModConfigStabilizer(bool restoreRuntimeState = false)
		{
			bool flag = _modConfigStabilizeCoroutine != null || !string.IsNullOrWhiteSpace(_modConfigStabilizeOwnerName);
			if (_modConfigStabilizeCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_modConfigStabilizeCoroutine);
				_modConfigStabilizeCoroutine = null;
			}
			_modConfigStabilizeOwnerName = string.Empty;
			if (restoreRuntimeState && flag)
			{
				RefreshRealModConfigUi();
			}
		}

		[IteratorStateMachine(typeof(<StabilizeOwnedModConfigUiCoroutine>d__155))]
		private IEnumerator StabilizeOwnedModConfigUiCoroutine(object menuInstance, string ownerModName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StabilizeOwnedModConfigUiCoroutine>d__155(0)
			{
				<>4__this = this,
				menuInstance = menuInstance,
				ownerModName = ownerModName
			};
		}

		private void RepairOwnedModConfigSections(object menuInstance, Type menuType)
		{
			if (_repairingModConfigUi || menuInstance == null || menuType == null || !IsOwnedModConfigName(_activeModConfigName))
			{
				return;
			}
			try
			{
				string text = ResolveOwnedModConfigLookupName(menuType.Assembly, menuInstance, menuType);
				bool num = NormalizeOwnedModConfigSections(menuType.Assembly, menuInstance, menuType);
				bool flag = GetOwnedSectionTabCount(menuInstance, menuType) != GetCurrentCanonicalSections().Count;
				if (num || flag)
				{
					_repairingModConfigUi = true;
					_activeModConfigName = text ?? _activeModConfigName;
					MethodInfo method = menuType.GetMethod("UpdateSectionTabs", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
					if (method != null && !string.IsNullOrWhiteSpace(_activeModConfigName))
					{
						method.Invoke(menuInstance, new object[1] { _activeModConfigName });
						ForceOwnedSectionTabLayoutRefresh(menuInstance, menuType);
						NormalizeOwnedSectionTabCategories(menuInstance, menuType, IsChineseLanguage());
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RepairOwnedModConfigSections failed: " + ex.Message));
			}
			finally
			{
				_repairingModConfigUi = false;
			}
		}

		private static bool TryGetModConfigMenuInstance(out Type menuType, out object menuInstance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			menuType = null;
			menuInstance = null;
			if (!Chainloader.PluginInfos.TryGetValue("com.github.PEAKModding.PEAKLib.ModConfig", out var value) || (Object)((value != null) ? value.Instance : null) == (Object)null)
			{
				return false;
			}
			Assembly assembly = ((object)value.Instance).GetType().Assembly;
			menuType = assembly.GetType("PEAKLib.ModConfig.Components.ModdedSettingsMenu") ?? ResolveLoadedType("PEAKLib.ModConfig.Components.ModdedSettingsMenu", "com.github.PEAKModding.PEAKLib.ModConfig");
			menuInstance = menuType?.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null);
			if (menuType != null)
			{
				return menuInstance != null;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<EnumerateModConfigUiRoots>d__158))]
		private IEnumerable<Transform> EnumerateModConfigUiRoots(object menuInstance, Type menuType)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateModConfigUiRoots>d__158(-2)
			{
				<>4__this = this,
				<>3__menuInstance = menuInstance,
				<>3__menuType = menuType
			};
		}

		[IteratorStateMachine(typeof(<EnumerateCandidateTransforms>d__159))]
		private IEnumerable<Transform> EnumerateCandidateTransforms(object menuInstance, Type menuType)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateCandidateTransforms>d__159(-2)
			{
				<>3__menuInstance = menuInstance,
				<>3__menuType = menuType
			};
		}

		private bool NeedsOwnedModConfigSectionRebuild(object menuInstance, Type menuType)
		{
			if (menuInstance == null || menuType == null || !IsOwnedModConfigName(_activeModConfigName))
			{
				return false;
			}
			int count = GetCurrentCanonicalSections().Count;
			if (count <= 0)
			{
				return false;
			}
			int ownedSectionTabCount = GetOwnedSectionTabCount(menuInstance, menuType);
			if (ownedSectionTabCount > 0 && ownedSectionTabCount >= count)
			{
				return ownedSectionTabCount > count;
			}
			return true;
		}

		private static int GetOwnedSectionTabCount(object menuInstance, Type menuType)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if (menuInstance == null || menuType == null)
			{
				return 0;
			}
			try
			{
				object obj = menuType.GetField("SectionTabController", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
				Component val = (Component)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return 0;
				}
				Type type = menuType.Assembly.GetType("PEAKLib.ModConfig.Components.ModdedTABSButton");
				return (type != null) ? val.GetComponentsInChildren(type, true).Length : 0;
			}
			catch
			{
				return 0;
			}
		}

		private static void ForceOwnedSectionTabLayoutRefresh(object menuInstance, Type menuType)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			if (menuInstance == null || menuType == null)
			{
				return;
			}
			try
			{
				object obj = menuType.GetField("SectionTabController", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
				Component val = (Component)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Canvas.ForceUpdateCanvases();
				RectTransform[] componentsInParent = val.GetComponentsInParent<RectTransform>(true);
				foreach (RectTransform val2 in componentsInParent)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						LayoutRebuilder.ForceRebuildLayoutImmediate(val2);
					}
				}
				RectTransform component = val.GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(component);
				}
				Canvas.ForceUpdateCanvases();
			}
			catch
			{
			}
		}

		private static void LocalizeOwnedModConfigSectionTabs(object menuInstance, Type menuType, bool isChinese)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			if (menuInstance == null || menuType == null)
			{
				return;
			}
			try
			{
				object obj = menuType.GetField("SectionTabController", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
				Component val = (Component)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				TMP_Text[] componentsInChildren = val.GetComponentsInChildren<TMP_Text>(true);
				foreach (TMP_Text val2 in componentsInChildren)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					string text = NormalizeLocalizedText(val2.text).Trim();
					if (!string.IsNullOrWhiteSpace(text) && TryGetOwnedCanonicalSectionName(text, out var canonicalSectionName))
					{
						string displayName;
						string text2 = (TryGetLocalizedSectionDisplayName(canonicalSectionName, isChinese, out displayName) ? displayName : GetLocalizedSectionName(canonicalSectionName, isChinese));
						if (!string.IsNullOrWhiteSpace(text2) && !string.Equals(val2.text, text2, StringComparison.Ordinal))
						{
							val2.text = text2;
						}
					}
				}
			}
			catch
			{
			}
		}

		private void RepairOwnedModConfigState(object menuInstance, Type menuType)
		{
			if (_repairingModConfigUi || menuInstance == null || menuType == null || !IsOwnedModConfigName(_activeModConfigName))
			{
				return;
			}
			try
			{
				bool isChinese = IsChineseLanguage();
				bool num = FilterHiddenOwnedModConfigRows(menuInstance, menuType);
				DeduplicateVisibleOwnedModConfigRows(menuInstance, menuType);
				bool flag = NormalizeOwnedSectionTabCategories(menuInstance, menuType, isChinese);
				bool flag2 = NormalizeOwnedModConfigSelectedSection(menuInstance, menuType);
				bool flag3 = NeedsOwnedModConfigContentRefresh(menuInstance, menuType);
				if (!(num || flag || flag2 || flag3))
				{
					return;
				}
				_repairingModConfigUi = true;
				string text = GetSelectedModConfigCategory(menuInstance, menuType);
				if (string.IsNullOrWhiteSpace(text))
				{
					text = _activeModConfigName;
				}
				if (!TryGetOwnedCanonicalSectionName(GetSelectedModConfigSection(menuInstance, menuType), out var canonicalSectionName))
				{
					canonicalSectionName = GetCurrentCanonicalSections().FirstOrDefault();
				}
				if (flag3)
				{
					menuType.GetMethod("RefreshSettings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(menuInstance, null);
					FieldInfo field = menuType.GetField("selectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (!string.IsNullOrWhiteSpace(canonicalSectionName) && field != null)
					{
						field.SetValue(menuInstance, canonicalSectionName);
					}
					MethodInfo method = menuType.GetMethod("ShowSettings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
					if (method != null && !string.IsNullOrWhiteSpace(text))
					{
						method.Invoke(menuInstance, new object[1] { text });
					}
					else if (!string.IsNullOrWhiteSpace(canonicalSectionName))
					{
						SetSelectedModConfigSection(menuInstance, menuType, canonicalSectionName);
					}
				}
				else if (!string.IsNullOrWhiteSpace(canonicalSectionName))
				{
					SetSelectedModConfigSection(menuInstance, menuType, canonicalSectionName);
				}
				CleanupDestroyedModConfigCells(menuInstance, menuType);
				FilterHiddenOwnedModConfigRows(menuInstance, menuType);
				DeduplicateVisibleOwnedModConfigRows(menuInstance, menuType);
				NormalizeOwnedSectionTabCategories(menuInstance, menuType, isChinese);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RepairOwnedModConfigState failed: " + ex.Message));
			}
			finally
			{
				_repairingModConfigUi = false;
			}
		}

		private bool NeedsOwnedModConfigContentRefresh(object menuInstance, Type menuType)
		{
			if (menuInstance == null || menuType == null || !IsOwnedModConfigName(_activeModConfigName))
			{
				return false;
			}
			if (!TryGetOwnedCanonicalSectionName(GetSelectedModConfigSection(menuInstance, menuType), out var canonicalSectionName))
			{
				canonicalSectionName = GetCurrentCanonicalSections().FirstOrDefault();
			}
			int expectedOwnedModConfigEntryCount = GetExpectedOwnedModConfigEntryCount(menuInstance, menuType);
			if (expectedOwnedModConfigEntryCount <= 0)
			{
				return false;
			}
			int contentVisibleOwnedSettingsCellCount = GetContentVisibleOwnedSettingsCellCount(menuInstance, menuType, canonicalSectionName);
			int modConfigContentChildCount = GetModConfigContentChildCount(menuInstance, menuType);
			if (contentVisibleOwnedSettingsCellCount <= 0)
			{
				return true;
			}
			if (contentVisibleOwnedSettingsCellCount != expectedOwnedModConfigEntryCount)
			{
				return true;
			}
			if (modConfigContentChildCount < expectedOwnedModConfigEntryCount)
			{
				return true;
			}
			return false;
		}

		private bool FilterHiddenOwnedModConfigRows(object menuInstance, Type menuType)
		{
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			if (menuInstance == null || menuType == null || !IsOwnedModConfigName(_activeModConfigName))
			{
				return false;
			}
			bool flag = false;
			try
			{
				Transform modConfigContentTransform = GetModConfigContentTransform(menuInstance, menuType);
				if (GetFieldInHierarchy(menuType, "m_spawnedCells")?.GetValue(menuInstance) is IList list)
				{
					for (int num = list.Count - 1; num >= 0; num--)
					{
						object obj = list[num];
						if (obj == null)
						{
							list.RemoveAt(num);
							flag = true;
						}
						else
						{
							Object val = (Object)((obj is Object) ? obj : null);
							if (val != null && val == (Object)null)
							{
								list.RemoveAt(num);
								flag = true;
							}
							else
							{
								ConfigEntryBase val2 = TryGetConfigEntryBaseFromSettingOption(obj);
								if (val2 != null && IsOwnedConfigEntry(val2) && !ShouldExposeOwnedConfigEntry(val2))
								{
									list.RemoveAt(num);
									flag = true;
									GameObject val3 = TryGetDirectModConfigCellGameObject(obj);
									if ((Object)val3 != (Object)null)
									{
										Object.Destroy((Object)val3);
									}
								}
							}
						}
					}
				}
				HashSet<string> hiddenOwnedConfigDisplayNames = GetHiddenOwnedConfigDisplayNames();
				if ((Object)(object)modConfigContentTransform != (Object)null)
				{
					for (int num2 = modConfigContentTransform.childCount - 1; num2 >= 0; num2--)
					{
						Transform child = modConfigContentTransform.GetChild(num2);
						if (!((Object)(object)child == (Object)null) && ShouldRemoveOwnedModConfigRowByDisplayName(child, hiddenOwnedConfigDisplayNames))
						{
							Object.Destroy((Object)((Component)child).gameObject);
							flag = true;
						}
					}
				}
				if (flag)
				{
					CleanupDestroyedModConfigCells(menuInstance, menuType);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] FilterHiddenOwnedModConfigRows failed: " + DescribeReflectionException(ex)));
			}
			return flag;
		}

		private bool EnsureOwnedModConfigEntriesRegistered(Type menuType)
		{
			if (menuType == null)
			{
				return false;
			}
			try
			{
				Type type = menuType.Assembly.GetType("PEAKLib.ModConfig.ModConfigPlugin");
				if (type == null || SettingsHandler.Instance == null)
				{
					return false;
				}
				ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config);
				if (configEntriesSnapshot.Length == 0)
				{
					return false;
				}
				HashSet<string> hashSet = GetOwnedRegisteredConfigEntryIdentitySet();
				List<ConfigEntryBase> list = (from entry in configEntriesSnapshot
					where entry != null && ShouldExposeOwnedConfigEntry(entry) && !hashSet.Contains(GetConfigEntryIdentity(entry))
					orderby GetModConfigSectionSortIndex(GetModConfigSectionForEntry(entry)), GetModConfigEntrySortIndex(entry)
					select entry).ToList();
				if (list.Count == 0)
				{
					return false;
				}
				if (type.GetProperty("EntriesProcessed", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) is IList list2)
				{
					foreach (ConfigEntryBase item in list)
					{
						if (list2.Contains(item))
						{
							list2.Remove(item);
						}
					}
				}
				type.GetMethod("ProcessModEntries", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(null, null);
				HashSet<string> hashSet2 = GetOwnedRegisteredConfigEntryIdentitySet();
				List<string> list3 = (from identity in list.Select(GetConfigEntryIdentity)
					where !hashSet2.Contains(identity)
					select identity).ToList();
				if (list3.Count != 0)
				{
					Log.LogWarning((object)("[ShootZombies] ModConfig entries still missing after restore: " + string.Join(", ", list3)));
				}
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] EnsureOwnedModConfigEntriesRegistered failed: " + DescribeReflectionException(ex)));
				return false;
			}
		}

		private static HashSet<string> GetOwnedRegisteredConfigEntryIdentitySet()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			if (SettingsHandler.Instance == null)
			{
				return hashSet;
			}
			if (!(typeof(SettingsHandler).GetMethod("GetAllSettings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(SettingsHandler.Instance, null) is IEnumerable enumerable))
			{
				return hashSet;
			}
			foreach (object item in enumerable)
			{
				ConfigEntryBase val = TryGetConfigEntryBaseFromSettingOption(item);
				if (val != null && IsOwnedConfigEntry(val))
				{
					hashSet.Add(GetConfigEntryIdentity(val));
				}
			}
			return hashSet;
		}

		private static string GetConfigEntryIdentity(ConfigEntryBase entry)
		{
			if (entry == null || entry.Definition == (ConfigDefinition)null)
			{
				return string.Empty;
			}
			return entry.Definition.Section + "\u0001" + entry.Definition.Key;
		}

		private int GetExpectedOwnedModConfigEntryCount(object menuInstance, Type menuType)
		{
			if (menuInstance == null || menuType == null)
			{
				return 0;
			}
			if (!TryGetOwnedCanonicalSectionName(GetSelectedModConfigSection(menuInstance, menuType), out var canonicalSectionName))
			{
				canonicalSectionName = GetCurrentCanonicalSections().FirstOrDefault();
			}
			if (string.IsNullOrWhiteSpace(canonicalSectionName))
			{
				return 0;
			}
			return GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config).Count((ConfigEntryBase entry) => ShouldExposeOwnedConfigEntry(entry) && string.Equals(GetModConfigSectionForEntry(entry), canonicalSectionName, StringComparison.Ordinal));
		}

		private static int GetSpawnedVisibleOwnedSettingsCellCount(object menuInstance, Type menuType, string canonicalSectionName)
		{
			if (menuInstance == null || menuType == null || string.IsNullOrWhiteSpace(canonicalSectionName))
			{
				return 0;
			}
			if (!(menuType.GetField("m_spawnedCells", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance) is IList list))
			{
				return 0;
			}
			int num = 0;
			foreach (object item in list)
			{
				if (item == null)
				{
					continue;
				}
				Object val = (Object)((item is Object) ? item : null);
				if (val == null || !(val == (Object)null))
				{
					ConfigEntryBase val2 = TryGetConfigEntryBaseFromSettingOption(item);
					if (val2 != null && ShouldExposeOwnedConfigEntry(val2) && string.Equals(GetModConfigSectionForEntry(val2), canonicalSectionName, StringComparison.Ordinal))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static int GetContentVisibleOwnedSettingsCellCount(object menuInstance, Type menuType, string canonicalSectionName)
		{
			if (menuInstance == null || menuType == null || string.IsNullOrWhiteSpace(canonicalSectionName))
			{
				return 0;
			}
			Transform modConfigContentTransform = GetModConfigContentTransform(menuInstance, menuType);
			if ((Object)(object)modConfigContentTransform == (Object)null)
			{
				return 0;
			}
			HashSet<string> visibleOwnedConfigDisplayNamesForSection = GetVisibleOwnedConfigDisplayNamesForSection(canonicalSectionName);
			if (visibleOwnedConfigDisplayNamesForSection.Count == 0)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < modConfigContentTransform.childCount; i++)
			{
				Transform child = modConfigContentTransform.GetChild(i);
				if (!((Object)(object)child == (Object)null) && DoesModConfigRowMatchDisplayNames(child, visibleOwnedConfigDisplayNamesForSection))
				{
					num++;
				}
			}
			return num;
		}

		private static int GetSpawnedSettingsCellCount(object menuInstance, Type menuType)
		{
			if (menuInstance == null || menuType == null)
			{
				return 0;
			}
			if (menuType.GetField("m_spawnedCells", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance) is IList source)
			{
				return source.Cast<object>().Count((object item) => item != null);
			}
			object? obj = menuType.GetProperty("Content", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			Transform val2 = ((val != null) ? val : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return 0;
			}
			return val2.childCount;
		}

		private static int GetModConfigContentChildCount(object menuInstance, Type menuType)
		{
			Transform modConfigContentTransform = GetModConfigContentTransform(menuInstance, menuType);
			if ((Object)(object)modConfigContentTransform == (Object)null)
			{
				return 0;
			}
			return modConfigContentTransform.childCount;
		}

		private static Transform GetModConfigContentTransform(object menuInstance, Type menuType)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			if (menuInstance == null || menuType == null)
			{
				return null;
			}
			object obj = menuType.GetProperty("Content", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
			return (Transform)((obj is Transform) ? obj : null);
		}

		private bool NormalizeOwnedModConfigSelectedSection(object menuInstance, Type menuType)
		{
			List<string> currentCanonicalSections = GetCurrentCanonicalSections();
			if (currentCanonicalSections.Count == 0)
			{
				return false;
			}
			string text = NormalizeLocalizedText(GetSelectedModConfigSection(menuInstance, menuType)).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return SetSelectedModConfigSection(menuInstance, menuType, currentCanonicalSections[0]);
			}
			if (TryGetOwnedCanonicalSectionName(text, out var canonicalSectionName) && currentCanonicalSections.Contains(canonicalSectionName))
			{
				if (string.Equals(text, canonicalSectionName, StringComparison.Ordinal))
				{
					return false;
				}
				return SetSelectedModConfigSection(menuInstance, menuType, canonicalSectionName);
			}
			return SetSelectedModConfigSection(menuInstance, menuType, currentCanonicalSections[0]);
		}

		private static string GetSelectedModConfigSection(object menuInstance, Type menuType)
		{
			if (menuInstance == null || menuType == null)
			{
				return string.Empty;
			}
			FieldInfo field = menuType.GetField("selectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && field.GetValue(menuInstance) is string result)
			{
				return result;
			}
			PropertyInfo propertyInfo = menuType.GetProperty("selectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? menuType.GetProperty("SelectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (propertyInfo != null && propertyInfo.CanRead)
			{
				return (propertyInfo.GetValue(menuInstance, null) as string) ?? string.Empty;
			}
			return string.Empty;
		}

		private static bool SetSelectedModConfigSection(object menuInstance, Type menuType, string section)
		{
			if (menuInstance == null || menuType == null || string.IsNullOrWhiteSpace(section))
			{
				return false;
			}
			if (string.Equals(GetSelectedModConfigSection(menuInstance, menuType), section, StringComparison.Ordinal))
			{
				return false;
			}
			MethodInfo method = menuType.GetMethod("SetSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
			if (method != null)
			{
				method.Invoke(menuInstance, new object[1] { section });
				return true;
			}
			FieldInfo field = menuType.GetField("selectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				field.SetValue(menuInstance, section);
				return true;
			}
			PropertyInfo propertyInfo = menuType.GetProperty("selectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? menuType.GetProperty("SelectedSection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (propertyInfo != null && propertyInfo.CanWrite)
			{
				propertyInfo.SetValue(menuInstance, section, null);
				return true;
			}
			return false;
		}

		private static bool TryGetOwnedCanonicalSectionName(string section, out string canonicalSectionName)
		{
			canonicalSectionName = string.Empty;
			section = NormalizeLocalizedText(section).Trim();
			if (string.IsNullOrWhiteSpace(section))
			{
				return false;
			}
			foreach (string item in GetDesiredModConfigSectionOrder())
			{
				if (MatchesOwnedSectionAlias(section, item))
				{
					canonicalSectionName = item;
					return true;
				}
			}
			return false;
		}

		private void SyncActiveModConfigName(object menuInstance, Type menuType)
		{
			string selectedModConfigCategory = GetSelectedModConfigCategory(menuInstance, menuType);
			if (!string.IsNullOrWhiteSpace(selectedModConfigCategory))
			{
				_activeModConfigName = selectedModConfigCategory;
			}
		}

		private static bool NormalizeOwnedSectionTabCategories(object menuInstance, Type menuType, bool isChinese)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			if (menuInstance == null || menuType == null)
			{
				return false;
			}
			try
			{
				object obj = menuType.GetField("SectionTabController", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
				Component val = (Component)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				Type type = menuType.Assembly.GetType("PEAKLib.ModConfig.Components.ModdedTABSButton");
				if (type == null)
				{
					return false;
				}
				FieldInfo field = type.GetField("category", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				FieldInfo field2 = type.GetField("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null)
				{
					return false;
				}
				bool result = false;
				foreach (Component item in val.GetComponentsInChildren(type, true).OfType<Component>())
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					string text = NormalizeLocalizedText(field.GetValue(item) as string).Trim();
					TMP_Text val2 = (TMP_Text)((field2 != null) ? field2.GetValue(item) : null);
					if (TryGetOwnedCanonicalSectionName((!string.IsNullOrWhiteSpace(text)) ? text : NormalizeLocalizedText(((Object)(object)val2 != (Object)null) ? val2.text : string.Empty).Trim(), out var canonicalSectionName))
					{
						if (!string.Equals(text, canonicalSectionName, StringComparison.Ordinal))
						{
							field.SetValue(item, canonicalSectionName);
							result = true;
						}
						if ((Object)(object)item.gameObject != (Object)null && !string.Equals(((Object)item.gameObject).name, canonicalSectionName, StringComparison.Ordinal))
						{
							((Object)item.gameObject).name = canonicalSectionName;
							result = true;
						}
						string displayName;
						string text2 = (TryGetLocalizedSectionDisplayName(canonicalSectionName, isChinese, out displayName) ? displayName : GetLocalizedSectionName(canonicalSectionName, isChinese));
						if ((Object)(object)val2 != (Object)null && !string.IsNullOrWhiteSpace(text2) && !string.Equals(val2.text, text2, StringComparison.Ordinal))
						{
							val2.text = text2;
							result = true;
						}
					}
				}
				return result;
			}
			catch
			{
				return false;
			}
		}

		private static bool AreOwnedSectionTabLabelsStable(object menuInstance, Type menuType, bool isChinese)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if (menuInstance == null || menuType == null)
			{
				return false;
			}
			try
			{
				object obj = menuType.GetField("SectionTabController", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
				Component val = (Component)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				TMP_Text[] componentsInChildren = val.GetComponentsInChildren<TMP_Text>(true);
				foreach (TMP_Text val2 in componentsInChildren)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					string text = NormalizeLocalizedText(val2.text).Trim();
					if (!string.IsNullOrWhiteSpace(text) && TryGetOwnedCanonicalSectionName(text, out var canonicalSectionName))
					{
						hashSet.Add(canonicalSectionName);
						string displayName;
						string text2 = (TryGetLocalizedSectionDisplayName(canonicalSectionName, isChinese, out displayName) ? displayName : GetLocalizedSectionName(canonicalSectionName, isChinese));
						if (!string.IsNullOrWhiteSpace(text2) && !string.Equals(text, text2, StringComparison.Ordinal))
						{
							return false;
						}
					}
				}
				return hashSet.Count == Instance?.GetCurrentCanonicalSections().Count;
			}
			catch
			{
				return false;
			}
		}

		private static string GetSelectedModConfigCategory(object menuInstance, Type menuType)
		{
			if (menuInstance == null || menuType == null)
			{
				return string.Empty;
			}
			try
			{
				object obj = menuType.GetProperty("Tabs", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
				if (obj == null)
				{
					return string.Empty;
				}
				object obj2 = GetFieldInHierarchy(obj.GetType(), "selectedButton")?.GetValue(obj);
				if (obj2 == null)
				{
					return string.Empty;
				}
				return NormalizeLocalizedText(obj2.GetType().GetField("category", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj2) as string).Trim();
			}
			catch
			{
				return string.Empty;
			}
		}

		private static FieldInfo GetFieldInHierarchy(Type type, string fieldName)
		{
			Type type2 = type;
			while (type2 != null)
			{
				FieldInfo field = type2.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return field;
				}
				type2 = type2.BaseType;
			}
			return null;
		}

		private static string FindFallbackAkSoundSelection(string currentSelection)
		{
			string[] akSoundSelectionValues = AkSoundSelectionValues;
			foreach (string text in akSoundSelectionValues)
			{
				if (_externalGunshotSounds.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
				{
					return text;
				}
			}
			akSoundSelectionValues = AkSoundSelectionValues;
			foreach (string text2 in akSoundSelectionValues)
			{
				string externalAkSoundPath = GetExternalAkSoundPath(text2);
				if (!string.IsNullOrWhiteSpace(externalAkSoundPath) && File.Exists(externalAkSoundPath))
				{
					return text2;
				}
			}
			return NormalizeAkSoundSelection(currentSelection);
		}

		private static bool MatchesOwnedSectionAlias(string value, string canonicalSectionName)
		{
			if (string.IsNullOrWhiteSpace(value) || string.IsNullOrWhiteSpace(canonicalSectionName))
			{
				return false;
			}
			string text = NormalizeSectionAlias(value);
			string text2 = NormalizeSectionAlias(canonicalSectionName);
			if (!string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(text2) && string.Equals(text, text2, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals(value, canonicalSectionName, StringComparison.OrdinalIgnoreCase) || string.Equals(value, GetLocalizedSectionName(canonicalSectionName, isChinese: false), StringComparison.OrdinalIgnoreCase) || string.Equals(value, GetLocalizedSectionName(canonicalSectionName, isChinese: true), StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (TryGetLocalizedSectionDisplayName(canonicalSectionName, isChinese: false, out var displayName) && string.Equals(value, displayName, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (TryGetLocalizedSectionDisplayName(canonicalSectionName, isChinese: true, out displayName) && string.Equals(value, displayName, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return false;
		}

		private bool NormalizeOwnedModConfigSections(Assembly assembly, object menuInstance = null, Type menuType = null)
		{
			if (assembly == null)
			{
				return false;
			}
			Type type = assembly.GetType("PEAKLib.ModConfig.Components.ModSectionNames");
			if (type == null)
			{
				return false;
			}
			PropertyInfo property3 = type.GetProperty("SectionNames", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			PropertyInfo property2 = type.GetProperty("ModName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			PropertyInfo property4 = type.GetProperty("Sections", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property3 == null || property2 == null || property4 == null)
			{
				return false;
			}
			if (!(property3.GetValue(null) is IList list))
			{
				return false;
			}
			List<string> list2 = (from section in GetCurrentCanonicalSections()
				where !string.IsNullOrWhiteSpace(section)
				select section).Distinct<string>(StringComparer.Ordinal).ToList();
			if (list2.Count == 0)
			{
				return false;
			}
			List<object> list3 = new List<object>();
			foreach (object item in list)
			{
				string modName = property2.GetValue(item, null) as string;
				if (IsOwnedModConfigName(modName))
				{
					list3.Add(item);
				}
			}
			string text = ResolveOwnedModConfigLookupName(assembly, menuInstance, menuType, list3, property2);
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			bool result = false;
			object obj = list3.FirstOrDefault((object entry) => string.Equals(property2.GetValue(entry, null) as string, text, StringComparison.OrdinalIgnoreCase)) ?? list3.FirstOrDefault();
			if (obj == null)
			{
				obj = Activator.CreateInstance(type);
				property2.SetValue(obj, text, null);
				list.Add(obj);
				result = true;
			}
			for (int num = list3.Count - 1; num >= 0; num--)
			{
				if (list3[num] != obj)
				{
					list.Remove(list3[num]);
					result = true;
				}
			}
			if (!string.Equals(property2.GetValue(obj, null) as string, text, StringComparison.Ordinal))
			{
				property2.SetValue(obj, text, null);
				result = true;
			}
			IList list4 = property4.GetValue(obj, null) as IList;
			List<string> list5 = new List<string>();
			if (list4 != null)
			{
				foreach (object item2 in list4)
				{
					if (item2 is string text2 && !string.IsNullOrWhiteSpace(text2))
					{
						list5.Add(text2);
					}
				}
			}
			if (!list5.SequenceEqual(list2))
			{
				property4.SetValue(obj, list2, null);
				result = true;
			}
			return result;
		}

		private string ResolveOwnedModConfigLookupName(Assembly assembly, object menuInstance, Type menuType, IEnumerable<object> existingEntries = null, PropertyInfo modNameProperty = null)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			List<string> list = new List<string>();
			AddCandidate(GetSelectedModConfigCategory(menuInstance, menuType));
			AddCandidate(_activeModConfigName);
			if (existingEntries != null && modNameProperty != null)
			{
				foreach (object existingEntry in existingEntries)
				{
					AddCandidate(modNameProperty.GetValue(existingEntry, null) as string);
				}
			}
			AddCandidate("ShootZombies");
			AddCandidate("Shoot Zombies");
			AddCandidate("ShootZombies");
			AddCandidate(GetLocalizedModDisplayName(isChinese: false));
			AddCandidate(GetLocalizedModDisplayName(isChinese: true));
			AddCandidate("打僵尸");
			AddCandidate("僵尸模式");
			return list.FirstOrDefault();
			void AddCandidate(string name)
			{
				name = NormalizeLocalizedText(name).Trim();
				if (!string.IsNullOrWhiteSpace(name) && IsOwnedModConfigName(name) && hashSet.Add(name))
				{
					list.Add(name);
				}
			}
		}

		private bool IsOwnedModConfigName(string modName)
		{
			if (string.IsNullOrWhiteSpace(modName))
			{
				return false;
			}
			if (string.Equals(modName, "Shoot Zombies", StringComparison.OrdinalIgnoreCase) || string.Equals(modName, "ShootZombies", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (!string.Equals(modName, GetLocalizedModDisplayName(isChinese: true), StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(modName, "僵尸模式", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool IsOwnedModConfigContext(object menuInstance, Type menuType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if ((Object)Instance == (Object)null)
			{
				return false;
			}
			string text = GetSelectedModConfigCategory(menuInstance, menuType);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = NormalizeLocalizedText(Instance._activeModConfigName).Trim();
			}
			return Instance.IsOwnedModConfigName(text);
		}

		private static bool ShouldLocalizeOwnedModConfigButton(string value, bool ownedContext)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			if ((Object)Instance != (Object)null && Instance.IsOwnedModConfigName(value))
			{
				return true;
			}
			if (!ownedContext)
			{
				return false;
			}
			string canonicalSectionName;
			return TryGetOwnedCanonicalSectionName(value, out canonicalSectionName);
		}

		private static bool TryGetLocalizedOwnedConfigDisplayName(string value, bool isChinese, out string displayName)
		{
			displayName = string.Empty;
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			string localizedKeyName = GetLocalizedKeyName(value, isChinese);
			if (string.IsNullOrWhiteSpace(localizedKeyName))
			{
				return false;
			}
			string b = NormalizeLocalizedText(value).Trim();
			string text = NormalizeLocalizedText(localizedKeyName).Trim();
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, b, StringComparison.Ordinal))
			{
				return false;
			}
			displayName = text;
			return true;
		}

		private static void DeduplicateVisibleOwnedModConfigRows(object menuInstance, Type menuType)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			if (menuInstance == null || menuType == null)
			{
				return;
			}
			try
			{
				object? obj = menuType.GetProperty("Content", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuInstance);
				Transform val = (Transform)((obj is Transform) ? obj : null);
				Transform val2 = ((val != null) ? val : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				for (int num = val2.childCount - 1; num >= 0; num--)
				{
					Transform child = val2.GetChild(num);
					if (!((Object)(object)child == (Object)null))
					{
						TMP_Text val3 = ((IEnumerable<TMP_Text>)((Component)child).GetComponentsInChildren<TMP_Text>(true)).FirstOrDefault((Func<TMP_Text, bool>)((TMP_Text text) => !string.IsNullOrWhiteSpace(((Object)(object)text != (Object)null) ? text.text : null)));
						if (!((Object)(object)val3 == (Object)null))
						{
							string text2 = NormalizeLocalizedText(val3.text).Trim();
							if (!string.IsNullOrWhiteSpace(text2) && !hashSet.Add(text2))
							{
								Object.Destroy((Object)((Component)child).gameObject);
							}
						}
					}
				}
			}
			catch
			{
			}
		}

		private static GameObject TryGetDirectModConfigCellGameObject(object instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			if (instance == null)
			{
				return null;
			}
			GameObject val = (GameObject)((instance is GameObject) ? instance : null);
			GameObject val2 = ((val != null) ? val : null);
			if ((Object)val2 != (Object)null)
			{
				return val2;
			}
			Component val3 = (Component)((instance is Component) ? instance : null);
			Component val4 = ((val3 != null) ? val3 : null);
			if ((Object)val4 != (Object)null)
			{
				return val4.gameObject;
			}
			return null;
		}

		private HashSet<string> GetHiddenOwnedConfigDisplayNames()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config);
			foreach (ConfigEntryBase val in configEntriesSnapshot)
			{
				if (val != null && IsOwnedConfigEntry(val) && !ShouldExposeOwnedConfigEntry(val))
				{
					ConfigDefinition definition = val.Definition;
					string text = ((definition != (ConfigDefinition)null) ? definition.Key : null) ?? string.Empty;
					AddNormalizedOwnedConfigDisplayName(hashSet, text);
					AddNormalizedOwnedConfigDisplayName(hashSet, GetLocalizedKeyName(text, isChinese: false));
					AddNormalizedOwnedConfigDisplayName(hashSet, GetLocalizedKeyName(text, isChinese: true));
				}
			}
			return hashSet;
		}

		private static void AddNormalizedOwnedConfigDisplayName(HashSet<string> names, string value)
		{
			if (names != null && !string.IsNullOrWhiteSpace(value))
			{
				names.Add(NormalizeLocalizedText(value).Trim());
			}
		}

		private static HashSet<string> GetVisibleOwnedConfigDisplayNamesForSection(string canonicalSectionName)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Plugin instance = Instance;
			ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((Object)(object)instance != (Object)null) ? ((BaseUnityPlugin)instance).Config : null);
			foreach (ConfigEntryBase val in configEntriesSnapshot)
			{
				if (val != null && IsOwnedConfigEntry(val) && ShouldExposeOwnedConfigEntry(val) && string.Equals(GetModConfigSectionForEntry(val), canonicalSectionName, StringComparison.Ordinal))
				{
					ConfigDefinition definition = val.Definition;
					string text = ((definition != (ConfigDefinition)null) ? definition.Key : null) ?? string.Empty;
					AddNormalizedOwnedConfigDisplayName(hashSet, text);
					AddNormalizedOwnedConfigDisplayName(hashSet, GetLocalizedKeyName(text, isChinese: false));
					AddNormalizedOwnedConfigDisplayName(hashSet, GetLocalizedKeyName(text, isChinese: true));
				}
			}
			return hashSet;
		}

		private static bool ShouldRemoveOwnedModConfigRowByDisplayName(Transform row, HashSet<string> hiddenOwnedConfigDisplayNames)
		{
			if ((Object)(object)row == (Object)null)
			{
				return false;
			}
			if (hiddenOwnedConfigDisplayNames == null || hiddenOwnedConfigDisplayNames.Count == 0)
			{
				return false;
			}
			return DoesModConfigRowMatchDisplayNames(row, hiddenOwnedConfigDisplayNames);
		}

		private static bool DoesModConfigRowMatchDisplayNames(Transform row, HashSet<string> displayNames)
		{
			if ((Object)(object)row == (Object)null || displayNames == null || displayNames.Count == 0)
			{
				return false;
			}
			TMP_Text[] componentsInChildren = ((Component)row).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				string text = NormalizeLocalizedText(((Object)(object)val != (Object)null) ? val.text : null).Trim();
				if (!string.IsNullOrWhiteSpace(text) && displayNames.Contains(text))
				{
					return true;
				}
			}
			return false;
		}

		private void ApplyTextLocalizationToRoot(Transform root, Dictionary<string, string> map)
		{
			if ((Object)(object)root == (Object)null || map == null || map.Count == 0)
			{
				return;
			}
			TMP_Text[] componentsInChildren = ((Component)root).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = val.text;
				if (!string.IsNullOrWhiteSpace(text))
				{
					string value = null;
					if (map.TryGetValue(text.Trim(), out value) && !string.Equals(value, text, StringComparison.Ordinal))
					{
						val.text = value;
					}
				}
			}
		}

		private Dictionary<string, string> BuildModConfigUiLocalizationMap(bool isChinese)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			AddUiLocalizationPair(dictionary, "Shoot Zombies", GetLocalizedModDisplayName(isChinese));
			AddUiLocalizationPair(dictionary, "ShootZombies", GetLocalizedModDisplayName(isChinese));
			AddUiLocalizationPair(dictionary, "僵尸模式", GetLocalizedModDisplayName(isChinese));
			AddUiLocalizationPair(dictionary, "打僵尸", GetLocalizedModDisplayName(isChinese));
			string[] array = new string[9] { "General", "Weapon", "Inventory", "Zombie", "Zombie Spawn", "Zombie AI", "Fog", "Features", "Hotkeys" };
			foreach (string text in array)
			{
				string displayName;
				string localized = (TryGetLocalizedSectionDisplayName(text, isChinese, out displayName) ? displayName : GetLocalizedSectionName(text, isChinese));
				AddUiLocalizationPair(dictionary, text, localized);
				string localizedSectionDescription = GetLocalizedSectionDescription(text, isChinese: false);
				string localizedSectionDescription2 = GetLocalizedSectionDescription(text, isChinese);
				if (!string.IsNullOrWhiteSpace(localizedSectionDescription) && !string.IsNullOrWhiteSpace(localizedSectionDescription2))
				{
					AddUiLocalizationPair(dictionary, localizedSectionDescription, localizedSectionDescription2);
				}
			}
			AddUiLocalizationPair(dictionary, "Weapons", GetLocalizedSectionName("Weapon", isChinese));
			AddUiLocalizationPair(dictionary, "Zombie Behavior", GetLocalizedSectionName("Zombie", isChinese));
			AddUiLocalizationPair(dictionary, "Zombie Behaviors", GetLocalizedSectionName("Zombie", isChinese));
			AddUiLocalizationPair(dictionary, "Zombie Spawning", GetLocalizedSectionName("Zombie Spawn", isChinese));
			string[] first = new string[29]
			{
				"Weapon Selection", "Fire Interval", "Fire Volume", "Weapon Model Y Rotation", "Weapon Model Scale", "Weapon Model X Position", "Weapon Model Y Position", "Weapon Model Z Position", "Max Distance", "Bullet Size",
				"Zombie Time Reduction", "Move Speed", "Aggressiveness", "Knockback Force", "Enabled", "Zombie Spawn", "Zombie Spawn Enabled", "Max Count", "Spawn Interval", "Interval Random",
				"Spawn Count", "Count Random", "Spawn Radius", "Max Lifetime", "Destroy Distance", "Wakeup Distance", "Chase Distance", "Sprint Distance", "Chase Time"
			};
			string[] second = new string[16]
			{
				"Behavior Difficulty", "Lunge Distance", "Lunge Time", "Lunge Recovery Time", "Wakeup Look Angle", "Target Search Interval", "Bite Recovery Time", "Same Player Bite Cooldown", "AK Sound", "Mod Enabled",
				"Weapon Enabled", "Mod", "Weapon", "Zombie Spawn", "Open Config Panel", "Config Panel Theme"
			};
			string[] second2 = new string[1] { "Spawn Weapon" };
			foreach (string item in first.Concat(second).Concat(second2))
			{
				string localizedKeyName = GetLocalizedKeyName(item, isChinese);
				if (!string.IsNullOrWhiteSpace(localizedKeyName))
				{
					AddUiLocalizationPair(dictionary, item, localizedKeyName);
				}
				string localizedDescription = GetLocalizedDescription(item, isChinese: false);
				string localizedDescription2 = GetLocalizedDescription(item, isChinese);
				if (!string.IsNullOrWhiteSpace(localizedDescription) && !string.IsNullOrWhiteSpace(localizedDescription2))
				{
					AddUiLocalizationPair(dictionary, localizedDescription, localizedDescription2);
				}
			}
			foreach (string item2 in ConfigPanelThemeValues.Concat(WeaponSelectionValues).Concat(AkSoundSelectionValues).Concat(ZombieBehaviorDifficultyValues))
			{
				AddUiLocalizationPair(dictionary, item2, GetLocalizedSelectableValueDisplayName(item2, isChinese));
			}
			return dictionary;
		}

		private static string GetLocalizedSelectableValueDisplayName(string value, bool isChinese)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			switch (NormalizeLookupToken(value))
			{
			case "dark":
			case "black":
			case "黑":
			case "黑色":
				if (!isChinese)
				{
					return "Dark";
				}
				return "黑色";
			case "light":
			case "white":
			case "白":
			case "白色":
				if (!isChinese)
				{
					return "Light";
				}
				return "白色";
			case "clear":
			case "透":
			case "透明":
			case "translucent":
			case "transparent":
				if (!isChinese)
				{
					return "Transparent";
				}
				return "透明";
			case "aksound1":
			case "aksounds1":
			case "sound1":
			case "声音1":
			case "音效1":
				if (!isChinese)
				{
					return "Sound 1";
				}
				return "音效 1";
			case "aksound2":
			case "aksounds2":
			case "sound2":
			case "声音2":
			case "音效2":
				if (!isChinese)
				{
					return "Sound 2";
				}
				return "音效 2";
			case "aksound3":
			case "aksounds3":
			case "sound3":
			case "声音3":
			case "音效3":
				if (!isChinese)
				{
					return "Sound 3";
				}
				return "音效 3";
			case "easy":
			case "简单":
			case "休闲":
			case "simple":
			case "casual":
				if (!isChinese)
				{
					return "Easy";
				}
				return "简单";
			case "默认":
			case "标准":
			case "standard":
			case "normal":
				if (!isChinese)
				{
					return "Standard";
				}
				return "标准";
			case "hard":
			case "困难":
				if (!isChinese)
				{
					return "Hard";
				}
				return "困难";
			case "疯狂":
			case "残酷":
			case "insane":
			case "brutal":
				if (!isChinese)
				{
					return "Insane";
				}
				return "疯狂";
			case "hell":
			case "地狱":
			case "噩梦":
			case "nightmare":
				if (!isChinese)
				{
					return "Nightmare";
				}
				return "噩梦";
			default:
				return value;
			}
		}

		private static void AddUiLocalizationPair(Dictionary<string, string> map, string english, string localized)
		{
			if (map != null && !string.IsNullOrWhiteSpace(english) && !string.IsNullOrWhiteSpace(localized))
			{
				string text = NormalizeLocalizedText(english);
				string text5 = (map[localized] = (map[text] = (map[english] = NormalizeLocalizedText(localized))));
				map[text5] = text5;
				string key = english.Replace(" ", string.Empty);
				string key2 = text.Replace(" ", string.Empty);
				if (!map.ContainsKey(key))
				{
					map[key] = text5;
				}
				if (!map.ContainsKey(key2))
				{
					map[key2] = text5;
				}
				string key3 = text.ToUpperInvariant();
				string key4 = text5.ToUpperInvariant();
				map[key3] = text5;
				map[key4] = text5;
			}
		}

		private static bool IsSectionCanonicalName(string value)
		{
			switch (value)
			{
			case "General":
			case "Hotkeys":
			case "Weapon":
			case "Zombie":
			case "Inventory":
			case "Zombie AI":
			case "Zombie Spawn":
			case "Fog":
			case "Features":
				return true;
			default:
				return false;
			}
		}

		private static string GetLocalizedModDisplayNameCore(bool isChinese)
		{
			if (!isChinese)
			{
				return "ShootZombies";
			}
			return "打僵尸";
		}

		private static Type ResolveLoadedType(string fullName, string preferredAssembly = null)
		{
			if (!string.IsNullOrWhiteSpace(preferredAssembly))
			{
				Type type = Type.GetType(fullName + ", " + preferredAssembly, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				Type type2 = null;
				try
				{
					type2 = assembly.GetType(fullName, throwOnError: false);
				}
				catch
				{
				}
				if (type2 != null)
				{
					return type2;
				}
			}
			return null;
		}

		private static Transform FindBestCameraAnchor(Transform root)
		{
			//IL_006e: 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_0082: Expected O, but got Unknown
			//IL_0082: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Camera[] componentsInChildren = ((Component)root).GetComponentsInChildren<Camera>(true);
			Camera val = null;
			int num = int.MinValue;
			Camera[] array = componentsInChildren;
			foreach (Camera val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && ((Behaviour)val2).isActiveAndEnabled && !((Object)(object)val2.targetTexture != (Object)null))
				{
					int num2 = 0;
					string text = (((Object)val2).name ?? string.Empty).ToLowerInvariant();
					if ((Object)val2 == (Object)Camera.main)
					{
						num2 += 500;
					}
					if (text.Contains("main"))
					{
						num2 += 150;
					}
					if (text.Contains("camera"))
					{
						num2 += 100;
					}
					if (text.Contains("fps") || text.Contains("view") || text.Contains("player"))
					{
						num2 += 80;
					}
					if (val2.depth > 0f)
					{
						num2 += 20;
					}
					if (num2 > num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).transform;
		}

		private bool TryFindBestGlobalCameraAnchor(out Transform cameraTransform)
		{
			//IL_009e: 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)
			cameraTransform = null;
			List<Camera> list = new List<Camera>();
			try
			{
				list.AddRange(Object.FindObjectsByType<Camera>((FindObjectsSortMode)0));
			}
			catch
			{
			}
			try
			{
				Camera[] array = Resources.FindObjectsOfTypeAll<Camera>();
				foreach (Camera val in array)
				{
					if ((Object)(object)val != (Object)null && !list.Contains(val))
					{
						list.Add(val);
					}
				}
			}
			catch
			{
			}
			Camera val2 = null;
			int num = int.MinValue;
			foreach (Camera item in list)
			{
				if ((Object)(object)item == (Object)null || !((Behaviour)item).isActiveAndEnabled || (Object)(object)item.targetTexture != (Object)null)
				{
					continue;
				}
				Scene scene = ((Component)item).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					int globalCameraScore = GetGlobalCameraScore(item);
					if (globalCameraScore > num)
					{
						num = globalCameraScore;
						val2 = item;
					}
				}
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			cameraTransform = ((Component)val2).transform;
			return true;
		}

		private int GetGlobalCameraScore(Camera camera)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_006f: Expected O, but got Unknown
			//IL_00e7: 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)
			if ((Object)(object)camera == (Object)null)
			{
				return int.MinValue;
			}
			int num = 0;
			string text = ((((Object)camera).name ?? string.Empty) + "/" + (((Object)(object)((Component)camera).transform.parent != (Object)null) ? ((Object)((Component)camera).transform.parent).name : string.Empty)).ToLowerInvariant();
			if ((Object)camera == (Object)Camera.main)
			{
				num += 500;
			}
			if (text.Contains("main"))
			{
				num += 180;
			}
			if (text.Contains("player") || text.Contains("fps") || text.Contains("first") || text.Contains("view") || text.Contains("camera"))
			{
				num += 90;
			}
			if ((Object)(object)_localCharacter != (Object)null)
			{
				float num2 = Vector3.Distance(((Component)camera).transform.position, ((Component)_localCharacter).transform.position);
				num += Mathf.RoundToInt(Mathf.Clamp(40f - num2 * 10f, -40f, 40f));
			}
			if (camera.depth > 0f)
			{
				num += 10;
			}
			return num;
		}

		private static string LocalizeModConfigText(string value)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			value = NormalizeLocalizedText(value);
			bool isChinese = (Object)Instance != (Object)null && Instance.IsChineseLanguage();
			if (TryGetLocalizedSectionDisplayName(value, isChinese, out var displayName) && !string.Equals(displayName, value, StringComparison.Ordinal))
			{
				return NormalizeLocalizedText(displayName);
			}
			string localizedSectionName = GetLocalizedSectionName(value, isChinese);
			if (!string.Equals(localizedSectionName, value, StringComparison.Ordinal))
			{
				return NormalizeLocalizedText(localizedSectionName);
			}
			string localizedKeyName = GetLocalizedKeyName(value, isChinese);
			if (!string.Equals(localizedKeyName, value, StringComparison.Ordinal))
			{
				return NormalizeLocalizedText(localizedKeyName);
			}
			string localizedDescription = GetLocalizedDescription(value, isChinese);
			if (!string.IsNullOrWhiteSpace(localizedDescription) && !string.Equals(localizedDescription, value, StringComparison.Ordinal))
			{
				return NormalizeLocalizedText(localizedDescription);
			}
			string localizedSelectableValueDisplayName = GetLocalizedSelectableValueDisplayName(value, isChinese);
			if (!string.IsNullOrWhiteSpace(localizedSelectableValueDisplayName) && !string.Equals(localizedSelectableValueDisplayName, value, StringComparison.Ordinal))
			{
				return NormalizeLocalizedText(localizedSelectableValueDisplayName);
			}
			if (string.Equals(value, "default", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "Default", StringComparison.OrdinalIgnoreCase))
			{
				return NormalizeLocalizedText(GetLocalizedSelectableValueDisplayName("ak_sound1", isChinese));
			}
			if (string.Equals(value, "Shoot Zombies", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "ShootZombies", StringComparison.OrdinalIgnoreCase))
			{
				return NormalizeLocalizedText(GetLocalizedModDisplayName(isChinese));
			}
			return NormalizeLocalizedText(value);
		}

		private static IEnumerable<Type> GetLoadableTypes(Assembly assembly)
		{
			if (assembly == null)
			{
				return Array.Empty<Type>();
			}
			try
			{
				return (from t in assembly.GetTypes()
					where t != null
					select t).ToArray();
			}
			catch (ReflectionTypeLoadException ex)
			{
				return ex.Types.Where((Type t) => t != null).ToArray();
			}
			catch
			{
				return Array.Empty<Type>();
			}
		}

		private static ConfigEntryBase TryGetConfigEntryBaseFromSettingOption(object instance)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			if (instance == null)
			{
				return null;
			}
			try
			{
				Type type = instance.GetType();
				object obj = (type.GetProperty("PEAKLib.ModConfig.IBepInExProperty.ConfigBase", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? type.GetProperty("ConfigBase", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))?.GetValue(instance);
				ConfigEntryBase val = (ConfigEntryBase)((obj is ConfigEntryBase) ? obj : null);
				if (val != null)
				{
					return val;
				}
				string[] array = new string[4] { "<entryBase>P", "entryBase", "_entryBase", "<ConfigBase>k__BackingField" };
				foreach (string name in array)
				{
					object obj2 = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(instance);
					ConfigEntryBase val2 = (ConfigEntryBase)((obj2 is ConfigEntryBase) ? obj2 : null);
					if (val2 != null)
					{
						return val2;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static ConfigEntryBase TryGetConfigEntryBaseFromModConfigCell(object instance)
		{
			return TryResolveConfigEntryBaseFromObjectGraph(instance, 0, new HashSet<object>(ReferenceIdentityComparer.Instance));
		}

		private static ConfigEntryBase TryResolveConfigEntryBaseFromObjectGraph(object instance, int depth, HashSet<object> visited)
		{
			if (instance == null || depth > 2)
			{
				return null;
			}
			if (instance is string)
			{
				return null;
			}
			Object val = (Object)((instance is Object) ? instance : null);
			if (val != null && val == (Object)null)
			{
				return null;
			}
			if (!instance.GetType().IsValueType && visited != null && !visited.Add(instance))
			{
				return null;
			}
			ConfigEntryBase val2 = TryGetConfigEntryBaseFromSettingOption(instance);
			if (val2 != null)
			{
				return val2;
			}
			ConfigEntryBase val3 = (ConfigEntryBase)((instance is ConfigEntryBase) ? instance : null);
			val2 = ((val3 != null) ? val3 : null);
			if (val2 != null)
			{
				return val2;
			}
			GameObject val4 = (GameObject)((instance is GameObject) ? instance : null);
			if (val4 != null)
			{
				Component[] components = val4.GetComponents<Component>();
				for (int i = 0; i < components.Length; i++)
				{
					ConfigEntryBase val5 = TryResolveConfigEntryBaseFromObjectGraph(components[i], depth + 1, visited);
					if (val5 != null)
					{
						return val5;
					}
				}
			}
			foreach (object item in EnumerateRelevantModConfigMemberValues(instance))
			{
				ConfigEntryBase val6 = TryResolveConfigEntryBaseFromObjectGraph(item, depth + 1, visited);
				if (val6 != null)
				{
					return val6;
				}
			}
			return null;
		}

		private static GameObject TryGetAssociatedGameObjectFromModConfigCell(object instance)
		{
			return TryResolveGameObjectFromObjectGraph(instance, 0, new HashSet<object>(ReferenceIdentityComparer.Instance));
		}

		private static GameObject TryResolveGameObjectFromObjectGraph(object instance, int depth, HashSet<object> visited)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			if (instance == null || depth > 2)
			{
				return null;
			}
			Object val = (Object)((instance is Object) ? instance : null);
			if (val != null && val == (Object)null)
			{
				return null;
			}
			if (instance is string)
			{
				return null;
			}
			GameObject val2 = (GameObject)((instance is GameObject) ? instance : null);
			GameObject val3 = ((val2 != null) ? val2 : null);
			if ((Object)val3 != (Object)null)
			{
				return val3;
			}
			Component val4 = (Component)((instance is Component) ? instance : null);
			Component val5 = ((val4 != null) ? val4 : null);
			if ((Object)val5 != (Object)null)
			{
				return val5.gameObject;
			}
			Transform val6 = (Transform)((instance is Transform) ? instance : null);
			Transform val7 = ((val6 != null) ? val6 : null);
			if ((Object)val7 != (Object)null)
			{
				return ((Component)val7).gameObject;
			}
			if (!instance.GetType().IsValueType && visited != null && !visited.Add(instance))
			{
				return null;
			}
			foreach (object item in EnumerateRelevantModConfigMemberValues(instance))
			{
				GameObject val8 = TryResolveGameObjectFromObjectGraph(item, depth + 1, visited);
				if ((Object)val8 != (Object)null)
				{
					return val8;
				}
			}
			return null;
		}

		[IteratorStateMachine(typeof(<EnumerateRelevantModConfigMemberValues>d__217))]
		private static IEnumerable<object> EnumerateRelevantModConfigMemberValues(object instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateRelevantModConfigMemberValues>d__217(-2)
			{
				<>3__instance = instance
			};
		}

		private static bool ShouldInspectRelevantModConfigMember(Type memberType, string memberName)
		{
			if (memberType == null)
			{
				return false;
			}
			if (typeof(ConfigEntryBase).IsAssignableFrom(memberType) || typeof(Component).IsAssignableFrom(memberType) || typeof(GameObject).IsAssignableFrom(memberType) || typeof(Transform).IsAssignableFrom(memberType))
			{
				return true;
			}
			string text = memberName ?? string.Empty;
			if (text.IndexOf("config", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("setting", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("option", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("entry", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("property", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("cell", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("row", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("view", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("item", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			string text2 = memberType.FullName ?? memberType.Name ?? string.Empty;
			if (text2.IndexOf("PEAKLib.ModConfig", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("BepInEx", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			return false;
		}

		private static void RefreshOwnedConfigEntryCache()
		{
			_ownedConfigEntries.Clear();
			try
			{
				Plugin instance = Instance;
				ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((Object)(object)instance != (Object)null) ? ((BaseUnityPlugin)instance).Config : null);
				foreach (ConfigEntryBase item in configEntriesSnapshot)
				{
					_ownedConfigEntries.Add(item);
				}
			}
			catch
			{
			}
		}

		private static bool IsOwnedConfigEntry(ConfigEntryBase entry)
		{
			if (entry == null)
			{
				return false;
			}
			if (_ownedConfigEntries.Count == 0)
			{
				RefreshOwnedConfigEntryCache();
			}
			if (_ownedConfigEntries.Contains(entry))
			{
				return true;
			}
			try
			{
				Plugin instance = Instance;
				ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((Object)(object)instance != (Object)null) ? ((BaseUnityPlugin)instance).Config : null);
				foreach (ConfigEntryBase item in configEntriesSnapshot)
				{
					_ownedConfigEntries.Add(item);
				}
			}
			catch
			{
			}
			return _ownedConfigEntries.Contains(entry);
		}

		private static string GetCanonicalConfigSection(object instance)
		{
			ConfigEntryBase val = TryGetConfigEntryBaseFromSettingOption(instance);
			if (val == null)
			{
				return null;
			}
			string modConfigSectionForEntry = GetModConfigSectionForEntry(val);
			if (!string.IsNullOrWhiteSpace(modConfigSectionForEntry))
			{
				return modConfigSectionForEntry;
			}
			ConfigDefinition definition = val.Definition;
			if (definition == (ConfigDefinition)null)
			{
				return null;
			}
			return definition.Section;
		}

		private static string GetCanonicalConfigKey(object instance)
		{
			ConfigEntryBase val = TryGetConfigEntryBaseFromSettingOption(instance);
			if (val == null)
			{
				return null;
			}
			ConfigDefinition definition = val.Definition;
			if (definition == (ConfigDefinition)null)
			{
				return null;
			}
			return definition.Key;
		}

		private List<string> GetCurrentLocalizedSections()
		{
			List<string> list = new List<string>();
			foreach (string currentCanonicalSection in GetCurrentCanonicalSections())
			{
				list.Add(GetLocalizedModConfigSectionDisplayName(currentCanonicalSection));
			}
			return list;
		}

		private List<string> GetCurrentCanonicalSections()
		{
			List<string> list = new List<string>();
			ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config);
			if (configEntriesSnapshot.Length == 0)
			{
				return list;
			}
			foreach (string item in GetDesiredModConfigSectionOrder())
			{
				if (configEntriesSnapshot.Any((ConfigEntryBase entry) => ShouldExposeOwnedConfigEntry(entry) && string.Equals(GetModConfigSectionForEntry(entry), item, StringComparison.Ordinal)))
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static bool IsPrimaryZombieConfigEntry(ConfigEntryBase entry)
		{
			if (entry != ZombieBehaviorDifficulty && entry != ZombieKnockbackForce && entry != MaxZombies && entry != ZombieSpawnCount && entry != ZombieSpawnInterval)
			{
				return entry == ZombieMaxLifetime;
			}
			return true;
		}

		private static bool IsDerivedZombieConfigEntry(ConfigEntryBase entry)
		{
			if (entry != ZombieSpawnEnabled && entry != ZombieSpawnIntervalRandom && entry != ZombieSpawnRadius && entry != ZombieSpawnCountRandom && entry != ZombieDestroyDistance && entry != ZombieMoveSpeed && entry != ZombieAggressiveness && entry != DistanceBeforeWakeup && entry != DistanceBeforeChase && entry != ZombieSprintDistance && entry != ChaseTimeBeforeSprint && entry != ZombieLungeDistance && entry != ZombieTargetSearchInterval && entry != ZombieBiteRecoveryTime && entry != ZombieSamePlayerBiteCooldown && entry != ZombieLungeTime && entry != ZombieLungeRecoveryTime)
			{
				return entry == ZombieLookAngleBeforeWakeup;
			}
			return true;
		}

		private static bool IsZombieConfigEntry(ConfigEntryBase entry)
		{
			if (!IsPrimaryZombieConfigEntry(entry))
			{
				return IsDerivedZombieConfigEntry(entry);
			}
			return true;
		}

		private static bool ShouldExposeOwnedConfigEntry(ConfigEntryBase entry)
		{
			if (entry == null)
			{
				return false;
			}
			if (IsZombieConfigEntry(entry))
			{
				return IsPrimaryZombieConfigEntry(entry);
			}
			return true;
		}

		private string GetLocalizedModConfigSectionDisplayName(string section)
		{
			if (!TryGetLocalizedSectionDisplayName(section, IsChineseLanguage(), out var displayName))
			{
				return GetLocalizedSectionName(section, IsChineseLanguage());
			}
			return displayName;
		}

		[IteratorStateMachine(typeof(<GetDesiredModConfigSectionOrder>d__230))]
		private static IEnumerable<string> GetDesiredModConfigSectionOrder()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetDesiredModConfigSectionOrder>d__230(-2);
		}

		private static int GetModConfigSectionSortIndex(string section)
		{
			return NormalizeSectionAlias(section) switch
			{
				"Weapon" => 0, 
				"Zombie" => 1, 
				"Features" => 2, 
				"Zombie Spawn" => 3, 
				_ => 99, 
			};
		}

		private static int GetModConfigEntrySortIndex(ConfigEntryBase entry)
		{
			if (entry == ModEnabled)
			{
				return 0;
			}
			if (entry == WeaponEnabled)
			{
				return 100;
			}
			if (entry == WeaponSelection)
			{
				return 101;
			}
			if (entry == SpawnWeaponKey)
			{
				return 102;
			}
			if (entry == OpenConfigPanelKey)
			{
				return 103;
			}
			if (entry == ConfigPanelTheme)
			{
				return 104;
			}
			if (entry == FireInterval)
			{
				return 105;
			}
			if (entry == FireVolume)
			{
				return 106;
			}
			if (entry == AkSoundSelection)
			{
				return 107;
			}
			if (entry == ZombieTimeReduction)
			{
				return 108;
			}
			if (entry == WeaponModelScale)
			{
				return 190;
			}
			if (entry == WeaponModelPitch)
			{
				return 191;
			}
			if (entry == WeaponModelYaw)
			{
				return 192;
			}
			if (entry == WeaponModelRoll)
			{
				return 193;
			}
			if (entry == WeaponModelOffsetX)
			{
				return 194;
			}
			if (entry == WeaponModelOffsetY)
			{
				return 195;
			}
			if (entry == WeaponModelOffsetZ)
			{
				return 196;
			}
			if (entry == ZombieBehaviorDifficulty)
			{
				return 199;
			}
			if (entry == ZombieMoveSpeed)
			{
				return 200;
			}
			if (entry == ZombieAggressiveness)
			{
				return 201;
			}
			if (entry == ZombieKnockbackForce)
			{
				return 202;
			}
			if (entry == DistanceBeforeWakeup)
			{
				return 203;
			}
			if (entry == DistanceBeforeChase)
			{
				return 204;
			}
			if (entry == ZombieSprintDistance)
			{
				return 205;
			}
			if (entry == ChaseTimeBeforeSprint)
			{
				return 206;
			}
			if (entry == ZombieLungeDistance)
			{
				return 207;
			}
			if (entry == ZombieTargetSearchInterval)
			{
				return 208;
			}
			if (entry == ZombieBiteRecoveryTime)
			{
				return 209;
			}
			if (entry == ZombieSamePlayerBiteCooldown)
			{
				return 210;
			}
			if (entry == ZombieSpawnEnabled)
			{
				return 211;
			}
			if (entry == MaxZombies)
			{
				return 212;
			}
			if (entry == ZombieSpawnCount)
			{
				return 213;
			}
			if (entry == ZombieSpawnInterval)
			{
				return 214;
			}
			if (entry == ZombieMaxLifetime)
			{
				return 215;
			}
			if (entry == ZombieSpawnIntervalRandom)
			{
				return 216;
			}
			if (entry == ZombieSpawnCountRandom)
			{
				return 217;
			}
			if (entry == ZombieSpawnRadius)
			{
				return 218;
			}
			if (entry == ZombieDestroyDistance)
			{
				return 219;
			}
			return int.MaxValue;
		}

		private static string GetModConfigSectionForEntry(ConfigEntryBase entry)
		{
			if (entry == null)
			{
				return string.Empty;
			}
			if (entry == WeaponEnabled || entry == WeaponSelection || entry == WeaponModelScale || entry == SpawnWeaponKey || entry == FireInterval || entry == FireVolume || entry == AkSoundSelection || entry == ZombieTimeReduction)
			{
				return "Weapon";
			}
			if (entry == ZombieBehaviorDifficulty || entry == ZombieMoveSpeed || entry == ZombieAggressiveness || entry == ZombieKnockbackForce || entry == DistanceBeforeWakeup || entry == DistanceBeforeChase || entry == ZombieSprintDistance || entry == ChaseTimeBeforeSprint || entry == ZombieLungeDistance || entry == ZombieTargetSearchInterval || entry == ZombieBiteRecoveryTime || entry == ZombieSamePlayerBiteCooldown || entry == ZombieLungeTime || entry == ZombieLungeRecoveryTime || entry == ZombieLookAngleBeforeWakeup)
			{
				return "Zombie";
			}
			if (entry == MaxZombies || entry == ZombieSpawnInterval || entry == ZombieMaxLifetime || entry == ZombieDestroyDistance)
			{
				return "Zombie";
			}
			if (entry == ZombieSpawnEnabled || entry == ZombieSpawnIntervalRandom || entry == ZombieSpawnCount || entry == ZombieSpawnCountRandom || entry == ZombieSpawnRadius)
			{
				return "Zombie";
			}
			if (entry == ModEnabled || entry == OpenConfigPanelKey || entry == ConfigPanelTheme || entry == WeaponModelPitch || entry == WeaponModelYaw || entry == WeaponModelRoll || entry == WeaponModelOffsetX || entry == WeaponModelOffsetY || entry == WeaponModelOffsetZ)
			{
				return "Features";
			}
			ConfigDefinition definition = entry.Definition;
			return ((definition != (ConfigDefinition)null) ? definition.Section : null) ?? string.Empty;
		}

		private static string DescribeReflectionException(Exception ex)
		{
			if (ex == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			while (ex != null && num < 6)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(" --> ");
				}
				stringBuilder.Append(ex.GetType().Name);
				if (!string.IsNullOrWhiteSpace(ex.Message))
				{
					stringBuilder.Append(": ").Append(ex.Message);
				}
				ex = ex.InnerException;
				num++;
			}
			return stringBuilder.ToString();
		}

		private static bool TryCoerceInvokeArgument(Type parameterType, object value, out object coercedValue)
		{
			coercedValue = null;
			if (parameterType == null)
			{
				return false;
			}
			if (parameterType.IsByRef)
			{
				parameterType = parameterType.GetElementType();
				if (parameterType == null)
				{
					return false;
				}
			}
			Type type = Nullable.GetUnderlyingType(parameterType) ?? parameterType;
			if (value == null)
			{
				if (!type.IsValueType || Nullable.GetUnderlyingType(parameterType) != null)
				{
					coercedValue = null;
					return true;
				}
				return false;
			}
			if (type.IsInstanceOfType(value))
			{
				coercedValue = value;
				return true;
			}
			try
			{
				if (type.IsEnum)
				{
					if (value is string value2)
					{
						coercedValue = Enum.Parse(type, value2, ignoreCase: true);
						return true;
					}
					coercedValue = Enum.ToObject(type, value);
					return true;
				}
				if (value is IConvertible && typeof(IConvertible).IsAssignableFrom(type))
				{
					coercedValue = Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool TryBuildCompatibleInvokeArguments(MethodInfo method, object[] suppliedArguments, out object[] invokeArguments)
		{
			invokeArguments = null;
			if (method == null)
			{
				return false;
			}
			suppliedArguments = suppliedArguments ?? Array.Empty<object>();
			ParameterInfo[] parameters = method.GetParameters();
			if (suppliedArguments.Length > parameters.Length)
			{
				return false;
			}
			object[] array = new object[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterInfo parameterInfo = parameters[i];
				if (i < suppliedArguments.Length)
				{
					if (!TryCoerceInvokeArgument(parameterInfo.ParameterType, suppliedArguments[i], out array[i]))
					{
						return false;
					}
					continue;
				}
				if (parameterInfo.HasDefaultValue)
				{
					array[i] = parameterInfo.DefaultValue;
					continue;
				}
				Type type = (parameterInfo.ParameterType.IsByRef ? parameterInfo.ParameterType.GetElementType() : parameterInfo.ParameterType);
				if (type == typeof(PhotonMessageInfo))
				{
					array[i] = Activator.CreateInstance(type);
					continue;
				}
				return false;
			}
			invokeArguments = array;
			return true;
		}

		private static bool TryInvokeCompatibleInstanceMethod(object target, string methodName, out Exception failure, params object[] suppliedArguments)
		{
			failure = null;
			if (target == null || string.IsNullOrWhiteSpace(methodName))
			{
				return false;
			}
			MethodInfo[] array = (from method in target.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where string.Equals(method.Name, methodName, StringComparison.Ordinal)
				select method).OrderBy(delegate(MethodInfo method)
			{
				int num = method.GetParameters().Length;
				object[] array2 = suppliedArguments;
				return Math.Abs(num - ((array2 != null) ? array2.Length : 0));
			}).ThenBy((MethodInfo method) => method.GetParameters().Length).ToArray();
			foreach (MethodInfo methodInfo in array)
			{
				if (TryBuildCompatibleInvokeArguments(methodInfo, suppliedArguments, out var invokeArguments))
				{
					try
					{
						methodInfo.Invoke(target, invokeArguments);
						return true;
					}
					catch (Exception ex) when (ex is TargetParameterCountException || ex is ArgumentException)
					{
						failure = ex;
					}
					catch (TargetInvocationException ex2)
					{
						failure = ex2.InnerException ?? ex2;
						return false;
					}
					catch (Exception ex3)
					{
						failure = ex3;
						return false;
					}
				}
			}
			return false;
		}

		private void ReinitializeConfig()
		{
			if (_isRefreshingLanguage)
			{
				return;
			}
			_isRefreshingLanguage = true;
			try
			{
				bool isChinese = (_lastLanguageSetting = IsChineseLanguage());
				ApplyLocalizedConfigMetadata(isChinese);
				RefreshLocalizedConfigFiles(isChinese);
				if (!DisableModConfigRuntimePatches && IsModConfigUiRuntimeSafe())
				{
					TryLocalizeVisibleModConfigUi();
				}
				UpdateWeaponLobbyNotice();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[ShootZombies] ReinitializeConfig error: " + ex));
			}
			finally
			{
				_isRefreshingLanguage = false;
			}
		}

		public static void PlayGunshotSound(Vector3 position)
		{
			//IL_007d: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			if ((Object)(object)_gunshotSound == (Object)null)
			{
				return;
			}
			try
			{
				if (!(Time.time - _lastSoundTime < 0.05f))
				{
					_lastSoundTime = Time.time;
					if ((Object)(object)_sharedAudioSource == (Object)null)
					{
						GameObject val = new GameObject("AK47_GunshotSound");
						_sharedAudioSource = val.AddComponent<AudioSource>();
						_sharedAudioSource.spatialBlend = 1f;
						_sharedAudioSource.maxDistance = 100f;
						Object.DontDestroyOnLoad((Object)val);
					}
					((Component)_sharedAudioSource).transform.position = position;
					_sharedAudioSource.clip = _gunshotSound;
					_sharedAudioSource.volume = FireVolume.Value;
					float length = _gunshotSound.length;
					float value = FireInterval.Value;
					float num = 1f;
					if (value <= length)
					{
						float num2 = length / value;
						float num3 = Random.Range(-0.1f, 0.1f);
						num = num2 + num3;
					}
					else
					{
						num = 1f + Random.Range(-0.05f, 0.05f);
					}
					_sharedAudioSource.pitch = num;
					_sharedAudioSource.Play();
				}
			}
			catch (Exception)
			{
			}
		}

		private static void PlayFallbackGunshotSound(Vector3 position)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				AudioSource orCreateFallbackGunshotAudioSource = GetOrCreateFallbackGunshotAudioSource();
				if (!((Object)(object)orCreateFallbackGunshotAudioSource == (Object)null))
				{
					((Component)orCreateFallbackGunshotAudioSource).transform.position = position;
					orCreateFallbackGunshotAudioSource.volume = 0.8f;
					orCreateFallbackGunshotAudioSource.pitch = 1.4f;
					if ((Object)(object)orCreateFallbackGunshotAudioSource.clip != (Object)null)
					{
						orCreateFallbackGunshotAudioSource.Play();
					}
				}
			}
			catch
			{
			}
		}

		private static AudioSource GetOrCreateFallbackGunshotAudioSource()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			if ((Object)(object)_sharedFallbackGunshotAudioSource != (Object)null)
			{
				return _sharedFallbackGunshotAudioSource;
			}
			GameObject val = new GameObject("DefaultGunshotSound");
			_sharedFallbackGunshotAudioSource = val.AddComponent<AudioSource>();
			_sharedFallbackGunshotAudioSource.spatialBlend = 1f;
			_sharedFallbackGunshotAudioSource.rolloffMode = (AudioRolloffMode)1;
			_sharedFallbackGunshotAudioSource.minDistance = 1.5f;
			_sharedFallbackGunshotAudioSource.maxDistance = 100f;
			_sharedFallbackGunshotAudioSource.dopplerLevel = 0f;
			_sharedFallbackGunshotAudioSource.playOnAwake = false;
			Object.DontDestroyOnLoad((Object)val);
			return _sharedFallbackGunshotAudioSource;
		}

		private static AudioClip ResolveGunshotSoundClip(string selection = null)
		{
			string text = NormalizeAkSoundSelection(selection);
			if (!string.IsNullOrWhiteSpace(text) && _externalGunshotSounds.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				string.Equals(_currentGunshotSoundSelection, text, StringComparison.OrdinalIgnoreCase);
			}
			return _gunshotSound;
		}

		private static void PlayRemoteGunshotSound(Vector3 position, string selection = null)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			AudioClip val = ResolveGunshotSoundClip(selection);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				RemoteGunshotAudioInstance remoteGunshotAudioInstance = AcquireRemoteGunshotAudioInstance();
				if (remoteGunshotAudioInstance != null && !((Object)(object)remoteGunshotAudioInstance.Root == (Object)null) && !((Object)(object)remoteGunshotAudioInstance.AudioSource == (Object)null))
				{
					remoteGunshotAudioInstance.Root.transform.position = position;
					AudioSource audioSource = remoteGunshotAudioInstance.AudioSource;
					audioSource.volume = FireVolume.Value;
					audioSource.clip = val;
					float length = val.length;
					float value = FireInterval.Value;
					float num = ((value <= length) ? (length / value) : 1f);
					audioSource.pitch = Mathf.Clamp(num, 0.5f, 3f);
					audioSource.time = 0f;
					if (!remoteGunshotAudioInstance.Root.activeSelf)
					{
						remoteGunshotAudioInstance.Root.SetActive(true);
					}
					audioSource.Play();
					remoteGunshotAudioInstance.ReleaseAtTime = Time.time + Mathf.Max(val.length / Mathf.Max(audioSource.pitch, 0.01f), 0.3f) + 0.1f;
				}
			}
			catch (Exception)
			{
			}
		}

		private void Awake()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			try
			{
				bool flag = IsChineseLanguage();
				PreparePrimaryConfigFile();
				InitializePluginConfig();
				_loadedZombieBehaviorDifficultyMetadata = ReadStoredZombieBehaviorDifficultySelection();
				InitConfig();
				MigrateFeatureConfigDefinitions();
				MigrateLegacyLocalizedConfigEntries();
				ApplyLocalizedConfigMetadata(flag);
				RefreshLocalizedConfigFiles(flag);
				_lastLanguageSetting = flag;
				_cachedIsChineseLanguage = flag;
				_lastLanguagePollTime = Time.unscaledTime;
				LoadAk47BundleInAwake();
				Harmony val = new Harmony("com.github.Thanks.ShootZombies");
				val.PatchAll(Assembly.GetExecutingAssembly());
				PatchUpdatedRunMethods(val);
				PatchModConfigProcessEntriesBug(val);
				if (!DisableModConfigRuntimePatches)
				{
					PatchModConfigUiMethods(val);
				}
				InitializeRoomConfigCallbacks();
				SceneManager.sceneLoaded += OnSceneLoaded;
				((MonoBehaviour)this).StartCoroutine(DeferredInitialLocalizationRefresh());
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[ShootZombies] Awake failed: " + ex));
			}
		}

		private void InitializePluginConfig()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			try
			{
				string canonicalConfigPath = GetCanonicalConfigPath();
				if (string.IsNullOrWhiteSpace(canonicalConfigPath))
				{
					_pluginConfig = ((BaseUnityPlugin)this).Config;
					_pluginConfigPath = GetConfigFilePath(_pluginConfig);
					return;
				}
				string directoryName = Path.GetDirectoryName(canonicalConfigPath);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				_pluginConfig = new ConfigFile(canonicalConfigPath, true);
				FieldInfo? field = typeof(BaseUnityPlugin).GetField("<Config>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					throw new MissingFieldException("BepInEx.BaseUnityPlugin", "<Config>k__BackingField");
				}
				field.SetValue(this, _pluginConfig);
				_pluginConfigPath = GetConfigFilePath(_pluginConfig);
				if (string.IsNullOrWhiteSpace(_pluginConfigPath))
				{
					_pluginConfigPath = canonicalConfigPath;
				}
			}
			catch (Exception ex)
			{
				_pluginConfig = ((BaseUnityPlugin)this).Config;
				_pluginConfigPath = GetConfigFilePath(_pluginConfig);
				Log.LogWarning((object)("[ShootZombies] InitializePluginConfig failed, falling back to default config routing: " + DescribeReflectionException(ex)));
			}
		}

		[IteratorStateMachine(typeof(<DeferredInitialLocalizationRefresh>d__760))]
		private IEnumerator DeferredInitialLocalizationRefresh()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredInitialLocalizationRefresh>d__760(0)
			{
				<>4__this = this
			};
		}

		private static void CharacterUpdatePostfix(Character __instance)
		{
		}

		private void PatchUpdatedRunMethods(Harmony harmony)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (harmony == null)
			{
				return;
			}
			try
			{
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(Plugin), "UpdatedRunLifecyclePostfix", (Type[])null, (Type[])null));
				MethodInfo[] array = new MethodInfo[3]
				{
					AccessTools.Method(typeof(RunManager), "StartRun", Type.EmptyTypes, (Type[])null),
					AccessTools.Method(typeof(RunManager), "JumpToMiniRunBiomeWhenReady", Type.EmptyTypes, (Type[])null),
					AccessTools.Method(typeof(RunManager), "SetUpFromQuicksave", new Type[2]
					{
						typeof(Guid),
						typeof(float)
					}, (Type[])null)
				};
				foreach (MethodInfo methodInfo in array)
				{
					if (methodInfo != null)
					{
						harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] PatchUpdatedRunMethods failed: " + DescribeReflectionException(ex)));
			}
		}

		private void PatchModConfigProcessEntriesBug(Harmony harmony)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			if (harmony == null)
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = ResolveLoadedType("PEAKLib.ModConfig.ModConfigPlugin", "com.github.PEAKModding.PEAKLib.ModConfig")?.GetMethod("ProcessModEntries", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(Plugin), "ModConfigProcessModEntriesPrefix", Type.EmptyTypes, (Type[])null);
				if (methodInfo != null && methodInfo2 != null)
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] PatchModConfigProcessEntriesBug failed: " + DescribeReflectionException(ex)));
			}
		}

		private static bool ModConfigProcessModEntriesPrefix()
		{
			return !TryProcessModConfigEntriesWithoutEarlyReturn();
		}

		private static bool TryProcessModConfigEntriesWithoutEarlyReturn()
		{
			try
			{
				Type type = ResolveLoadedType("PEAKLib.ModConfig.ModConfigPlugin", "com.github.PEAKModding.PEAKLib.ModConfig");
				if (type == null)
				{
					return false;
				}
				Type type2 = type.Assembly.GetType("PEAKLib.ModConfig.Components.ModSectionNames");
				Type type3 = type.Assembly.GetType("PEAKLib.ModConfig.SettingsHandlerUtility");
				Type type4 = type.Assembly.GetType("PEAKLib.ModConfig.Components.ModKeyToName");
				if (type2 == null || type3 == null)
				{
					return false;
				}
				List<ConfigEntryBase> modConfigProcessedEntries = GetModConfigProcessedEntries(type);
				if (modConfigProcessedEntries == null)
				{
					return false;
				}
				IList modConfigModdedKeys = GetModConfigModdedKeys(type);
				MethodInfo method = type2.GetMethod("SetMod", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo method2 = type2.GetMethod("CheckSectionName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null || method2 == null)
				{
					return false;
				}
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				foreach (PluginInfo item in Chainloader.PluginInfos.Values.OrderBy(delegate(PluginInfo p)
				{
					BepInPlugin metadata2 = p.Metadata;
					return (metadata2 == null) ? null : metadata2.Name;
				}))
				{
					if ((Object)(object)((item != null) ? item.Instance : null) == (Object)null || item.Instance.Config == null)
					{
						continue;
					}
					BepInPlugin metadata = item.Metadata;
					string text = FixModConfigPluginName((metadata != null) ? metadata.Name : null);
					if (string.IsNullOrWhiteSpace(text) || !hashSet.Add(text))
					{
						continue;
					}
					object obj = method.Invoke(null, new object[1] { text });
					foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item2 in item.Instance.Config)
					{
						ConfigEntryBase value = item2.Value;
						if (value == null || !ShouldExposeModConfigEntry(value) || modConfigProcessedEntries.Contains(value))
						{
							continue;
						}
						try
						{
							method2.Invoke(obj, new object[1] { value.Definition.Section });
							RegisterModConfigEntry(type, type3, type4, modConfigModdedKeys, value, text);
							modConfigProcessedEntries.Add(value);
						}
						catch (Exception ex)
						{
							ManualLogSource log = Log;
							if (log != null)
							{
								log.LogWarning((object)("[ShootZombies] ModConfig entry registration failed for [" + text + "] " + value.Definition.Key + ": " + DescribeReflectionException(ex)));
							}
						}
					}
				}
				return true;
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[ShootZombies] TryProcessModConfigEntriesWithoutEarlyReturn failed: " + DescribeReflectionException(ex2)));
				}
				return false;
			}
		}

		private static List<ConfigEntryBase> GetModConfigProcessedEntries(Type modConfigPluginType)
		{
			return GetStaticModConfigMemberValue(modConfigPluginType, "EntriesProcessed", "<EntriesProcessed>k__BackingField") as List<ConfigEntryBase>;
		}

		private static IList GetModConfigModdedKeys(Type modConfigPluginType)
		{
			return GetStaticModConfigMemberValue(modConfigPluginType, "ModdedKeys", "<ModdedKeys>k__BackingField") as IList;
		}

		private static object GetStaticModConfigMemberValue(Type type, string propertyName, string fieldName)
		{
			if (type == null)
			{
				return null;
			}
			PropertyInfo property = type.GetProperty(propertyName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				return property.GetValue(null);
			}
			return type.GetField(fieldName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null);
		}

		private static bool ShouldExposeModConfigEntry(ConfigEntryBase entry)
		{
			object obj;
			if (entry == null)
			{
				obj = null;
			}
			else
			{
				ConfigDescription description = entry.Description;
				obj = ((description != null) ? description.Tags : null);
			}
			object[] array = (object[])obj;
			if (array != null)
			{
				return !array.Contains("Hidden");
			}
			return true;
		}

		private static void RegisterModConfigEntry(Type modConfigPluginType, Type settingsUtilityType, Type modKeyToNameType, IList moddedKeys, ConfigEntryBase entry, string tabName)
		{
			Type settingType = entry.SettingType;
			if (settingType == typeof(bool))
			{
				InvokeModConfigSettingMethod(settingsUtilityType, "AddBoolToTab", entry, tabName, (Action<bool>)delegate(bool newVal)
				{
					entry.BoxedValue = newVal;
				});
			}
			else if (settingType == typeof(float))
			{
				InvokeModConfigSettingMethod(settingsUtilityType, "AddFloatToTab", entry, tabName, (Action<float>)delegate(float newVal)
				{
					entry.BoxedValue = newVal;
				});
			}
			else if (settingType == typeof(double))
			{
				InvokeModConfigSettingMethod(settingsUtilityType, "AddDoubleToTab", entry, tabName, (Action<double>)delegate(double newVal)
				{
					entry.BoxedValue = newVal;
				});
			}
			else if (settingType == typeof(int))
			{
				InvokeModConfigSettingMethod(settingsUtilityType, "AddIntToTab", entry, tabName, (Action<int>)delegate(int newVal)
				{
					entry.BoxedValue = newVal;
				});
			}
			else if (settingType == typeof(string))
			{
				string text = (entry.DefaultValue as string) ?? string.Empty;
				if (text.Length > 4 && IsValidModConfigInputPath(modConfigPluginType, text))
				{
					TryAddModConfigModdedKey(modKeyToNameType, moddedKeys, entry, tabName);
				}
				Action<string> action = delegate(string newVal)
				{
					entry.BoxedValue = newVal;
				};
				ConfigDescription description = entry.Description;
				if (((description != null) ? description.AcceptableValues : null) is AcceptableValueList<string>)
				{
					InvokeModConfigSettingMethod(settingsUtilityType, "AddEnumToTab", entry, tabName, false, action);
				}
				else
				{
					InvokeModConfigSettingMethod(settingsUtilityType, "AddStringToTab", entry, tabName, action);
				}
			}
			else if (settingType == typeof(KeyCode))
			{
				TryAddModConfigModdedKey(modKeyToNameType, moddedKeys, entry, tabName);
				InvokeModConfigSettingMethod(settingsUtilityType, "AddKeybindToTab", entry, tabName, (Action<KeyCode>)delegate(KeyCode newVal)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					entry.BoxedValue = newVal;
				});
			}
			else if (settingType.IsEnum)
			{
				InvokeModConfigSettingMethod(settingsUtilityType, "AddEnumToTab", entry, tabName, true, (Action<string>)delegate(string newVal)
				{
					try
					{
						entry.BoxedValue = Enum.Parse(settingType, newVal);
					}
					catch
					{
					}
				});
			}
			else
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)$"[ShootZombies] Missing ModConfig SettingType: [Mod: {tabName}] {entry.Definition.Key} (Type: {entry.SettingType})");
				}
			}
		}

		private static void InvokeModConfigSettingMethod(Type settingsUtilityType, string methodName, params object[] args)
		{
			MethodInfo methodInfo = settingsUtilityType?.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (methodInfo == null)
			{
				throw new MissingMethodException(settingsUtilityType?.FullName ?? "PEAKLib.ModConfig.SettingsHandlerUtility", methodName);
			}
			try
			{
				methodInfo.Invoke(null, args);
			}
			catch (TargetInvocationException ex)
			{
				throw ex.InnerException ?? ex;
			}
		}

		private static void TryAddModConfigModdedKey(Type modKeyToNameType, IList moddedKeys, ConfigEntryBase entry, string tabName)
		{
			if (modKeyToNameType == null || moddedKeys == null || entry == null)
			{
				return;
			}
			try
			{
				ConstructorInfo constructor = modKeyToNameType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
				{
					typeof(ConfigEntryBase),
					typeof(string)
				}, null);
				if (constructor != null)
				{
					moddedKeys.Add(constructor.Invoke(new object[2] { entry, tabName }));
				}
			}
			catch
			{
			}
		}

		private static bool IsValidModConfigInputPath(Type modConfigPluginType, string path)
		{
			try
			{
				MethodInfo methodInfo = modConfigPluginType?.GetMethod("IsValidPath", BindingFlags.Static | BindingFlags.NonPublic);
				bool flag = default(bool);
				int num;
				if (methodInfo != null)
				{
					object obj = methodInfo.Invoke(null, new object[1] { path });
					if (obj is bool)
					{
						flag = (bool)obj;
						num = 1;
					}
					else
					{
						num = 0;
					}
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch
			{
				return false;
			}
		}

		private static string FixModConfigPluginName(string input)
		{
			input = input ?? string.Empty;
			input = Regex.Replace(input, "([a-z])([A-Z])", "$1 $2");
			input = Regex.Replace(input, "([A-Z])([A-Z][a-z])", "$1 $2");
			input = Regex.Replace(input, "\\s+", " ");
			input = Regex.Replace(input, "([A-Z]\\.)\\s([A-Z]\\.)", "$1$2");
			return input.Trim();
		}

		private static void UpdatedRunLifecyclePostfix()
		{
			try
			{
				_cachedHeldBlowgunItem = null;
				_lastHeldBlowgunSearchTime = -10f;
				RequestAkVisualRefresh();
				TryScheduleDelayedBlowgunReplacement();
				ClearLocalAmbientColdStatus();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] UpdatedRunLifecyclePostfix failed: " + ex.Message));
			}
		}

		private void LoadAk47BundleInAwake()
		{
			try
			{
				LoadBundleInternal();
				if (!HasAkVisualPrefab())
				{
					TryLoadLightweightAkResources();
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[ShootZombies] LoadAk47BundleInAwake error: " + ex));
			}
		}

		private static bool IsLobbyScene(Scene scene)
		{
			if (((Scene)(ref scene)).name != null)
			{
				return ((Scene)(ref scene)).name.Contains("Airport");
			}
			return false;
		}

		private static bool IsTitleScene(Scene scene)
		{
			if (((Scene)(ref scene)).name != null)
			{
				if (!((Scene)(ref scene)).name.Contains("Pretitle"))
				{
					return ((Scene)(ref scene)).name.Contains("Title");
				}
				return true;
			}
			return false;
		}

		private static bool IsGameplayScene(Scene scene)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (((Scene)(ref scene)).name != null && !IsTitleScene(scene))
			{
				return !IsLobbyScene(scene);
			}
			return false;
		}

		internal static bool IsGameplaySceneRuntime(Scene scene)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsGameplayScene(scene);
		}

		internal static bool IsLobbySceneRuntime(Scene scene)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsLobbyScene(scene);
		}

		internal static bool IsTitleSceneRuntime(Scene scene)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsTitleScene(scene);
		}

		private static bool IsModConfigUiRuntimeSafeScene(Scene scene)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!((Scene)(ref scene)).IsValid() || !((Scene)(ref scene)).isLoaded)
			{
				return false;
			}
			return !IsGameplayScene(scene);
		}

		private static bool IsModConfigUiRuntimeSafe()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsModConfigUiRuntimeSafeScene(SceneManager.GetActiveScene());
		}

		private static void BeginSceneRuntimeWarmup(Scene scene)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			float num = 0.5f;
			if (IsGameplayScene(scene))
			{
				num = 10f;
			}
			else if (IsLobbyScene(scene))
			{
				num = 1.5f;
			}
			_sceneWarmupSceneName = ((Scene)(ref scene)).name ?? string.Empty;
			_sceneWarmupUntilUnscaledTime = Time.unscaledTime + num;
			ItemUIDataPatch.ResetVisibleUiTrackingFallback();
		}

		private static void RequestAkVisualRefresh(bool includeUiRefresh = true, bool forceRefresh = false)
		{
			_pendingAkVisualRefresh = true;
			if (forceRefresh)
			{
				_pendingAkVisualForceRefresh = true;
			}
			if (includeUiRefresh)
			{
				_pendingAkUiRefresh = true;
			}
		}

		internal static bool IsRuntimeVisualRefreshBlocked()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsRuntimeVisualRefreshBlocked(SceneManager.GetActiveScene());
		}

		internal static bool IsRuntimeVisualRefreshBlocked(Scene scene)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (!((Scene)(ref scene)).IsValid() || !((Scene)(ref scene)).isLoaded)
			{
				return true;
			}
			if (Time.unscaledTime < _sceneWarmupUntilUnscaledTime)
			{
				string a = ((Scene)(ref scene)).name ?? string.Empty;
				if (string.IsNullOrEmpty(_sceneWarmupSceneName) || string.Equals(a, _sceneWarmupSceneName, StringComparison.Ordinal))
				{
					return true;
				}
			}
			if (IsGameplayScene(scene) && (Object)Character.localCharacter == (Object)null)
			{
				return true;
			}
			return false;
		}

		private static bool IsFogRuntimeReady()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsFogRuntimeReady(SceneManager.GetActiveScene());
		}

		private static bool IsFogRuntimeReady(Scene scene)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0041: Expected O, but got Unknown
			if (!((Scene)(ref scene)).IsValid() || !((Scene)(ref scene)).isLoaded || !IsGameplayScene(scene))
			{
				return false;
			}
			if (IsRuntimeVisualRefreshBlocked(scene))
			{
				return false;
			}
			Character val = _localCharacter ?? Character.localCharacter;
			if ((Object)val == (Object)null || val.isZombie || val.isBot)
			{
				return false;
			}
			return true;
		}

		private static string GetSceneBucket(Scene scene)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (IsTitleScene(scene))
			{
				return "title";
			}
			if (IsLobbyScene(scene))
			{
				return "lobby";
			}
			if (IsGameplayScene(scene))
			{
				return "gameplay";
			}
			return "other";
		}

		private static int ScoreBaseWeaponItem(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return 0;
			}
			if (IsGuaranteedBlowgunItem(item))
			{
				return 10000;
			}
			string text = (((Object)((Component)item).gameObject).name ?? string.Empty).ToLowerInvariant();
			string text2 = (item.UIData?.itemName ?? string.Empty).ToLowerInvariant();
			if (text.Contains("ak"))
			{
				return 0;
			}
			int num = 0;
			num += ScoreActionProfile(item);
			int num2;
			if (!text.Contains("blowgun"))
			{
				num2 = (text2.Contains("blowgun") ? 1 : 0);
				if (num2 == 0)
				{
					goto IL_0099;
				}
			}
			else
			{
				num2 = 1;
			}
			num += 1500;
			goto IL_0099;
			IL_0099:
			if (text.Contains("healingdart") || text2.Contains("healingdart"))
			{
				num += 120;
			}
			if (text.Contains("dart") || text2.Contains("dart"))
			{
				num += 40;
			}
			if (num2 == 0 && text.Contains("variant"))
			{
				num -= 120;
			}
			if (num2 == 0 && (text.Contains("projectile") || text.Contains("ammo")))
			{
				num -= 220;
			}
			return Mathf.Max(num, 0);
		}

		private static int ScoreActionProfile(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return 0;
			}
			int num = 0;
			try
			{
				bool flag = false;
				bool flag2 = false;
				ItemActionBase[] componentsInChildren = ((Component)item).GetComponentsInChildren<ItemActionBase>(true);
				foreach (ItemActionBase val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null))
					{
						switch (((object)val).GetType().Name)
						{
						case "Action_RaycastDart":
							flag = true;
							break;
						case "Action_Consume":
						case "Action_ConsumeAndSpawn":
							flag2 = true;
							break;
						}
					}
				}
				if (flag)
				{
					num += 2500;
				}
				if (flag2)
				{
					num -= 2200;
				}
			}
			catch
			{
			}
			return num;
		}

		private static bool IsGuaranteedBlowgunItem(Item item)
		{
			return BlowgunInfiniteUsePatch.IsBlowgunItem(item);
		}

		private Canvas ResolveHudCanvas()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			TextMeshProUGUI val = (((Object)(object)instance.itemPromptMain != (Object)null) ? instance.itemPromptMain : instance.interactNameText);
			Canvas val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponentInParent<Canvas>() : null);
			Canvas[] componentsInChildren = ((Component)instance).GetComponentsInChildren<Canvas>(true);
			Canvas val3 = null;
			float num = -1f;
			Canvas[] array = componentsInChildren;
			foreach (Canvas val4 in array)
			{
				if ((Object)(object)val4 == (Object)null)
				{
					continue;
				}
				RectTransform component = ((Component)val4).GetComponent<RectTransform>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				Rect rect = component.rect;
				float num2 = Mathf.Abs(((Rect)(ref rect)).width * ((Rect)(ref rect)).height);
				if (!(num2 < 1f))
				{
					if (val4.isRootCanvas)
					{
						num2 += 1000000f;
					}
					if (((Component)val4).gameObject.activeInHierarchy)
					{
						num2 += 500000f;
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)val4 == (Object)(object)val2)
					{
						num2 += 250000f;
					}
					if (num2 > num)
					{
						num = num2;
						val3 = val4;
					}
				}
			}
			if ((Object)(object)val3 != (Object)null)
			{
				return val3;
			}
			return val2;
		}

		private TextMeshProUGUI ResolveHudTextStyleSource()
		{
			GUIManager instance = GUIManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			if ((Object)(object)instance.itemPromptMain != (Object)null)
			{
				return instance.itemPromptMain;
			}
			if ((Object)(object)instance.interactNameText != (Object)null)
			{
				return instance.interactNameText;
			}
			return instance.interactPromptText;
		}

		private void ApplyGameTextStyle(TextMeshProUGUI target, Color color, float sizeMultiplier = 1f, float? customLineSpacing = null)
		{
			//IL_008e: 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)
			if (!((Object)(object)target == (Object)null))
			{
				TextMeshProUGUI val = ResolveHudTextStyleSource();
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)target).font = ((TMP_Text)val).font;
					((TMP_Text)target).fontSharedMaterial = ((TMP_Text)val).fontSharedMaterial;
					((TMP_Text)target).fontStyle = ((TMP_Text)val).fontStyle;
					((TMP_Text)target).characterSpacing = ((TMP_Text)val).characterSpacing;
					((TMP_Text)target).wordSpacing = ((TMP_Text)val).wordSpacing;
					((TMP_Text)target).lineSpacing = customLineSpacing ?? ((TMP_Text)val).lineSpacing;
					((TMP_Text)target).textWrappingMode = (TextWrappingModes)0;
				}
				((TMP_Text)target).fontSize = 18f * sizeMultiplier;
				((Graphic)target).color = color;
				((TMP_Text)target).alignment = (TextAlignmentOptions)257;
			}
		}

		private static void ApplyBottomLeftAnchoredRect(RectTransform target, RectTransform canvasRect, float width, float height, float scale, float x, float y)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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)
			if (!((Object)(object)target == (Object)null) && !((Object)(object)canvasRect == (Object)null))
			{
				((Transform)target).localScale = Vector3.one * Mathf.Max(scale, 0.3f);
				target.anchorMin = new Vector2(0f, 0f);
				target.anchorMax = new Vector2(0f, 0f);
				target.pivot = new Vector2(0f, 0f);
				target.sizeDelta = new Vector2(width, height);
				Rect rect = canvasRect.rect;
				float num = height * Mathf.Max(scale, 0.3f);
				float num2 = y + 108f;
				float num3 = Mathf.Min(((Rect)(ref rect)).width * 0.25f, 320f);
				float num4 = Mathf.Min(((Rect)(ref rect)).height * 0.25f, 220f);
				float num5 = Mathf.Clamp(x, 0f - num3, ((Rect)(ref rect)).width + num3);
				float num6 = Mathf.Clamp(num2, 0f - num4, ((Rect)(ref rect)).height + num4) - num;
				target.anchoredPosition = new Vector2(num5, num6);
			}
		}

		private static void ApplyRightMiddleRect(RectTransform target, float width, float height, float rightOffset, float downOffset)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				((Transform)target).localScale = Vector3.one;
				target.anchorMin = new Vector2(1f, 0.5f);
				target.anchorMax = new Vector2(1f, 0.5f);
				target.pivot = new Vector2(1f, 0.5f);
				target.sizeDelta = new Vector2(width, height);
				target.anchoredPosition = new Vector2(0f - rightOffset, 0f - downOffset);
			}
		}

		private static void ApplyRightBottomRect(RectTransform target, float width, float height, float rightOffset, float bottomOffset)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				((Transform)target).localScale = Vector3.one;
				target.anchorMin = new Vector2(1f, 0f);
				target.anchorMax = new Vector2(1f, 0f);
				target.pivot = new Vector2(1f, 0f);
				target.sizeDelta = new Vector2(width, height);
				target.anchoredPosition = new Vector2(0f - rightOffset, bottomOffset);
			}
		}

		private static string GetFogModeLobbyNoticeTextCore(bool isChinese)
		{
			return string.Empty;
		}

		private void ClampFogModeLobbyNoticeToCanvas()
		{
			if (!((Object)(object)_fogModeLobbyNoticeRect == (Object)null))
			{
				string text = NormalizeLocalizedText(((Object)(object)_fogModeLobbyNoticeText != (Object)null) ? ((TMP_Text)_fogModeLobbyNoticeText).text : _lastFogModeLobbyNoticeText);
				ApplySharedFogBottomLeftLayout(_fogModeLobbyNoticeRect, 700f, GetLobbyNoticePreferredHeight(text));
			}
		}

		private void UpdateFogModeLobbyNotice()
		{
			CleanupFogModeLobbyNotice();
		}

		private void ClampWeaponLobbyNoticeToCanvas()
		{
			if (!((Object)(object)_weaponLobbyNoticeRect == (Object)null))
			{
				string text = NormalizeLocalizedText(((Object)(object)_weaponLobbyNoticeText != (Object)null) ? ((TMP_Text)_weaponLobbyNoticeText).text : _lastWeaponLobbyNoticeText);
				ApplyDefaultWeaponLobbyNoticeStyle();
				Canvas val = ResolveHudCanvas();
				if (!((Object)(object)val != (Object)null) || !TryAnchorWeaponLobbyNoticeToCompassPrompt(val, text))
				{
					ApplyRightMiddleRect(_weaponLobbyNoticeRect, 735f, GetScaledWeaponLobbyNoticePreferredHeight(text), 28f, 96f);
				}
			}
		}

		private void UpdateWeaponLobbyNotice()
		{
			if (!ShouldShowWeaponLobbyNotice())
			{
				CleanupWeaponLobbyNotice();
				return;
			}
			if ((Object)(object)_weaponLobbyNoticeObject == (Object)null || (Object)(object)_weaponLobbyNoticeText == (Object)null || !((Object)(object)_weaponLobbyNoticeObject.transform.parent != (Object)null))
			{
				CreateWeaponLobbyNotice();
			}
			if (!((Object)(object)_weaponLobbyNoticeText == (Object)null))
			{
				string text = NormalizeLocalizedText(GetLobbyWeaponNoticeTextCore(GetCachedChineseLanguageSetting()));
				bool flag = false;
				if (!string.Equals(_lastWeaponLobbyNoticeText, text, StringComparison.Ordinal))
				{
					_lastWeaponLobbyNoticeText = text;
					((TMP_Text)_weaponLobbyNoticeText).text = text;
					flag = true;
				}
				if (flag || Time.unscaledTime - _lastWeaponLobbyNoticeLayoutTime >= 1f)
				{
					ClampWeaponLobbyNoticeToCanvas();
					_lastWeaponLobbyNoticeLayoutTime = Time.unscaledTime;
				}
				_weaponLobbyNoticeObject.SetActive(true);
			}
		}

		private void CreateFogModeLobbyNotice()
		{
			CleanupFogModeLobbyNotice();
		}

		private void CreateWeaponLobbyNotice()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			CleanupWeaponLobbyNotice();
			Canvas val = ResolveHudCanvas();
			if (!((Object)(object)val == (Object)null))
			{
				GameObject val2 = new GameObject("WeaponLobbyNotice");
				val2.transform.SetParent(((Component)val).transform, false);
				RectTransform obj = (_weaponLobbyNoticeRect = val2.AddComponent<RectTransform>());
				obj.anchoredPosition = Vector2.zero;
				string text = NormalizeLocalizedText(GetLobbyWeaponNoticeTextCore(GetCachedChineseLanguageSetting()));
				obj.sizeDelta = new Vector2(735f, GetScaledWeaponLobbyNoticePreferredHeight(text));
				_weaponLobbyNoticeObject = val2;
				_weaponLobbyNoticeText = val2.AddComponent<TextMeshProUGUI>();
				ApplyDefaultWeaponLobbyNoticeStyle();
				_lastWeaponLobbyNoticeText = text;
				((TMP_Text)_weaponLobbyNoticeText).text = _lastWeaponLobbyNoticeText;
				ClampWeaponLobbyNoticeToCanvas();
				_lastWeaponLobbyNoticeLayoutTime = Time.unscaledTime;
			}
		}

		private static void CleanupFogModeLobbyNotice()
		{
			if ((Object)(object)_fogModeLobbyNoticeObject != (Object)null)
			{
				Object.Destroy((Object)(object)_fogModeLobbyNoticeObject);
			}
			_fogModeLobbyNoticeObject = null;
			_fogModeLobbyNoticeText = null;
			_fogModeLobbyNoticeRect = null;
			_lastFogModeLobbyNoticeText = string.Empty;
			CleanupSharedFogBottomLeftRootIfUnused();
		}

		private static void CleanupWeaponLobbyNotice()
		{
			if ((Object)(object)_weaponLobbyNoticeObject != (Object)null)
			{
				Object.Destroy((Object)(object)_weaponLobbyNoticeObject);
			}
			_weaponLobbyNoticeObject = null;
			_weaponLobbyNoticeText = null;
			_weaponLobbyNoticeRect = null;
			_lastWeaponLobbyNoticeText = string.Empty;
			_lastWeaponLobbyNoticeLayoutTime = -10f;
		}

		private void ApplyDefaultWeaponLobbyNoticeStyle()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_weaponLobbyNoticeText == (Object)null))
			{
				ApplyGameTextStyle(_weaponLobbyNoticeText, new Color(1f, 0.94f, 0.72f), 1.2f, 1.125f);
				((TMP_Text)_weaponLobbyNoticeText).fontStyle = (FontStyles)0;
				((TMP_Text)_weaponLobbyNoticeText).alignment = (TextAlignmentOptions)4100;
				((TMP_Text)_weaponLobbyNoticeText).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)_weaponLobbyNoticeText).overflowMode = (TextOverflowModes)0;
			}
		}

		private TextMeshProUGUI ResolveLobbyCompassPromptText(Canvas hudCanvas)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hudCanvas == (Object)null)
			{
				return null;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)hudCanvas).GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI val = null;
			int num = int.MinValue;
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val2 in array)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2 == (Object)(object)_weaponLobbyNoticeText)
				{
					continue;
				}
				string text = NormalizeLocalizedText(StripRichText(((TMP_Text)val2).text)).ToLowerInvariant();
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				int num2 = 0;
				if (!text.Contains("指南针") && !text.Contains("compass") && !text.Contains("罗盘"))
				{
					continue;
				}
				num2 += 240;
				if (text.Contains("按") || text.Contains("press"))
				{
					num2 += 80;
				}
				if (text.Contains("生成") || text.Contains("spawn") || text.Contains("get"))
				{
					num2 += 50;
				}
				string text2 = (((Object)val2).name ?? string.Empty).ToLowerInvariant();
				if (text2.Contains("prompt") || text2.Contains("interact") || text2.Contains("hint"))
				{
					num2 += 20;
				}
				RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
				if ((Object)(object)rectTransform != (Object)null)
				{
					Vector3 position = ((Transform)rectTransform).position;
					if (position.y > (float)Screen.height * 0.35f)
					{
						num2 += 25;
					}
					if (position.x > (float)Screen.width * 0.35f)
					{
						num2 += 25;
					}
					Rect rect = rectTransform.rect;
					if (((Rect)(ref rect)).width > 60f && ((Rect)(ref rect)).width < 1200f)
					{
						num2 += 10;
					}
				}
				if (num2 > num)
				{
					num = num2;
					val = val2;
				}
			}
			if ((Object)(object)val != (Object)null && num >= 300)
			{
				return val;
			}
			return null;
		}

		private bool TryAnchorWeaponLobbyNoticeToCompassPrompt(Canvas hudCanvas, string text)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_007d: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: 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)hudCanvas == (Object)null || (Object)(object)_weaponLobbyNoticeRect == (Object)null || (Object)(object)_weaponLobbyNoticeText == (Object)null)
			{
				return false;
			}
			TextMeshProUGUI val = ResolveLobbyCompassPromptText(hudCanvas);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			RectTransform rectTransform = ((TMP_Text)val).rectTransform;
			if ((Object)(object)rectTransform == (Object)null || !(((Transform)rectTransform).parent is RectTransform))
			{
				return false;
			}
			RectTransform val2 = (RectTransform)((Transform)rectTransform).parent;
			if ((Object)((Transform)_weaponLobbyNoticeRect).parent != (Object)val2)
			{
				((Transform)_weaponLobbyNoticeRect).SetParent((Transform)(object)val2, false);
			}
			((TMP_Text)_weaponLobbyNoticeText).fontSize = ((TMP_Text)val).fontSize;
			((TMP_Text)_weaponLobbyNoticeText).fontStyle = ((TMP_Text)val).fontStyle;
			((TMP_Text)_weaponLobbyNoticeText).alignment = ((TMP_Text)val).alignment;
			((TMP_Text)_weaponLobbyNoticeText).lineSpacing = ((TMP_Text)val).lineSpacing;
			((TMP_Text)_weaponLobbyNoticeText).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)_weaponLobbyNoticeText).overflowMode = (TextOverflowModes)0;
			Canvas.ForceUpdateCanvases();
			float num = Mathf.Clamp(((TMP_Text)_weaponLobbyNoticeText).preferredWidth + 24f, 120f, 420f);
			float num2 = Mathf.Max(((TMP_Text)_weaponLobbyNoticeText).preferredHeight + 8f, GetWeaponLobbyNoticePreferredHeight(text));
			_weaponLobbyNoticeRect.anchorMin = rectTransform.anchorMin;
			_weaponLobbyNoticeRect.anchorMax = rectTransform.anchorMax;
			_weaponLobbyNoticeRect.pivot = rectTransform.pivot;
			_weaponLobbyNoticeRect.sizeDelta = new Vector2(num, num2);
			Vector2 anchoredPosition = rectTransform.anchoredPosition;
			Rect rect = rectTransform.rect;
			float num3 = ((Rect)(ref rect)).height * 0.5f + num2 * 0.5f + 2f;
			_weaponLobbyNoticeRect.anchoredPosition = new Vector2(anchoredPosition.x, anchoredPosition.y - num3);
			((Transform)_weaponLobbyNoticeRect).SetAsLastSibling();
			return true;
		}

		private static RectTransform ResolveSharedFogBottomLeftRoot(Canvas hudCanvas)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0086: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hudCanvas == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_sharedFogBottomLeftRootRect == (Object)null || (Object)(object)_sharedFogBottomLeftRootObject == (Object)null)
			{
				GameObject val = new GameObject("ShootZombiesFogBottomLeftRoot");
				_sharedFogBottomLeftRootObject = val;
				_sharedFogBottomLeftRootRect = val.AddComponent<RectTransform>();
			}
			Transform transform = ((Component)hudCanvas).transform;
			if ((Object)(object)_sharedFogBottomLeftRootCanvas != (Object)(object)hudCanvas || (Object)(object)_sharedFogBottomLeftRootObject.transform.parent != (Object)(object)transform)
			{
				_sharedFogBottomLeftRootObject.transform.SetParent(transform, false);
			}
			_sharedFogBottomLeftRootCanvas = hudCanvas;
			((Transform)_sharedFogBottomLeftRootRect).localScale = Vector3.one;
			_sharedFogBottomLeftRootRect.anchorMin = Vector2.zero;
			_sharedFogBottomLeftRootRect.anchorMax = Vector2.one;
			_sharedFogBottomLeftRootRect.pivot = new Vector2(0.5f, 0.5f);
			_sharedFogBottomLeftRootRect.offsetMin = Vector2.zero;
			_sharedFogBottomLeftRootRect.offsetMax = Vector2.zero;
			_sharedFogBottomLeftRootRect.anchoredPosition = Vector2.zero;
			_sharedFogBottomLeftRootObject.transform.SetAsLastSibling();
			return _sharedFogBottomLeftRootRect;
		}

		private static void CleanupSharedFogBottomLeftRootIfUnused()
		{
			if (!((Object)(object)_fogUIContainerRect != (Object)null) && !((Object)(object)_fogModeLobbyNoticeRect != (Object)null))
			{
				CleanupSharedFogBottomLeftRoot();
			}
		}

		private static void CleanupSharedFogBottomLeftRoot()
		{
			if ((Object)(object)_sharedFogBottomLeftRootObject != (Object)null)
			{
				Object.Destroy((Object)(object)_sharedFogBottomLeftRootObject);
			}
			_sharedFogBottomLeftRootObject = null;
			_sharedFogBottomLeftRootRect = null;
			_sharedFogBottomLeftRootCanvas = null;
		}

		private static float GetLobbyNoticePreferredHeight(string text)
		{
			if (text == null || !text.Contains("\n"))
			{
				return 108f;
			}
			return 166f;
		}

		private static float GetWeaponLobbyNoticePreferredHeight(string text)
		{
			if (text == null || !text.Contains("\n"))
			{
				return 56f;
			}
			return 96f;
		}

		private static float GetScaledWeaponLobbyNoticePreferredHeight(string text)
		{
			return GetLobbyNoticePreferredHeight(text) * 0.75f;
		}

		private RectTransform ResolveVersionLabelRect(Canvas hudCanvas, bool forceRefresh = false)
		{
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: 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)
			if ((Object)(object)hudCanvas == (Object)null)
			{
				return null;
			}
			if (!forceRefresh && (Object)(object)_cachedVersionLabelRect != (Object)null && (Object)(object)((Component)_cachedVersionLabelRect).GetComponentInParent<Canvas>() == (Object)(object)hudCanvas && ((Component)_cachedVersionLabelRect).gameObject.activeInHierarchy)
			{
				return _cachedVersionLabelRect;
			}
			if (!forceRefresh && Time.unscaledTime - _lastVersionLabelSearchTime < 1f)
			{
				return null;
			}
			_lastVersionLabelSearchTime = Time.unscaledTime;
			TextMeshProUGUI[] componentsInChildren = ((Component)hudCanvas).GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI val = null;
			int num = int.MinValue;
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val2 in array)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string text = StripRichText(((TMP_Text)val2).text);
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				string text2 = text.ToLowerInvariant();
				string text3 = (((Object)val2).name ?? string.Empty).ToLowerInvariant() ?? string.Empty;
				int num2 = 0;
				if (text2.Contains("1.54"))
				{
					num2 += 320;
				}
				if (text2.Contains("version") || text2.Contains("ver"))
				{
					num2 += 150;
				}
				if (LooksLikeVersionToken(text2))
				{
					num2 += 120;
				}
				if (text3.Contains("version") || text3.Contains("ver"))
				{
					num2 += 80;
				}
				if (text2.Contains("fog") || text2.Contains("speed") || text2.Contains("actual"))
				{
					num2 -= 320;
				}
				if (text3.Contains("fog") || text3.Contains("timer") || text3.Contains("shootzombies"))
				{
					num2 -= 320;
				}
				if (text.Length <= 16)
				{
					num2 += 20;
				}
				RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
				if ((Object)(object)rectTransform != (Object)null)
				{
					if (((Component)rectTransform).transform.position.y > (float)Screen.height * 0.45f)
					{
						num2 += 15;
					}
					Rect rect = rectTransform.rect;
					if (((Rect)(ref rect)).width > 8f)
					{
						rect = rectTransform.rect;
						if (((Rect)(ref rect)).width < 320f)
						{
							num2 += 10;
						}
					}
				}
				if (num2 > num)
				{
					num = num2;
					val = val2;
				}
			}
			if ((Object)(object)val != (Object)null && num >= 120)
			{
				_cachedVersionLabelRect = ((TMP_Text)val).rectTransform;
				return _cachedVersionLabelRect;
			}
			_cachedVersionLabelRect = null;
			return null;
		}

		private bool TryAnchorFogUiToVersion(RectTransform containerRect, Canvas hudCanvas, bool forceRefresh = false)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0073: 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_009d: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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)
			if ((Object)(object)containerRect == (Object)null || (Object)(object)hudCanvas == (Object)null)
			{
				return false;
			}
			RectTransform val = ResolveVersionLabelRect(hudCanvas, forceRefresh);
			if ((Object)(object)val == (Object)null || (Object)(object)((Transform)val).parent == (Object)null)
			{
				return false;
			}
			RectTransform val2 = (RectTransform)((Transform)val).parent;
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			if ((Object)((Transform)containerRect).parent != (Object)(object)val2)
			{
				((Transform)containerRect).SetParent((Transform)(object)val2, false);
			}
			containerRect.anchorMin = new Vector2(0f, 1f);
			containerRect.anchorMax = new Vector2(0f, 1f);
			containerRect.pivot = new Vector2(0f, 1f);
			Canvas.ForceUpdateCanvases();
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array);
			Vector3 val3 = array[2];
			TextMeshProUGUI component = ((Component)val).GetComponent<TextMeshProUGUI>();
			Rect rect = val.rect;
			float num = ((Rect)(ref rect)).width;
			if ((Object)(object)component != (Object)null)
			{
				num = Mathf.Max(num, ((TMP_Text)component).preferredWidth);
			}
			float num2 = Mathf.Max(28f, num * 0.08f);
			Vector3 val4 = val3 + ((Component)val).transform.right * num2;
			Vector3 val5 = ((Transform)val2).InverseTransformPoint(val4);
			float x = val5.x;
			rect = val2.rect;
			float num3 = x + ((Rect)(ref rect)).width * val2.pivot.x;
			float y = val5.y;
			rect = val2.rect;
			float num4 = y - ((Rect)(ref rect)).height * (1f - val2.pivot.y);
			containerRect.anchoredPosition = new Vector2(num3 + -8f, num4 + 4f);
			((Transform)containerRect).SetAsLastSibling();
			return true;
		}

		private static string StripRichText(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			bool flag = false;
			foreach (char c in value)
			{
				switch (c)
				{
				case '<':
					flag = true;
					continue;
				case '>':
					flag = false;
					continue;
				}
				if (!flag)
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().Trim();
		}

		private static bool LooksLikeVersionToken(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			char[] separator = new char[17]
			{
				' ', '\n', '\r', '\t', '|', ':', '(', ')', '[', ']',
				'-', '_', '/', '\\', ',', ';', '!'
			};
			string[] array = value.Split(separator, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim().ToLowerInvariant();
				if (text.Length < 3 || text.Length > 10 || !text.Contains("."))
				{
					continue;
				}
				bool flag = false;
				bool flag2 = true;
				string text2 = text;
				foreach (char c in text2)
				{
					if (char.IsDigit(c))
					{
						flag = true;
						continue;
					}
					switch (c)
					{
					case '.':
					case 'a':
					case 'b':
					case 'c':
					case 'd':
					case 'e':
					case 'f':
					case 'g':
					case 'h':
					case 'i':
					case 'j':
					case 'k':
					case 'l':
					case 'm':
					case 'n':
					case 'o':
					case 'p':
					case 'q':
					case 'r':
					case 's':
					case 't':
					case 'u':
					case 'v':
					case 'w':
					case 'x':
					case 'y':
					case 'z':
						continue;
					}
					flag2 = false;
					break;
				}
				if (flag2 && flag)
				{
					return true;
				}
			}
			return false;
		}

		private void ClampFogUIToCanvas()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = _fogUIContainerRect;
			if ((Object)(object)val == (Object)null && (Object)(object)_fogUIObject != (Object)null && (Object)(object)_fogUIObject.transform.parent != (Object)null)
			{
				val = (_fogUIContainerRect = ((Component)_fogUIObject.transform.parent).GetComponent<RectTransform>());
			}
			if (!((Object)(object)val == (Object)null))
			{
				ApplySharedFogBottomLeftLayout(val, val.sizeDelta.x, val.sizeDelta.y);
			}
		}

		private void ApplySharedFogBottomLeftLayout(RectTransform target, float width, float height)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_005c: Expected O, but got Unknown
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			Canvas val = ResolveHudCanvas();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)target).GetComponentInParent<Canvas>();
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Canvas.ForceUpdateCanvases();
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				if ((Object)((Transform)target).parent != (Object)((Component)val).transform)
				{
					((Transform)target).SetParent(((Component)val).transform, false);
				}
				ApplyBottomLeftAnchoredRect(target, component, width, height, 1f, 0f, 0f);
			}
		}

		private void SetFogUIVisible(bool visible)
		{
			if ((Object)(object)_fogUIObject != (Object)null)
			{
				_fogUIObject.SetActive(visible);
			}
			if ((Object)(object)_fogTimerUIObject != (Object)null)
			{
				_fogTimerUIObject.SetActive(false);
			}
			if ((Object)(object)_fogUIContainerRect != (Object)null)
			{
				((Component)_fogUIContainerRect).gameObject.SetActive(visible);
			}
		}

		private void SendFogSpeed()
		{
		}

		private void DisableFrostDamage()
		{
		}

		private void StartFogMovement()
		{
		}

		private void CreateFogUI()
		{
			CleanupOldFogUI();
		}

		private void UpdateFogUI()
		{
			CleanupOldFogUI();
		}

		private void CleanupOldFogUI()
		{
			try
			{
				if ((Object)(object)_fogUIObject != (Object)null && (Object)(object)_fogUIObject.transform.parent != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_fogUIObject.transform.parent).gameObject);
				}
				else if ((Object)(object)_fogUIObject != (Object)null)
				{
					Object.Destroy((Object)(object)_fogUIObject);
				}
			}
			catch (Exception)
			{
			}
			finally
			{
				_fogUIObject = null;
				_fogTimerUIObject = null;
				_fogUIContainerRect = null;
				_cachedVersionLabelRect = null;
				CleanupSharedFogBottomLeftRootIfUnused();
			}
		}

		private static ItemInstanceData CreateItemInstanceData(int uses)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			ItemInstanceData val = new ItemInstanceData(Guid.NewGuid());
			if (val.data == null)
			{
				val.data = new Dictionary<DataEntryKey, DataEntryValue>();
			}
			OptionableIntItemData value = new OptionableIntItemData
			{
				HasData = true,
				Value = Mathf.Max(uses, 0)
			};
			val.data[(DataEntryKey)2] = (DataEntryValue)(object)value;
			ItemInstanceDataHandler.AddInstanceData(val);
			return val;
		}

		private static bool TrySetItemIntoSlot(Player player, int slotIndex, Item item, int uses)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)item == (Object)null || player.itemSlots == null || slotIndex < 0 || slotIndex >= player.itemSlots.Length)
			{
				return false;
			}
			player.itemSlots[slotIndex].SetItem(item, CreateItemInstanceData(uses));
			return true;
		}

		private static bool TryResolveFirstAidItem(out Item item)
		{
			item = null;
			try
			{
				MethodInfo methodInfo = typeof(Item).Assembly.GetType("ItemDatabase")?.GetMethod("TryGetItem", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(ushort),
					typeof(Item).MakeByRefType()
				}, null);
				if (methodInfo == null)
				{
					return false;
				}
				object[] array = new object[2]
				{
					(ushort)29,
					null
				};
				if ((bool)methodInfo.Invoke(null, array))
				{
					object obj = array[1];
					Item val = (Item)((obj is Item) ? obj : null);
					if (val != null && (Object)(object)val != (Object)null)
					{
						item = val;
						return true;
					}
				}
				ushort[] array2 = new ushort[11]
				{
					6, 1, 2, 3, 4, 5, 10, 15, 20, 25,
					30
				};
				foreach (ushort num in array2)
				{
					array[0] = num;
					array[1] = null;
					if (!(bool)methodInfo.Invoke(null, array))
					{
						continue;
					}
					object obj2 = array[1];
					Item val2 = (Item)((obj2 is Item) ? obj2 : null);
					if (val2 != null && !((Object)(object)val2 == (Object)null))
					{
						item = val2;
						string text = item.GetName()?.ToLowerInvariant();
						if (text != null && (text.Contains("first aid") || text.Contains("medkit") || text.Contains("bandage") || text.Contains("heal") || text.Contains("急救") || text.Contains("医疗")))
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			item = null;
			return false;
		}

		private void RefreshLocalCharacterReference()
		{
			try
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter != (Object)null && !localCharacter.isBot && !localCharacter.isZombie)
				{
					if ((Object)(object)_localCharacter != (Object)(object)localCharacter)
					{
						_localCharacter = localCharacter;
						_weaponVisualOwner = null;
						_localWeaponSourceItemId = 0;
					}
					TryEnsureLocalWeaponGrant(localCharacter);
				}
				else
				{
					_localCharacter = null;
					_hasWeapon = false;
					CleanupLocalWeaponVisual();
				}
			}
			catch (Exception)
			{
			}
		}

		private void TryEnsureLocalWeaponGrant(Character localCharacter)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)localCharacter == (Object)null) && !localCharacter.isBot && !localCharacter.isZombie && IsGameplayScene(SceneManager.GetActiveScene()) && IsWeaponFeatureEnabled() && IsAlive(localCharacter) && (!((Object)(object)localCharacter.refs?.view != (Object)null) || localCharacter.refs.view.IsMine) && GetCharacterGrantTrackingId(localCharacter) != int.MinValue && CharacterAlreadyHasShootZombiesWeapon(localCharacter))
			{
				MarkWeaponGrantedForCharacter(localCharacter);
			}
		}

		private void EnsureLocalWeaponVisual(Item heldBlowgunItem)
		{
			//IL_019f: 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_01af: Expected O, but got Unknown
			//IL_01af: Expected O, but got Unknown
			if (!EnableLocalWeaponVisualFollower || (Object)(object)_localCharacter == (Object)null || !HasAkVisualPrefab())
			{
				CleanupLocalWeaponVisual();
				return;
			}
			if ((Object)(object)heldBlowgunItem == (Object)null)
			{
				if (Time.time - _lastHeldWeaponSeenTime > 4f)
				{
					CleanupLocalWeaponVisual();
				}
				return;
			}
			int instanceID = ((Object)heldBlowgunItem).GetInstanceID();
			if ((Object)(object)_localWeaponVisualRoot == (Object)null || (Object)(object)_localWeaponVisualModel == (Object)null)
			{
				if (!CreateLocalWeaponVisualInstance(heldBlowgunItem))
				{
					LogDiagnosticOnce("local-weapon-create-fail:" + instanceID, "CreateLocalWeaponVisualInstance failed: prefab=" + DescribeAkVisualPrefabForDiagnostics());
					return;
				}
			}
			else if (_pendingLocalWeaponVisualModelRefresh)
			{
				Transform val = ItemPatch.ResolveTargetVisualRootForItem(heldBlowgunItem);
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)heldBlowgunItem).transform;
				}
				if (!RebuildLocalWeaponVisualModel(heldBlowgunItem, val))
				{
					LogDiagnosticOnce("local-weapon-model-refresh-fail:" + instanceID, "RebuildLocalWeaponVisualModel failed, falling back to full recreate: prefab=" + DescribeAkVisualPrefabForDiagnostics());
					CleanupLocalWeaponVisual();
					if (!CreateLocalWeaponVisualInstance(heldBlowgunItem))
					{
						LogDiagnosticOnce("local-weapon-create-fail:" + instanceID, "CreateLocalWeaponVisualInstance failed after model refresh fallback: prefab=" + DescribeAkVisualPrefabForDiagnostics());
						return;
					}
				}
			}
			_localWeaponSourceItemId = instanceID;
			((Component)_localWeaponVisualRoot).gameObject.SetActive(true);
			Transform val2 = ResolveViewAnchor();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = (((Object)(object)_localCharacter?.refs?.view != (Object)null) ? ((Component)_localCharacter.refs.view).transform : ((Component)_localCharacter).transform);
			}
			if ((Object)(object)val2 == (Object)null)
			{
				CleanupLocalWeaponVisual();
				return;
			}
			if ((Object)_localWeaponVisualRoot.parent != (Object)val2 || (Object)(object)_weaponVisualOwner != (Object)(object)_localCharacter)
			{
				_localWeaponVisualRoot.SetParent(val2, false);
				_weaponVisualOwner = _localCharacter;
			}
			Transform val3 = ItemPatch.ResolveTargetVisualRootForItem(heldBlowgunItem);
			Transform val4 = ResolveLocalHeldWeaponAnchor(heldBlowgunItem, val3);
			if ((Object)(object)val4 != (Object)null)
			{
				AttachLocalWeaponVisualToView(val4, val2);
			}
			else
			{
				ApplyStableLocalWeaponViewPose();
			}
			ApplyLocalWeaponModelPose();
			int num = ResolveLocalWeaponVisibleLayer(val2, heldBlowgunItem, val4, val3);
			EnsureLocalVisualRenderers(num);
			ForceEnableAllLocalRenderers();
			SuppressLocalFirstPersonHandRenderers();
			PreventLocalWeaponCameraClipping(val2);
			LogLocalWeaponVisualState("ensure", heldBlowgunItem, val2, val3, num);
			UpdateLocalWeaponMuzzle();
		}

		private Transform ResolveLocalHeldWeaponAnchor(Item heldBlowgunItem, Transform targetVisualRootForItem)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_004d: Expected O, but got Unknown
			if ((Object)(object)heldBlowgunItem != (Object)null)
			{
				Transform val = ((Component)heldBlowgunItem).transform.Find("Blowgun");
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			if ((Object)(object)targetVisualRootForItem != (Object)null && (!((Object)(object)heldBlowgunItem != (Object)null) || !((Object)targetVisualRootForItem == (Object)((Component)heldBlowgunItem).transform)))
			{
				return targetVisualRootForItem;
			}
			if ((Object)(object)heldBlowgunItem != (Object)null && (Object)(object)heldBlowgunItem.mainRenderer != (Object)null)
			{
				return ((Component)heldBlowgunItem.mainRenderer).transform;
			}
			if (!((Object)(object)heldBlowgunItem != (Object)null))
			{
				return null;
			}
			return ((Component)heldBlowgunItem).transform;
		}

		private Transform ResolveViewAnchor()
		{
			if ((Object)(object)_localCharacter != (Object)null)
			{
				Transform val = FindBestCameraAnchor(((Component)_localCharacter).transform);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			if (TryFindBestGlobalCameraAnchor(out var cameraTransform))
			{
				return cameraTransform;
			}
			if ((Object)(object)_localCharacter?.refs?.view != (Object)null)
			{
				return ((Component)_localCharacter.refs.view).transform;
			}
			if (!((Object)(object)_localCharacter != (Object)null))
			{
				return null;
			}
			return ((Component)_localCharacter).transform;
		}

		private static void SuppressLocalFirstPersonHandRenderers()
		{
			Transform localFirstPersonRenderRoot = GetLocalFirstPersonRenderRoot();
			if ((Object)(object)localFirstPersonRenderRoot == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)localFirstPersonRenderRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (IsSuppressibleLocalFirstPersonHandRenderer(val))
				{
					val.enabled = false;
					val.forceRenderingOff = true;
					val.allowOcclusionWhenDynamic = false;
				}
			}
			_localFirstPersonHandsSuppressed = true;
		}

		private static void RestoreLocalFirstPersonHandRenderers()
		{
			if (!_localFirstPersonHandsSuppressed)
			{
				return;
			}
			Transform localFirstPersonRenderRoot = GetLocalFirstPersonRenderRoot();
			if ((Object)(object)localFirstPersonRenderRoot != (Object)null)
			{
				Renderer[] componentsInChildren = ((Component)localFirstPersonRenderRoot).GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val in componentsInChildren)
				{
					if (IsSuppressibleLocalFirstPersonHandRenderer(val))
					{
						val.enabled = true;
						val.forceRenderingOff = false;
						val.allowOcclusionWhenDynamic = false;
					}
				}
			}
			_localFirstPersonHandsSuppressed = false;
		}

		private static Transform GetLocalFirstPersonRenderRoot()
		{
			if ((Object)(object)_localCharacter?.refs?.view != (Object)null)
			{
				return ((Component)_localCharacter.refs.view).transform;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter?.refs?.view != (Object)null)
			{
				return ((Component)localCharacter.refs.view).transform;
			}
			return null;
		}

		private static bool IsSuppressibleLocalFirstPersonHandRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_localWeaponVisualRoot != (Object)null && ((Component)renderer).transform.IsChildOf(_localWeaponVisualRoot))
			{
				return false;
			}
			string text = ((((Object)renderer).name ?? string.Empty) + "/" + (FormatTransformPath(((Component)renderer).transform) ?? string.Empty)).ToLowerInvariant();
			string[] localFirstPersonHandSuppressionKeywords = LocalFirstPersonHandSuppressionKeywords;
			foreach (string value in localFirstPersonHandSuppressionKeywords)
			{
				if (!string.IsNullOrWhiteSpace(value) && text.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		private static Vector3 GetInverseLossyScale(Transform target)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return Vector3.one;
			}
			Vector3 lossyScale = target.lossyScale;
			float num = 1f / Mathf.Max(Mathf.Abs(lossyScale.x), 0.0001f);
			float num2 = 1f / Mathf.Max(Mathf.Abs(lossyScale.y), 0.0001f);
			float num3 = 1f / Mathf.Max(Mathf.Abs(lossyScale.z), 0.0001f);
			return new Vector3(num, num2, num3);
		}

		private static Vector3 GetRelativeLossyScale(Transform source, Transform targetParent)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || (Object)(object)targetParent == (Object)null)
			{
				return Vector3.one;
			}
			Vector3 lossyScale = source.lossyScale;
			Vector3 lossyScale2 = targetParent.lossyScale;
			return new Vector3(SafeAxisScaleRatio(lossyScale.x, lossyScale2.x), SafeAxisScaleRatio(lossyScale.y, lossyScale2.y), SafeAxisScaleRatio(lossyScale.z, lossyScale2.z));
		}

		private static float SafeAxisScaleRatio(float sourceAxis, float parentAxis)
		{
			if (Mathf.Abs(parentAxis) < 0.0001f)
			{
				return 1f;
			}
			return sourceAxis / parentAxis;
		}

		private static Vector3 GetEffectiveLocalWeaponModelScale()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			float num = GetWeaponModelScale() * 1.275f;
			return ClampLocalWeaponScale(new Vector3(_localWeaponModelBaseScale.x * num, _localWeaponModelBaseScale.y * num, _localWeaponModelBaseScale.z * num));
		}

		private static void ApplyStableLocalWeaponViewPose()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_localWeaponVisualRoot == (Object)null))
			{
				_localWeaponVisualRoot.localPosition = _localWeaponOffset;
				_localWeaponVisualRoot.localRotation = Quaternion.Euler(_localWeaponEuler);
				_localWeaponVisualRoot.localScale = _localWeaponRootScale;
			}
		}

		private static void ApplyLocalWeaponModelPose()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_localWeaponVisualModel == (Object)null))
			{
				_localWeaponVisualModel.localPosition = _localWeaponModelBasePosition + _localWeaponModelBaseRotation * GetConfiguredLocalWeaponModelOffset();
				_localWeaponVisualModel.localRotation = _localWeaponModelBaseRotation * Quaternion.Euler(GetConfiguredLocalWeaponModelEuler() + _localWeaponViewEulerOffset);
				_localWeaponVisualModel.localScale = GetEffectiveLocalWeaponModelScale();
			}
		}

		private static void NormalizeLocalWeaponScaleForFirstPersonView(Transform visualModel)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)visualModel == (Object)null || !TryGetCombinedRendererBounds(visualModel, out var bounds))
			{
				return;
			}
			float num = Mathf.Max(((Bounds)(ref bounds)).size.x, Mathf.Max(((Bounds)(ref bounds)).size.y, ((Bounds)(ref bounds)).size.z));
			if (IsFiniteFloat(num) && !(num < 0.0005f))
			{
				float num2 = Mathf.Clamp(Mathf.Clamp(0.9f / Mathf.Max(1.275f, 0.01f), 0.24f, 0.8f) / num, 0.05f, 96f);
				if (IsFiniteFloat(num2) && !(Mathf.Abs(num2 - 1f) <= 0.01f))
				{
					Vector3 localScale = visualModel.localScale;
					visualModel.localScale = ClampLocalWeaponScale(new Vector3(Mathf.Abs(localScale.x * num2), Mathf.Abs(localScale.y * num2), Mathf.Abs(localScale.z * num2)));
				}
			}
		}

		private static Vector3 ClampLocalWeaponScale(Vector3 scale)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(ClampLocalWeaponScaleAxis(scale.x), ClampLocalWeaponScaleAxis(scale.y), ClampLocalWeaponScaleAxis(scale.z));
		}

		private static float ClampLocalWeaponScaleAxis(float value)
		{
			if (!IsFiniteFloat(value))
			{
				return 1f;
			}
			return Mathf.Clamp(Mathf.Abs(value), 0.01f, 96f);
		}

		private static void PreventLocalWeaponCameraClipping(Transform viewAnchor)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localWeaponVisualRoot == (Object)null || (Object)(object)_localWeaponVisualModel == (Object)null || (Object)(object)viewAnchor == (Object)null)
			{
				return;
			}
			Camera val = ResolveCameraForAnchor(viewAnchor);
			if ((Object)(object)val == (Object)null || !TryGetCombinedRendererBounds(_localWeaponVisualModel, out var bounds))
			{
				return;
			}
			float boundsClosestDepth = GetBoundsClosestDepth(bounds, viewAnchor);
			if (!IsFiniteFloat(boundsClosestDepth))
			{
				return;
			}
			float num = Mathf.Max(val.nearClipPlane + 0.06f, 0.18f);
			if (boundsClosestDepth >= num)
			{
				return;
			}
			float num2 = Mathf.Clamp(num - boundsClosestDepth + 0.02f, 0.01f, 1.6f);
			Vector3 localPosition = _localWeaponVisualRoot.localPosition;
			localPosition.z += num2;
			_localWeaponVisualRoot.localPosition = localPosition;
			float num3 = boundsClosestDepth;
			if (TryGetCombinedRendererBounds(_localWeaponVisualModel, out var bounds2))
			{
				float boundsClosestDepth2 = GetBoundsClosestDepth(bounds2, viewAnchor);
				if (IsFiniteFloat(boundsClosestDepth2))
				{
					num3 = boundsClosestDepth2;
				}
			}
			LogDiagnosticOnce("local-weapon-clip-fix:" + GetCurrentWeaponSelection() + ":" + ((Object)_localWeaponVisualRoot).GetInstanceID(), $"Adjusted local weapon depth to avoid clipping: selection={GetCurrentWeaponSelection()}, nearClip={val.nearClipPlane:0.###}, before={boundsClosestDepth:0.###}, after={num3:0.###}, delta={num2:0.###}, rootLocalPos={_localWeaponVisualRoot.localPosition}");
		}

		private static Camera ResolveCameraForAnchor(Transform viewAnchor)
		{
			Camera val = null;
			if ((Object)(object)viewAnchor != (Object)null)
			{
				val = ((Component)viewAnchor).GetComponent<Camera>() ?? ((Component)viewAnchor).GetComponentInParent<Camera>();
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Camera.main;
			}
			return val;
		}

		private static bool TryGetCombinedRendererBounds(Transform root, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			if ((Object)(object)root == (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			bool flag = false;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null) && val.enabled)
				{
					if (!flag)
					{
						bounds = val.bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(val.bounds);
					}
				}
			}
			return flag;
		}

		private static string DescribeLocalMaterialStateForDiagnostics(Material material)
		{
			if ((Object)(object)material == (Object)null)
			{
				return "null";
			}
			Texture val = null;
			if (material.HasProperty("_BaseMap"))
			{
				val = material.GetTexture("_BaseMap");
			}
			if ((Object)(object)val == (Object)null && material.HasProperty("_MainTex"))
			{
				val = material.GetTexture("_MainTex");
			}
			string text = (material.HasProperty("_Cull") ? material.GetFloat("_Cull").ToString("0.###", CultureInfo.InvariantCulture) : "-");
			object[] obj = new object[5]
			{
				((Object)material).name,
				null,
				null,
				null,
				null
			};
			Shader shader = material.shader;
			obj[1] = ((shader != null) ? ((Object)shader).name : null) ?? "null";
			obj[2] = material.renderQueue;
			obj[3] = text;
			obj[4] = (((Object)(object)val != (Object)null) ? ((Object)val).name : "null");
			return string.Format("{0}[shader={1},rq={2},cull={3},tex={4}]", obj);
		}

		private static string DescribeLocalRendererStateForDiagnostics(Renderer renderer)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			if ((Object)(object)renderer == (Object)null)
			{
				return "null";
			}
			MeshFilter component = ((Component)renderer).GetComponent<MeshFilter>();
			Mesh val = (((Object)(object)component != (Object)null) ? component.sharedMesh : null);
			SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((renderer is SkinnedMeshRenderer) ? renderer : null);
			if ((Object)(object)val == (Object)null && (Object)(object)val2 != (Object)null)
			{
				val = val2.sharedMesh;
			}
			Material[] array = renderer.sharedMaterials ?? Array.Empty<Material>();
			string text = string.Join(" | ", array.Take(4).Select(DescribeLocalMaterialStateForDiagnostics));
			if (array.Length > 4)
			{
				text += $" | ...+{array.Length - 4}";
			}
			string text2 = (((Object)(object)val != (Object)null) ? ((Object)val).name : "null");
			int num = (((Object)(object)val != (Object)null) ? val.subMeshCount : 0);
			int num2 = (((Object)(object)val != (Object)null) ? val.vertexCount : 0);
			return $"{FormatTransformPath(((Component)renderer).transform)}[enabled={renderer.enabled},forceOff={renderer.forceRenderingOff},active={((Component)renderer).gameObject.activeInHierarchy},layer={((Component)renderer).gameObject.layer},mesh={text2},subMeshes={num},verts={num2},mats={text}]";
		}

		private static string DescribeLocalRendererCollectionForDiagnostics(Transform root, int maxCount = 10)
		{
			if ((Object)(object)root == (Object)null)
			{
				return "none";
			}
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			List<string> list = componentsInChildren.Where((Renderer r) => (Object)(object)r != (Object)null).Take(maxCount).Select(DescribeLocalRendererStateForDiagnostics)
				.ToList();
			if (list.Count == 0)
			{
				return "none";
			}
			if (componentsInChildren.Length > list.Count)
			{
				list.Add("...+" + (componentsInChildren.Length - list.Count));
			}
			return string.Join(" || ", list);
		}

		private static string DescribeLocalBoundsForDiagnostics(Transform root)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetCombinedRendererBounds(root, out var bounds))
			{
				return "none";
			}
			return $"center={((Bounds)(ref bounds)).center},size={((Bounds)(ref bounds)).size}";
		}

		private void LogLocalWeaponVisualState(string phase, Item sourceItem, Transform viewAnchor, Transform targetVisualRoot, int resolvedLayer)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected I4, but got Unknown
			//IL_01bf: 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)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_localWeaponVisualRoot == (Object)null) && !((Object)(object)_localWeaponVisualModel == (Object)null))
			{
				Camera val = ResolveCameraForAnchor(viewAnchor);
				int num = (((Object)(object)sourceItem != (Object)null) ? ((Object)sourceItem).GetInstanceID() : 0);
				string text = "null";
				if ((Object)(object)sourceItem != (Object)null)
				{
					string text2 = (((Object)(object)sourceItem.holderCharacter != (Object)null) ? ((Object)sourceItem.holderCharacter).name : null) ?? (((Object)(object)sourceItem.trueHolderCharacter != (Object)null) ? ((Object)sourceItem.trueHolderCharacter).name : null) ?? "null";
					text = $"name={((Object)sourceItem).name},id={sourceItem.itemID},state={(int)sourceItem.itemState},holder={text2}";
				}
				string key = "local-weapon-state:" + phase + ":" + GetCurrentWeaponSelection() + ":" + num + ":" + ((Object)_localWeaponVisualRoot).GetInstanceID();
				object[] obj = new object[20]
				{
					phase,
					GetCurrentWeaponSelection(),
					text,
					FormatTransformPath(viewAnchor),
					FormatTransformPath(targetVisualRoot),
					((Object)(object)val != (Object)null) ? ((Object)val).name : "null",
					((Object)(object)val != (Object)null) ? ((Component)val).gameObject.layer : (-1),
					((Object)(object)val != (Object)null) ? val.cullingMask : 0,
					resolvedLayer,
					FormatTransformPath(_localWeaponVisualRoot),
					_localWeaponVisualRoot.localPosition,
					null,
					null,
					null,
					null,
					null,
					null,
					null,
					null,
					null
				};
				Quaternion localRotation = _localWeaponVisualRoot.localRotation;
				obj[11] = ((Quaternion)(ref localRotation)).eulerAngles;
				obj[12] = _localWeaponVisualRoot.localScale;
				obj[13] = FormatTransformPath(_localWeaponVisualModel);
				obj[14] = _localWeaponVisualModel.localPosition;
				localRotation = _localWeaponVisualModel.localRotation;
				obj[15] = ((Quaternion)(ref localRotation)).eulerAngles;
				obj[16] = _localWeaponVisualModel.localScale;
				obj[17] = DescribeLocalBoundsForDiagnostics(_localWeaponVisualRoot);
				obj[18] = DescribeLocalBoundsForDiagnostics(_localWeaponVisualModel);
				obj[19] = DescribeLocalRendererCollectionForDiagnostics(_localWeaponVisualRoot);
				LogDiagnosticOnce(key, string.Format("Local weapon visual state: phase={0}, selection={1}, item={2}, view={3}, targetRoot={4}, camera={5}, cameraLayer={6}, cullingMask={7}, resolvedLayer={8}, rootPath={9}, rootLocalPos={10}, rootLocalRot={11}, rootLocalScale={12}, modelPath={13}, modelLocalPos={14}, modelLocalRot={15}, modelLocalScale={16}, rootBounds={17}, modelBounds={18}, renderers={19}", obj));
			}
		}

		private static float GetBoundsClosestDepth(Bounds bounds, Transform anchor)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: 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)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)anchor == (Object)null)
			{
				return float.PositiveInfinity;
			}
			Vector3 center = ((Bounds)(ref bounds)).center;
			Vector3 extents = ((Bounds)(ref bounds)).extents;
			Vector3[] array = (Vector3[])(object)new Vector3[8]
			{
				center + new Vector3(0f - extents.x, 0f - extents.y, 0f - extents.z),
				center + new Vector3(0f - extents.x, 0f - extents.y, extents.z),
				center + new Vector3(0f - extents.x, extents.y, 0f - extents.z),
				center + new Vector3(0f - extents.x, extents.y, extents.z),
				center + new Vector3(extents.x, 0f - extents.y, 0f - extents.z),
				center + new Vector3(extents.x, 0f - extents.y, extents.z),
				center + new Vector3(extents.x, extents.y, 0f - extents.z),
				center + new Vector3(extents.x, extents.y, extents.z)
			};
			float num = float.PositiveInfinity;
			for (int i = 0; i < array.Length; i++)
			{
				Vector3 val = anchor.InverseTransformPoint(array[i]);
				if (IsFiniteVector(val))
				{
					num = Mathf.Min(num, val.z);
				}
			}
			return num;
		}

		private void AttachLocalWeaponVisualToView(Transform sourceAnchor, Transform viewAnchor)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0030: Expected O, but got Unknown
			if (!((Object)(object)_localWeaponVisualRoot == (Object)null) && !((Object)(object)viewAnchor == (Object)null))
			{
				if ((Object)_localWeaponVisualRoot.parent != (Object)viewAnchor || (Object)(object)_weaponVisualOwner != (Object)(object)_localCharacter)
				{
					_localWeaponVisualRoot.SetParent(viewAnchor, false);
					_weaponVisualOwner = _localCharacter;
				}
				if (!TryApplySourceAnchorRelativePose(sourceAnchor, viewAnchor))
				{
					ApplyStableLocalWeaponViewPose();
				}
			}
		}

		private bool TryApplySourceAnchorRelativePose(Transform sourceAnchor, Transform viewAnchor)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			if ((Object)(object)_localWeaponVisualRoot == (Object)null || (Object)(object)sourceAnchor == (Object)null || (Object)(object)viewAnchor == (Object)null)
			{
				return false;
			}
			Vector3 val = viewAnchor.InverseTransformPoint(sourceAnchor.position);
			if (!IsFiniteVector(val))
			{
				return false;
			}
			bool flag = IsReasonableHeldVisualPose(val);
			LogDiagnosticOnce("local-weapon-source-anchor-stable-fallback:" + ((Object)_localWeaponVisualRoot).GetInstanceID(), $"Skipped source anchor local pose and used stable first-person pose: source={FormatTransformPath(sourceAnchor)}, view={FormatTransformPath(viewAnchor)}, sourceLocalPos={val}, preferStable={true}, poseReasonable={flag}");
			return false;
		}

		private static bool IsReasonableHeldVisualPose(Vector3 localPosition)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFiniteVector(localPosition))
			{
				return false;
			}
			if (localPosition.z < 0.05f || localPosition.z > 1.45f)
			{
				return false;
			}
			if (Mathf.Abs(localPosition.x) > 0.8f || Mathf.Abs(localPosition.y) > 0.8f)
			{
				return false;
			}
			return true;
		}

		private static Vector3 SanitizeHeldWeaponLocalPosition(Vector3 localPosition)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFiniteVector(localPosition))
			{
				return new Vector3(0f, 0f, 0.22f);
			}
			return new Vector3(Mathf.Clamp(localPosition.x, -0.85f, 0.85f), Mathf.Clamp(localPosition.y, -0.85f, 0.85f), Mathf.Clamp(localPosition.z, 0.18f, 1.45f));
		}

		private static bool IsFiniteVector(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (IsFiniteFloat(value.x) && IsFiniteFloat(value.y))
			{
				return IsFiniteFloat(value.z);
			}
			return false;
		}

		private static bool IsFiniteQuaternion(Quaternion value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (IsFiniteFloat(value.x) && IsFiniteFloat(value.y) && IsFiniteFloat(value.z))
			{
				return IsFiniteFloat(value.w);
			}
			return false;
		}

		private static bool IsFiniteFloat(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private bool CreateLocalWeaponVisualInstance(Item sourceItem)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			CleanupLocalWeaponVisual();
			if (!HasAkVisualPrefab() || (Object)(object)sourceItem == (Object)null)
			{
				return false;
			}
			GameObject val = new GameObject("AK47_LocalVisualRoot");
			_localWeaponVisualRoot = val.transform;
			val.SetActive(false);
			Transform val2 = ItemPatch.ResolveTargetVisualRootForItem(sourceItem);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)sourceItem).transform;
			}
			if (!RebuildLocalWeaponVisualModel(sourceItem, val2))
			{
				CleanupLocalWeaponVisual();
				return false;
			}
			LogDiagnosticOnce("local-weapon-create-success:" + ((Object)sourceItem).GetInstanceID(), "Created local weapon visual: model=" + FormatTransformPath(_localWeaponVisualModel) + ", targetRoot=" + FormatTransformPath(val2) + ", prefab=" + DescribeAkVisualPrefabForDiagnostics());
			Transform val3 = ResolveViewAnchor();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ((Component)sourceItem).transform;
			}
			if ((Object)(object)val3 != (Object)null)
			{
				_localWeaponVisualRoot.SetParent(val3, false);
				_weaponVisualOwner = _localCharacter;
				if ((Object)(object)((Component)val3).GetComponent<Camera>() != (Object)null || (Object)(object)((Component)val3).GetComponentInParent<Camera>() != (Object)null)
				{
					Transform sourceAnchor = ResolveLocalHeldWeaponAnchor(sourceItem, val2);
					if (!TryApplySourceAnchorRelativePose(sourceAnchor, val3))
					{
						ApplyStableLocalWeaponViewPose();
					}
				}
			}
			int num = ResolveLocalWeaponVisibleLayer(val3, sourceItem, val2, ItemPatch.TryGetMuzzleMarker(sourceItem));
			EnsureLocalVisualRenderers(num);
			ForceEnableAllLocalRenderers();
			PreventLocalWeaponCameraClipping(val3);
			LogLocalWeaponVisualState("create", sourceItem, val3, val2, num);
			_localWeaponSourceItemId = ((Object)sourceItem).GetInstanceID();
			val.SetActive(true);
			UpdateLocalWeaponMuzzle();
			return true;
		}

		private bool RebuildLocalWeaponVisualModel(Item sourceItem, Transform targetVisualRoot)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localWeaponVisualRoot == (Object)null || (Object)(object)sourceItem == (Object)null)
			{
				return false;
			}
			if ((Object)(object)targetVisualRoot == (Object)null)
			{
				targetVisualRoot = ((Component)sourceItem).transform;
			}
			if ((Object)(object)_localWeaponVisualModel != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_localWeaponVisualModel).gameObject);
				_localWeaponVisualModel = null;
			}
			_localWeaponMuzzle = null;
			_localWeaponModelUsesPreparedPose = false;
			_localWeaponVisualModel = CreateFirstPersonLocalWeaponModel(_localWeaponVisualRoot, targetVisualRoot);
			if ((Object)(object)_localWeaponVisualModel == (Object)null)
			{
				GameObject val = new GameObject("AK47_LocalVisualModel");
				val.transform.SetParent(_localWeaponVisualRoot, false);
				_localWeaponVisualModel = val.transform;
			}
			if ((Object)(object)_localWeaponVisualModel == (Object)null)
			{
				return false;
			}
			if (_localWeaponModelUsesPreparedPose)
			{
				BakeLocalWeaponSkinnedRenderers(((Component)_localWeaponVisualModel).gameObject);
			}
			SetActiveRecursively(_localWeaponVisualModel, active: true);
			StripLocalVisualBehaviours(((Component)_localWeaponVisualModel).gameObject);
			int num = CountMeshBackedRenderers(_localWeaponVisualModel);
			if (num == 0)
			{
				EnsureLocalVisualFallbackGeometry(_localWeaponVisualModel);
				num = CountMeshBackedRenderers(_localWeaponVisualModel);
			}
			else
			{
				CleanupLocalVisualFallbackGeometry(_localWeaponVisualModel);
			}
			if (num == 0)
			{
				if ((Object)(object)_localWeaponVisualModel != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_localWeaponVisualModel).gameObject);
					_localWeaponVisualModel = null;
				}
				_localWeaponMuzzle = null;
				return false;
			}
			NormalizeLocalWeaponScaleForFirstPersonView(_localWeaponVisualModel);
			_localWeaponModelBasePosition = _localWeaponVisualModel.localPosition;
			_localWeaponModelBaseRotation = _localWeaponVisualModel.localRotation;
			_localWeaponModelBaseScale = ClampLocalWeaponScale(_localWeaponVisualModel.localScale);
			ApplyLocalWeaponModelPose();
			_pendingLocalWeaponVisualModelRefresh = false;
			LogDiagnosticOnce("local-weapon-model-ready:" + ((Object)sourceItem).GetInstanceID() + ":" + GetCurrentWeaponSelection(), $"Prepared local weapon visual model: model={FormatTransformPath(_localWeaponVisualModel)}, renderers={num}, targetRoot={FormatTransformPath(targetVisualRoot)}, prefab={DescribeAkVisualPrefabForDiagnostics()}");
			return true;
		}

		private static Transform CreateFirstPersonLocalWeaponModel(Transform parent, Transform targetVisualRoot)
		{
			Transform val = CreateBakedLocalWeaponModel(parent);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			val = CreateStandaloneLocalWeaponModel(parent);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return CreatePreparedLocalWeaponModel(parent, targetVisualRoot);
		}

		private static Transform CreateBakedLocalWeaponModel(Transform parent)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_00e5: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)parent == (Object)null || !HasAkVisualPrefab())
			{
				return null;
			}
			GameObject akVisualPrefab = GetAkVisualPrefab();
			if ((Object)(object)akVisualPrefab == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("AK47_LocalVisualModel");
			val.transform.SetParent(parent, false);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			int num = 0;
			Renderer[] componentsInChildren = akVisualPrefab.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Mesh val3 = null;
				Material[] sourceMaterials = null;
				if (val2 is MeshRenderer)
				{
					MeshFilter component = ((Component)val2).GetComponent<MeshFilter>();
					val3 = (((Object)(object)component != (Object)null) ? component.sharedMesh : null);
					sourceMaterials = val2.sharedMaterials;
				}
				else
				{
					SkinnedMeshRenderer val4 = (SkinnedMeshRenderer)((val2 is SkinnedMeshRenderer) ? val2 : null);
					if ((Object)(object)val4 != (Object)null)
					{
						val3 = val4.sharedMesh;
						sourceMaterials = ((Renderer)val4).sharedMaterials;
					}
				}
				if ((Object)(object)val3 == (Object)null || val3.vertexCount <= 0)
				{
					continue;
				}
				string text = ((((Object)val2).name ?? string.Empty) + "/" + (FormatTransformPath(((Component)val2).transform) ?? string.Empty)).ToLowerInvariant();
				if (!LocalWeaponExcludedRendererKeywords.Any((string keyword) => !string.IsNullOrWhiteSpace(keyword) && text.Contains(keyword)))
				{
					GameObject val5 = new GameObject(string.IsNullOrWhiteSpace(((Object)val2).name) ? ("AK47_LocalMesh_" + num) : ((Object)val2).name);
					val5.transform.SetParent(val.transform, false);
					if (!ItemPatch.TryGetTransformPoseRelativeToAkRoot(((Component)val2).transform, out var localPosition, out var localRotation, out var localScale))
					{
						localPosition = ((Component)val2).transform.localPosition;
						localRotation = ((Component)val2).transform.localRotation;
						localScale = ((Component)val2).transform.localScale;
					}
					val5.transform.localPosition = localPosition;
					val5.transform.localRotation = localRotation;
					val5.transform.localScale = localScale;
					MeshFilter val6 = val5.AddComponent<MeshFilter>();
					MeshRenderer obj = val5.AddComponent<MeshRenderer>();
					val6.sharedMesh = val3;
					((Renderer)obj).sharedMaterials = BuildLocalViewMaterials(sourceMaterials, Mathf.Max(val3.subMeshCount, 1));
					ItemPatch.NormalizeAkRenderer((Renderer)obj);
					num++;
				}
			}
			if (num == 0)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			_localWeaponModelUsesPreparedPose = false;
			return val.transform;
		}

		private static Transform CreatePreparedLocalWeaponModel(Transform parent, Transform targetVisualRoot)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)parent == (Object)null || !HasAkVisualPrefab())
			{
				return null;
			}
			GameObject akVisualPrefab = GetAkVisualPrefab();
			if ((Object)(object)akVisualPrefab == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(akVisualPrefab, parent, false);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			_localWeaponModelUsesPreparedPose = true;
			((Object)val).name = "AK47_LocalVisualModel";
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			PrepareLocalWeaponVisualModel(val, targetVisualRoot);
			StripLocalVisualBehaviours(val);
			return val.transform;
		}

		private static Transform CreateStandaloneLocalWeaponModel(Transform parent)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			if ((Object)(object)parent == (Object)null || !HasAkVisualPrefab())
			{
				return null;
			}
			if (!TryResolveLocalStandaloneAkVisual(out var mesh, out var materials, out var localScale, out var localRotation, out var localPosition) || (Object)(object)mesh == (Object)null)
			{
				return null;
			}
			_localWeaponModelUsesPreparedPose = false;
			GameObject val = new GameObject("AK47_LocalVisualModel");
			val.transform.SetParent(parent, false);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			GameObject val2 = new GameObject("AK47_LocalVisualMesh");
			val2.transform.SetParent(val.transform, false);
			val2.transform.localPosition = localPosition;
			val2.transform.localRotation = localRotation;
			val2.transform.localScale = localScale;
			MeshFilter val3 = val2.AddComponent<MeshFilter>();
			MeshRenderer obj = val2.AddComponent<MeshRenderer>();
			val3.sharedMesh = mesh;
			((Renderer)obj).sharedMaterials = BuildLocalViewMaterials(materials, Mathf.Max(mesh.subMeshCount, 1));
			ItemPatch.NormalizeAkRenderer((Renderer)obj);
			return val.transform;
		}

		private static Material[] BuildLocalViewMaterials(Material[] sourceMaterials, int subMeshCount)
		{
			subMeshCount = Mathf.Max(subMeshCount, 1);
			Material[] array = (Material[])(object)new Material[subMeshCount];
			for (int i = 0; i < subMeshCount; i++)
			{
				Material source = ((sourceMaterials != null && sourceMaterials.Length != 0) ? sourceMaterials[Mathf.Clamp(i, 0, sourceMaterials.Length - 1)] : null);
				array[i] = CreateVisibleLocalViewMaterial(source);
			}
			return array;
		}

		private static Material CreateVisibleLocalViewMaterial(Material source)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0031: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			Shader val = ResolveLocalVisualCompatibleShader();
			Material val2 = new Material(((Object)(object)val != (Object)null) ? val : GetLocalVisualFallbackMaterial().shader);
			((Object)val2).name = "AK47_LocalViewMat";
			Texture val3 = null;
			string text = null;
			Color val4 = Color.white;
			if ((Object)(object)source != (Object)null)
			{
				if (source.HasProperty("_BaseMap"))
				{
					val3 = source.GetTexture("_BaseMap");
					if ((Object)(object)val3 != (Object)null)
					{
						text = "_BaseMap";
					}
				}
				if ((Object)(object)val3 == (Object)null && source.HasProperty("_MainTex"))
				{
					val3 = source.GetTexture("_MainTex");
					if ((Object)(object)val3 != (Object)null)
					{
						text = "_MainTex";
					}
				}
				if (source.HasProperty("_BaseColor"))
				{
					val4 = source.GetColor("_BaseColor");
				}
				else if (source.HasProperty("_Color"))
				{
					val4 = source.GetColor("_Color");
				}
			}
			val4.a = 1f;
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", val4);
			}
			if (val2.HasProperty("_Color"))
			{
				val2.SetColor("_Color", val4);
			}
			if ((Object)(object)val3 != (Object)null)
			{
				if (val2.HasProperty("_BaseMap"))
				{
					val2.SetTexture("_BaseMap", val3);
					if (!string.IsNullOrWhiteSpace(text))
					{
						val2.SetTextureScale("_BaseMap", source.GetTextureScale(text));
						val2.SetTextureOffset("_BaseMap", source.GetTextureOffset(text));
					}
				}
				if (val2.HasProperty("_MainTex"))
				{
					val2.SetTexture("_MainTex", val3);
					if (!string.IsNullOrWhiteSpace(text))
					{
						val2.SetTextureScale("_MainTex", source.GetTextureScale(text));
						val2.SetTextureOffset("_MainTex", source.GetTextureOffset(text));
					}
				}
			}
			if (val2.HasProperty("_Surface"))
			{
				val2.SetFloat("_Surface", 0f);
			}
			if (val2.HasProperty("_AlphaClip"))
			{
				val2.SetFloat("_AlphaClip", 0f);
			}
			if (val2.HasProperty("_Cutoff"))
			{
				val2.SetFloat("_Cutoff", 0f);
			}
			if (val2.HasProperty("_Cull"))
			{
				val2.SetFloat("_Cull", 0f);
			}
			if (val2.HasProperty("_Metallic"))
			{
				val2.SetFloat("_Metallic", 0f);
			}
			if (val2.HasProperty("_Glossiness"))
			{
				val2.SetFloat("_Glossiness", 0.15f);
			}
			val2.renderQueue = -1;
			return val2;
		}

		private static bool TryResolveLocalStandaloneAkVisual(out Mesh mesh, out Material[] materials, out Vector3 localScale, out Quaternion localRotation, out Vector3 localPosition)
		{
			//IL_0007: 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)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			mesh = null;
			materials = null;
			localScale = Vector3.one;
			localRotation = Quaternion.identity;
			localPosition = Vector3.zero;
			if ((Object)(object)_ak47Prefab == (Object)null)
			{
				return false;
			}
			Transform val = FindPreferredStandaloneAkMeshTransform(_ak47Prefab.transform);
			if ((Object)(object)val != (Object)null)
			{
				MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
				MeshRenderer component2 = ((Component)val).GetComponent<MeshRenderer>();
				mesh = (((Object)(object)component != (Object)null) ? component.sharedMesh : null);
				materials = (((Object)(object)component2 != (Object)null) ? ((Renderer)component2).sharedMaterials : null);
				if ((Object)(object)mesh != (Object)null)
				{
					ItemPatch.TryGetTransformPoseRelativeToAkRoot(val, out localPosition, out localRotation, out localScale);
					return true;
				}
			}
			if (!ItemPatch.TryResolveBaseAkVisual(out mesh, out materials, out localScale, out localRotation, out localPosition, out var _))
			{
				return false;
			}
			return (Object)(object)mesh != (Object)null;
		}

		private static Transform FindPreferredStandaloneAkMeshTransform(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Transform val = root.Find("Mesh") ?? root.Find("AK/Mesh");
			if (IsValidStandaloneAkMeshTransform(val))
			{
				return val;
			}
			MeshFilter[] componentsInChildren = ((Component)root).GetComponentsInChildren<MeshFilter>(true);
			Transform result = null;
			int num = int.MinValue;
			MeshFilter[] array = componentsInChildren;
			foreach (MeshFilter val2 in array)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2.sharedMesh == (Object)null)
				{
					continue;
				}
				MeshRenderer component = ((Component)val2).GetComponent<MeshRenderer>();
				if (!((Object)(object)component == (Object)null))
				{
					int standaloneAkMeshScore = GetStandaloneAkMeshScore(((Component)val2).transform, val2.sharedMesh, component);
					if (standaloneAkMeshScore > num)
					{
						num = standaloneAkMeshScore;
						result = ((Component)val2).transform;
					}
				}
			}
			return result;
		}

		private static bool IsValidStandaloneAkMeshTransform(Transform candidate)
		{
			if ((Object)(object)candidate == (Object)null)
			{
				return false;
			}
			MeshFilter component = ((Component)candidate).GetComponent<MeshFilter>();
			MeshRenderer component2 = ((Component)candidate).GetComponent<MeshRenderer>();
			if ((Object)(object)(((Object)(object)component != (Object)null) ? component.sharedMesh : null) != (Object)null)
			{
				return (Object)(object)component2 != (Object)null;
			}
			return false;
		}

		private static int GetStandaloneAkMeshScore(Transform candidate, Mesh mesh, MeshRenderer renderer)
		{
			if ((Object)(object)candidate == (Object)null || (Object)(object)mesh == (Object)null || (Object)(object)renderer == (Object)null)
			{
				return int.MinValue;
			}
			string text = (((Object)candidate).name ?? string.Empty).ToLowerInvariant();
			string text2 = FormatTransformPath(candidate).ToLowerInvariant();
			WeaponVariantDefinition weaponVariantDefinition = GetWeaponVariantDefinition(GetCurrentWeaponSelection());
			int num;
			int num2 = (num = mesh.vertexCount);
			if (text == "mesh" || text2.EndsWith("/mesh"))
			{
				num += 3000;
			}
			if (weaponVariantDefinition != null && weaponVariantDefinition.PrefabAliases != null && weaponVariantDefinition.PrefabAliases.Any((string alias) => !string.IsNullOrWhiteSpace(alias) && (MatchesWeaponAliasToken(text, new string[1] { alias }) || MatchesWeaponAliasToken(text2, new string[1] { alias }))))
			{
				num += 5200;
			}
			if (text2.Contains("/weapon/") || text2.Contains("/gun/") || text2.Contains("/rifle/") || text2.Contains("/smg/") || text2.Contains("/carbine/"))
			{
				num += 2000;
			}
			if (text.Contains("ak") || text.Contains("mpx") || text.Contains("hk") || text.Contains("weapon") || text.Contains("rifle") || text.Contains("gun") || text.Contains("smg") || text.Contains("carbine") || text.Contains("body") || text.Contains("main"))
			{
				num += 2400;
			}
			if (text.Contains("hand") || text2.Contains("/hand") || text.Contains("arm") || text.Contains("finger"))
			{
				num -= 20000;
			}
			if (text.Contains("bone") || text.Contains("helper") || text.Contains("socket") || text.Contains("locator"))
			{
				num -= 6000;
			}
			if (text.Contains("holiday") || text2.Contains("holiday"))
			{
				num -= 12000;
			}
			if (text.Contains("vfx") || text.Contains("effect") || text.Contains("spawn") || text.Contains("muzzle") || text.Contains("flash") || text.Contains("shell"))
			{
				num -= 8000;
			}
			if (num2 <= 64)
			{
				num -= 12000;
			}
			else if (num2 >= 400)
			{
				num += Mathf.Clamp(num2 / 3, 0, 6000);
			}
			num = ((((Renderer)renderer).sharedMaterials != null && ((Renderer)renderer).sharedMaterials.Length != 0) ? (num + Mathf.Clamp(((Renderer)renderer).sharedMaterials.Length * 120, 0, 600)) : (num - 3000));
			if (((Renderer)renderer).enabled)
			{
				num += 120;
			}
			return num;
		}

		private static void PrepareLocalWeaponVisualModel(GameObject modelObject, Transform targetVisualRoot)
		{
			if (!((Object)(object)modelObject == (Object)null))
			{
				BakeLocalWeaponSkinnedRenderers(modelObject);
				PrepareLocalWeaponRenderers(modelObject, targetVisualRoot);
			}
		}

		private static void PrepareLocalWeaponRenderers(GameObject root, Transform targetVisualRoot)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			bool flag = componentsInChildren.Any(IsRenderableLocalWeaponRenderer);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Mesh localRendererMesh = GetLocalRendererMesh(val);
				if (!((Object)localRendererMesh != (Object)null) || (flag && !IsRenderableLocalWeaponRenderer(val)))
				{
					val.enabled = false;
					val.forceRenderingOff = true;
					continue;
				}
				val.enabled = true;
				val.forceRenderingOff = false;
				val.allowOcclusionWhenDynamic = false;
				val.shadowCastingMode = (ShadowCastingMode)0;
				val.receiveShadows = false;
				val.lightProbeUsage = (LightProbeUsage)0;
				val.reflectionProbeUsage = (ReflectionProbeUsage)0;
				SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.updateWhenOffscreen = true;
				}
				int subMeshCount = Mathf.Max(localRendererMesh.subMeshCount, 1);
				val.sharedMaterials = BuildLocalViewMaterials(val.sharedMaterials, subMeshCount);
			}
		}

		private static bool IsRenderableLocalWeaponRenderer(Renderer renderer)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			Mesh localRendererMesh = GetLocalRendererMesh(renderer);
			if ((Object)localRendererMesh == (Object)null || localRendererMesh.vertexCount <= 0)
			{
				return false;
			}
			string text = ((((Object)renderer).name ?? string.Empty) + "/" + (FormatTransformPath(((Component)renderer).transform) ?? string.Empty)).ToLowerInvariant();
			string[] localWeaponExcludedRendererKeywords = LocalWeaponExcludedRendererKeywords;
			foreach (string value in localWeaponExcludedRendererKeywords)
			{
				if (text.Contains(value))
				{
					return false;
				}
			}
			return true;
		}

		private static Mesh GetLocalRendererMesh(Renderer renderer)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			if ((Object)(object)renderer == (Object)null)
			{
				return null;
			}
			MeshFilter component = ((Component)renderer).GetComponent<MeshFilter>();
			Mesh val = (((Object)(object)component != (Object)null) ? component.sharedMesh : null);
			if ((Object)val != (Object)null)
			{
				return val;
			}
			SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((renderer is SkinnedMeshRenderer) ? renderer : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2.sharedMesh;
			}
			return null;
		}

		private static void BakeLocalWeaponSkinnedRenderers(GameObject root)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			SkinnedMeshRenderer[] componentsInChildren = root.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			int num = 0;
			SkinnedMeshRenderer[] array = componentsInChildren;
			foreach (SkinnedMeshRenderer val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.sharedMesh == (Object)null)
				{
					continue;
				}
				try
				{
					Mesh val2 = new Mesh();
					((Object)val2).name = (((Object)val.sharedMesh).name ?? ((Object)val).name) + "_Baked";
					val.BakeMesh(val2);
					MeshFilter val3 = ((Component)val).GetComponent<MeshFilter>();
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = ((Component)val).gameObject.AddComponent<MeshFilter>();
					}
					MeshRenderer val4 = ((Component)val).GetComponent<MeshRenderer>();
					if ((Object)(object)val4 == (Object)null)
					{
						val4 = ((Component)val).gameObject.AddComponent<MeshRenderer>();
					}
					val3.sharedMesh = val2;
					int num2 = Mathf.Max(val2.subMeshCount, 1);
					Material[] array2 = ((Renderer)val).sharedMaterials?.ToArray() ?? Array.Empty<Material>();
					if (array2.Length == 0)
					{
						array2 = (Material[])(object)new Material[1] { GetLocalVisualFallbackMaterial() };
					}
					if (array2.Length != num2)
					{
						Material[] array3 = (Material[])(object)new Material[num2];
						for (int j = 0; j < num2; j++)
						{
							Material val5 = ((j < array2.Length) ? array2[j] : null);
							array3[j] = (((Object)(object)val5 != (Object)null) ? val5 : array2[Mathf.Clamp(array2.Length - 1, 0, array2.Length - 1)]);
							if ((Object)(object)array3[j] == (Object)null)
							{
								array3[j] = GetLocalVisualFallbackMaterial();
							}
						}
						array2 = array3;
					}
					((Renderer)val4).sharedMaterials = array2;
					((Renderer)val4).enabled = ((Renderer)val).enabled;
					((Renderer)val4).forceRenderingOff = ((Renderer)val).forceRenderingOff;
					((Renderer)val4).allowOcclusionWhenDynamic = ((Renderer)val).allowOcclusionWhenDynamic;
					((Renderer)val4).shadowCastingMode = ((Renderer)val).shadowCastingMode;
					((Renderer)val4).receiveShadows = ((Renderer)val).receiveShadows;
					Object.DestroyImmediate((Object)(object)val);
					num++;
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("[ShootZombies] BakeLocalWeaponSkinnedRenderers failed on " + ((Object)val).name + ": " + ex.Message));
				}
			}
		}

		private static void EnsureLocalVisualRenderers(int layer)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			if ((Object)(object)_localWeaponVisualRoot == (Object)null)
			{
				return;
			}
			SetLayerRecursively(_localWeaponVisualRoot, layer);
			Renderer[] componentsInChildren = ((Component)_localWeaponVisualRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (val is MeshRenderer)
				{
					MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
					if ((Object)(object)(((Object)(object)component != (Object)null) ? component.sharedMesh : null) != (Object)null)
					{
						val.enabled = true;
					}
				}
				else
				{
					SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						if ((Object)(object)val2.sharedMesh != (Object)null)
						{
							val.enabled = true;
						}
						val2.updateWhenOffscreen = true;
					}
				}
				val.forceRenderingOff = false;
				val.allowOcclusionWhenDynamic = false;
				val.shadowCastingMode = (ShadowCastingMode)0;
				val.receiveShadows = false;
			}
		}

		private static void ForceEnableAllLocalRenderers()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localWeaponVisualRoot == (Object)null)
			{
				return;
			}
			SetActiveRecursively(_localWeaponVisualRoot, active: true);
			Material localVisualFallbackMaterial = GetLocalVisualFallbackMaterial();
			Renderer[] componentsInChildren = ((Component)_localWeaponVisualRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				val.enabled = true;
				val.forceRenderingOff = false;
				val.allowOcclusionWhenDynamic = false;
				MeshRenderer val2 = (MeshRenderer)((val is MeshRenderer) ? val : null);
				if ((Object)(object)val2 != (Object)null)
				{
					MeshFilter component = ((Component)val2).GetComponent<MeshFilter>();
					Mesh val3 = (((Object)(object)component != (Object)null) ? component.sharedMesh : null);
					if ((Object)(object)val3 != (Object)null)
					{
						int num = Mathf.Max(val3.subMeshCount, 1);
						Material[] sharedMaterials = val.sharedMaterials;
						if (sharedMaterials != null && sharedMaterials.Length > num)
						{
							Material[] array = (Material[])(object)new Material[num];
							for (int j = 0; j < num; j++)
							{
								array[j] = sharedMaterials[j];
							}
							val.sharedMaterials = array;
						}
					}
				}
				else
				{
					SkinnedMeshRenderer val4 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
					if ((Object)(object)val4 != (Object)null)
					{
						val4.updateWhenOffscreen = true;
						Mesh sharedMesh = val4.sharedMesh;
						if ((Object)(object)sharedMesh != (Object)null)
						{
							int num2 = Mathf.Max(sharedMesh.subMeshCount, 1);
							Material[] sharedMaterials2 = val.sharedMaterials;
							if (sharedMaterials2 != null && sharedMaterials2.Length > num2)
							{
								Material[] array2 = (Material[])(object)new Material[num2];
								for (int k = 0; k < num2; k++)
								{
									array2[k] = sharedMaterials2[k];
								}
								val.sharedMaterials = array2;
							}
						}
					}
				}
				Material[] sharedMaterials3 = val.sharedMaterials;
				if (sharedMaterials3 == null || sharedMaterials3.Length == 0)
				{
					val.sharedMaterial = localVisualFallbackMaterial;
					continue;
				}
				bool flag = false;
				for (int l = 0; l < sharedMaterials3.Length; l++)
				{
					Material val5 = sharedMaterials3[l];
					bool flag2 = false;
					if ((Object)(object)val5 == (Object)null || (Object)(object)val5.shader == (Object)null || !val5.shader.isSupported)
					{
						flag2 = true;
					}
					if (!flag2 && val5.HasProperty("_Surface") && val5.GetFloat("_Surface") > 0.5f)
					{
						flag2 = true;
					}
					if (!flag2 && val5.renderQueue >= 3000)
					{
						flag2 = true;
					}
					if (flag2)
					{
						sharedMaterials3[l] = localVisualFallbackMaterial;
						flag = true;
						continue;
					}
					if (val5.HasProperty("_BaseColor"))
					{
						Color color = val5.GetColor("_BaseColor");
						color.a = 1f;
						val5.SetColor("_BaseColor", color);
					}
					if (val5.HasProperty("_Color"))
					{
						Color color2 = val5.GetColor("_Color");
						color2.a = 1f;
						val5.SetColor("_Color", color2);
					}
					if (val5.HasProperty("_Cull"))
					{
						val5.SetFloat("_Cull", 0f);
					}
				}
				if (flag)
				{
					val.sharedMaterials = sharedMaterials3;
				}
			}
		}

		private static void StripLocalVisualBehaviours(GameObject visualModel)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			if ((Object)(object)visualModel == (Object)null)
			{
				return;
			}
			foreach (Component item in visualModel.GetComponentsInChildren<Component>(true).Reverse())
			{
				if (!((Object)item == (Object)null) && !(item is Transform) && !(item is MeshFilter) && !(item is MeshRenderer) && !(item is SkinnedMeshRenderer))
				{
					Behaviour val = (Behaviour)((item is Behaviour) ? item : null);
					if ((Object)(object)val != (Object)null)
					{
						val.enabled = false;
					}
					Collider val2 = (Collider)((item is Collider) ? item : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.enabled = false;
					}
					Renderer val3 = (Renderer)((item is Renderer) ? item : null);
					if ((Object)(object)val3 != (Object)null)
					{
						val3.enabled = false;
						val3.forceRenderingOff = true;
					}
					Object.Destroy((Object)item);
				}
			}
		}

		private static void NormalizeLocalVisualModel(Transform modelRoot)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)modelRoot == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)modelRoot).GetComponentsInChildren<Renderer>(true);
			bool flag = false;
			Bounds val = default(Bounds);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					if (!flag)
					{
						val = val2.bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref val)).Encapsulate(val2.bounds);
					}
				}
			}
			if (flag)
			{
				Vector3 val3 = modelRoot.InverseTransformPoint(((Bounds)(ref val)).center);
				if (IsFiniteVector(val3) && ((Vector3)(ref val3)).sqrMagnitude > 1E-06f)
				{
					modelRoot.localPosition -= val3;
				}
				float num = Mathf.Max(new float[3]
				{
					((Bounds)(ref val)).size.x,
					((Bounds)(ref val)).size.y,
					((Bounds)(ref val)).size.z
				});
				if (num > 0.0001f)
				{
					float num2 = Mathf.Clamp(0.65f / num, 0.08f, 3f);
					modelRoot.localScale *= num2;
				}
			}
		}

		private static void SetActiveRecursively(Transform root, bool active)
		{
			if (!((Object)(object)root == (Object)null))
			{
				((Component)root).gameObject.SetActive(active);
				for (int i = 0; i < root.childCount; i++)
				{
					SetActiveRecursively(root.GetChild(i), active);
				}
			}
		}

		private static int CountMeshBackedRenderers(Transform root)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return 0;
			}
			int num = 0;
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (val is MeshRenderer)
				{
					MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
					if ((Object)(object)(((Object)(object)component != (Object)null) ? component.sharedMesh : null) != (Object)null)
					{
						num++;
					}
				}
				else
				{
					SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)((val is SkinnedMeshRenderer) ? val : null);
					if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMesh != (Object)null)
					{
						num++;
					}
				}
			}
			return num;
		}

		private static void EnsureLocalVisualFallbackGeometry(Transform modelRoot)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_0115: 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)
			if ((Object)(object)modelRoot == (Object)null || (Object)(object)modelRoot.Find("AK47_LocalFallback") != (Object)null)
			{
				return;
			}
			GameObject val = new GameObject("AK47_LocalFallback");
			val.transform.SetParent(modelRoot, false);
			val.transform.localPosition = new Vector3(0f, -0.01f, 0.12f);
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			obj.transform.SetParent(val.transform, false);
			obj.transform.localScale = new Vector3(0.06f, 0.06f, 0.42f);
			obj.transform.localPosition = new Vector3(0f, 0f, 0.15f);
			GameObject obj2 = GameObject.CreatePrimitive((PrimitiveType)2);
			obj2.transform.SetParent(val.transform, false);
			obj2.transform.localRotation = Quaternion.Euler(90f, 0f, 0f);
			obj2.transform.localScale = new Vector3(0.011f, 0.18f, 0.011f);
			obj2.transform.localPosition = new Vector3(0f, -0.005f, 0.39f);
			Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					val2.sharedMaterial = GetLocalVisualFallbackMaterial();
				}
			}
			Collider[] componentsInChildren2 = val.GetComponentsInChildren<Collider>(true);
			foreach (Collider val3 in componentsInChildren2)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					val3.enabled = false;
				}
			}
		}

		private static void CleanupLocalVisualFallbackGeometry(Transform modelRoot)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (!((Object)(object)modelRoot == (Object)null))
			{
				Transform val = modelRoot.Find("AK47_LocalFallback");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)((Component)val).gameObject);
				}
			}
		}

		private static Material GetLocalVisualFallbackMaterial()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localVisualFallbackMaterial != (Object)null)
			{
				return _localVisualFallbackMaterial;
			}
			Shader val = ResolveLocalVisualCompatibleShader() ?? Shader.Find("Sprites/Default");
			_localVisualFallbackMaterial = (((Object)(object)val != (Object)null) ? new Material(val) : new Material(Shader.Find("W/Peak_Standard") ?? Shader.Find("Standard")));
			((Object)_localVisualFallbackMaterial).name = "AK47_LocalVisualFallbackMat";
			if (_localVisualFallbackMaterial.HasProperty("_BaseColor"))
			{
				_localVisualFallbackMaterial.SetColor("_BaseColor", new Color(0.24f, 0.25f, 0.27f, 1f));
			}
			if (_localVisualFallbackMaterial.HasProperty("_Color"))
			{
				_localVisualFallbackMaterial.SetColor("_Color", new Color(0.24f, 0.25f, 0.27f, 1f));
			}
			if (_localVisualFallbackMaterial.HasProperty("_Metallic"))
			{
				_localVisualFallbackMaterial.SetFloat("_Metallic", 0.55f);
			}
			if (_localVisualFallbackMaterial.HasProperty("_Smoothness"))
			{
				_localVisualFallbackMaterial.SetFloat("_Smoothness", 0.35f);
			}
			if (_localVisualFallbackMaterial.HasProperty("_Glossiness"))
			{
				_localVisualFallbackMaterial.SetFloat("_Glossiness", 0.35f);
			}
			if (_localVisualFallbackMaterial.HasProperty("_Cull"))
			{
				_localVisualFallbackMaterial.SetFloat("_Cull", 0f);
			}
			_localVisualFallbackMaterial.renderQueue = -1;
			return _localVisualFallbackMaterial;
		}

		private static Shader ResolveLocalVisualCompatibleShader()
		{
			return Shader.Find("Unlit/Texture") ?? Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default") ?? Shader.Find("W/Peak_Standard") ?? Shader.Find("Standard") ?? Shader.Find("Legacy Shaders/Diffuse") ?? Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Hidden/InternalErrorShader");
		}

		private static int ResolveVisibleLayerForCamera(Transform fallbackAnchor)
		{
			Camera val = null;
			if ((Object)(object)fallbackAnchor != (Object)null)
			{
				val = ((Component)fallbackAnchor).GetComponentInParent<Camera>();
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Camera.main;
			}
			if ((Object)(object)val == (Object)null)
			{
				if (!((Object)(object)fallbackAnchor != (Object)null))
				{
					return 0;
				}
				return ((Component)fallbackAnchor).gameObject.layer;
			}
			int cullingMask = val.cullingMask;
			if (((uint)cullingMask & (true ? 1u : 0u)) != 0)
			{
				return 0;
			}
			int layer = ((Component)val).gameObject.layer;
			if ((cullingMask & (1 << layer)) != 0)
			{
				return layer;
			}
			for (int i = 0; i < 32; i++)
			{
				if ((cullingMask & (1 << i)) != 0)
				{
					return i;
				}
			}
			if (!((Object)(object)fallbackAnchor != (Object)null))
			{
				return 0;
			}
			return ((Component)fallbackAnchor).gameObject.layer;
		}

		private static int ResolveLocalWeaponVisibleLayer(Transform viewAnchor, Item item, params Transform[] preferredAnchors)
		{
			Camera val = null;
			if ((Object)(object)viewAnchor != (Object)null)
			{
				val = ((Component)viewAnchor).GetComponent<Camera>() ?? ((Component)viewAnchor).GetComponentInParent<Camera>();
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Camera.main;
			}
			int num = (((Object)(object)val != (Object)null) ? val.cullingMask : (-1));
			if (((uint)num & (true ? 1u : 0u)) != 0)
			{
				return 0;
			}
			List<int> list = new List<int>();
			int i;
			if (preferredAnchors != null)
			{
				for (i = 0; i < preferredAnchors.Length; i++)
				{
					Transform val2 = preferredAnchors[i];
					if ((Object)(object)val2 != (Object)null)
					{
						list.Add(((Component)val2).gameObject.layer);
					}
				}
			}
			if ((Object)(object)item != (Object)null)
			{
				if ((Object)(object)item.mainRenderer != (Object)null)
				{
					list.Add(((Component)item.mainRenderer).gameObject.layer);
				}
				list.Add(((Component)item).gameObject.layer);
			}
			if ((Object)(object)val != (Object)null)
			{
				list.Add(((Component)val).gameObject.layer);
			}
			foreach (int item2 in list.Distinct())
			{
				if (item2 <= 0 || item2 >= 32 || (num & (1 << item2)) == 0)
				{
					continue;
				}
				i = item2;
				goto IL_0170;
			}
			foreach (int item3 in list.Distinct())
			{
				if (item3 < 0 || item3 >= 32 || (num & (1 << item3)) == 0)
				{
					continue;
				}
				i = item3;
				goto IL_0170;
			}
			return ResolveVisibleLayerForCamera(viewAnchor);
			IL_0170:
			return i;
		}

		private static void UpdateLocalWeaponMuzzle()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_0098: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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)
			if ((Object)(object)_localWeaponVisualModel == (Object)null)
			{
				_localWeaponMuzzle = null;
				return;
			}
			if ((Object)(object)_localWeaponMuzzle == (Object)null)
			{
				GameObject val = new GameObject("AK47_LocalMuzzle");
				val.transform.SetParent(_localWeaponVisualModel, false);
				_localWeaponMuzzle = val.transform;
			}
			Transform val2 = FindPreferredLocalMuzzleTransform(_localWeaponVisualModel);
			if ((Object)(object)val2 != (Object)null)
			{
				_localWeaponMuzzle.position = val2.position;
				_localWeaponMuzzle.rotation = val2.rotation;
				return;
			}
			Renderer val3 = FindBestLocalMuzzleRenderer();
			if ((Object)(object)val3 != (Object)null)
			{
				Bounds bounds = val3.bounds;
				_localWeaponMuzzle.position = ((Bounds)(ref bounds)).center + ((Component)val3).transform.forward * Mathf.Max(((Bounds)(ref bounds)).extents.z, 0.06f);
				_localWeaponMuzzle.rotation = ((Component)val3).transform.rotation;
			}
			else
			{
				_localWeaponMuzzle.position = _localWeaponVisualModel.position + _localWeaponVisualModel.forward * 0.55f;
				_localWeaponMuzzle.rotation = _localWeaponVisualModel.rotation;
			}
		}

		private static Transform FindPreferredLocalMuzzleTransform(Transform root)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Transform val = null;
			int num = 0;
			float num2 = float.MinValue;
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string text = (((Object)val2).name ?? string.Empty).ToLowerInvariant();
				int num3 = 0;
				if (text.Contains("muzzle"))
				{
					num3 += 100;
				}
				if (text.Contains("barrel"))
				{
					num3 += 85;
				}
				if (text.Contains("firepoint") || text.Contains("fire_point"))
				{
					num3 += 80;
				}
				if (text.Contains("tip") || text.Contains("end"))
				{
					num3 += 60;
				}
				if (text.Contains("spawn"))
				{
					num3 += 20;
				}
				if (text.Contains("shell") || text.Contains("eject") || text.Contains("mag") || text.Contains("clip"))
				{
					num3 -= 80;
				}
				if (num3 > 0)
				{
					float num4 = Vector3.Dot(val2.position - root.position, root.forward);
					if ((Object)val == (Object)null || num3 > num || (num3 == num && num4 > num2))
					{
						val = val2;
						num = num3;
						num2 = num4;
					}
				}
			}
			return val;
		}

		private static Renderer FindBestLocalMuzzleRenderer()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localWeaponVisualModel == (Object)null)
			{
				return null;
			}
			Renderer[] componentsInChildren = ((Component)_localWeaponVisualModel).GetComponentsInChildren<Renderer>(true);
			Renderer result = null;
			float num = float.MinValue;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null) && val.enabled)
				{
					Bounds bounds = val.bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					float num2 = ((Vector3)(ref size)).magnitude + ((Bounds)(ref bounds)).center.z;
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static void CleanupLocalWeaponVisual()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//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_004e: 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)
			RestoreLocalFirstPersonHandRenderers();
			if ((Object)(object)_localWeaponVisualRoot != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_localWeaponVisualRoot).gameObject);
			}
			_localWeaponVisualRoot = null;
			_localWeaponVisualModel = null;
			_localWeaponMuzzle = null;
			_weaponVisualOwner = null;
			_localWeaponSourceItemId = 0;
			_localWeaponModelBasePosition = Vector3.zero;
			_localWeaponModelBaseRotation = Quaternion.identity;
			_localWeaponModelBaseScale = Vector3.one;
			_localWeaponModelUsesPreparedPose = false;
			_pendingLocalWeaponVisualModelRefresh = false;
		}

		private void EnsureLocalHeldDebugSphere(Item heldBlowgunItem)
		{
			CleanupLocalHeldDebugSphere();
		}

		private static void CleanupLocalHeldDebugSphere()
		{
			if ((Object)(object)_localHeldDebugSphereRoot != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_localHeldDebugSphereRoot).gameObject);
			}
			_localHeldDebugSphereRoot = null;
		}

		private static Material GetLocalHeldDebugSphereMaterial()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localHeldDebugSphereMaterial != (Object)null)
			{
				return _localHeldDebugSphereMaterial;
			}
			_localHeldDebugSphereMaterial = new Material(Shader.Find("Unlit/Color") ?? Shader.Find("Sprites/Default") ?? Shader.Find("Standard"));
			((Object)_localHeldDebugSphereMaterial).name = "ShootZombies_LocalHeldDebugSphere";
			if (_localHeldDebugSphereMaterial.HasProperty("_Color"))
			{
				_localHeldDebugSphereMaterial.SetColor("_Color", new Color(1f, 0.05f, 0.05f, 1f));
			}
			if (_localHeldDebugSphereMaterial.HasProperty("_BaseColor"))
			{
				_localHeldDebugSphereMaterial.SetColor("_BaseColor", new Color(1f, 0.05f, 0.05f, 1f));
			}
			if (_localHeldDebugSphereMaterial.HasProperty("_EmissionColor"))
			{
				_localHeldDebugSphereMaterial.EnableKeyword("_EMISSION");
				_localHeldDebugSphereMaterial.SetColor("_EmissionColor", new Color(1.5f, 0.08f, 0.08f, 1f));
			}
			if (_localHeldDebugSphereMaterial.HasProperty("_Cull"))
			{
				_localHeldDebugSphereMaterial.SetInt("_Cull", 0);
			}
			return _localHeldDebugSphereMaterial;
		}

		[IteratorStateMachine(typeof(<PeriodicPlayerScan>d__905))]
		private IEnumerator PeriodicPlayerScan()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PeriodicPlayerScan>d__905(0);
		}

		private static bool TryGrantWeaponWithAuthority(Character c, int ownerActorNr)
		{
			if ((Object)(object)c == (Object)null || ownerActorNr == int.MinValue)
			{
				return false;
			}
			if (CharacterAlreadyHasShootZombiesWeapon(c))
			{
				MarkWeaponGrantedForActor(ownerActorNr);
				return true;
			}
			if (ShouldGrantLoadoutDirectly(c))
			{
				if (!TryGiveItemTo(c))
				{
					return false;
				}
				MarkWeaponGrantedForActor(ownerActorNr);
				return true;
			}
			return TryRequestRemoteLoadoutGrant(c, 1);
		}

		private static bool TryGrantFirstAidWithAuthority(Character c, int ownerActorNr)
		{
			if ((Object)(object)c == (Object)null || ownerActorNr == int.MinValue)
			{
				return false;
			}
			if (CharacterAlreadyHasFirstAid(c))
			{
				MarkFirstAidGrantedForActor(ownerActorNr);
				return true;
			}
			if (ShouldGrantLoadoutDirectly(c))
			{
				if (!TryGiveFirstAidTo(c))
				{
					return false;
				}
				MarkFirstAidGrantedForActor(ownerActorNr);
				return true;
			}
			return TryRequestRemoteLoadoutGrant(c, 2);
		}

		private static bool ShouldGrantLoadoutDirectly(Character c)
		{
			if ((Object)(object)c == (Object)null)
			{
				return false;
			}
			if (!HasOnlineRoomSession())
			{
				return true;
			}
			if ((Object)(object)c == (Object)(object)Character.localCharacter || (Object)(object)c == (Object)(object)_localCharacter)
			{
				return true;
			}
			PhotonView val = c.refs?.view;
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)c).GetComponent<PhotonView>() ?? ((Component)c).GetComponentInParent<PhotonView>();
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!val.IsMine)
			{
				return val.OwnerActorNr <= 0;
			}
			return true;
		}

		private static bool IsLoadoutGrantEligible(Character c)
		{
			if ((Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return false;
			}
			try
			{
				CharacterData data = c.data;
				if ((Object)(object)data != (Object)null && (data.dead || data.passedOut || data.fullyPassedOut))
				{
					return false;
				}
				if (c.warping)
				{
					return false;
				}
				return true;
			}
			catch
			{
				return IsAlive(c);
			}
		}

		private static bool IsAlive(Character c)
		{
			if ((Object)(object)c == (Object)null)
			{
				return false;
			}
			try
			{
				CharacterData data = c.data;
				if ((Object)(object)data == (Object)null)
				{
					return true;
				}
				FieldInfo field = ((object)data).GetType().GetField("dead", BindingFlags.Instance | BindingFlags.Public);
				if (field != null)
				{
					return !(bool)field.GetValue(data);
				}
				return true;
			}
			catch
			{
				return true;
			}
		}

		private static bool TryGiveItemTo(Character c, bool ignoreFeatureGate = false)
		{
			try
			{
				if (!ignoreFeatureGate && !IsWeaponFeatureEnabled())
				{
					return false;
				}
				if ((Object)(object)c == (Object)null || c.isBot || c.isZombie)
				{
					return false;
				}
				if (!IsLoadoutGrantEligible(c))
				{
					return false;
				}
				Player player = c.player;
				if ((Object)(object)player == (Object)null || player.itemSlots == null)
				{
					return false;
				}
				if (CharacterAlreadyHasShootZombiesWeapon(c))
				{
					EnforceSingleWeaponForCharacter(c, equipIfHandsFree: true);
					TryEquipExistingWeaponSlot(c);
					MarkWeaponGrantedForCharacter(c);
					return true;
				}
				int preferredWeaponSlot = GetPreferredWeaponSlot(player);
				if (preferredWeaponSlot < 0)
				{
					return false;
				}
				if (!TryResolveBaseWeaponItem(out var item))
				{
					Log.LogError((object)"[ShootZombies] Failed to resolve base blowgun item from ItemDatabase");
					return false;
				}
				if (!TrySetItemIntoSlot(player, preferredWeaponSlot, item, 999))
				{
					return false;
				}
				TryProtectWeaponItemRuntime(item);
				TrySyncInventoryRpc(c, player, "weapon-slot");
				EnforceSingleWeaponForCharacter(c, equipIfHandsFree: true);
				TryEquipExistingWeaponSlot(c);
				if ((Object)(object)c.refs?.view != (Object)null)
				{
					_ = c.refs.view.IsMine;
				}
				if (!c.isBot && !c.isZombie)
				{
					_localCharacter = c;
					_hasWeapon = true;
					_cachedHeldBlowgunItem = null;
					_lastHeldBlowgunSearchTime = -10f;
					_lastHeldWeaponSeenTime = Time.time;
				}
				MarkWeaponGrantedForCharacter(c);
				TryScheduleDelayedBlowgunReplacement();
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TryGiveItemTo failed: " + ex.Message));
				return false;
			}
		}

		private static bool CharacterAlreadyHasShootZombiesWeapon(Character c)
		{
			if ((Object)(object)c == (Object)null)
			{
				return false;
			}
			try
			{
				CharacterData data = c.data;
				Item val = (((Object)(object)data != (Object)null) ? data.currentItem : null);
				if ((Object)(object)val != (Object)null && ItemPatch.IsBlowgunLike(val))
				{
					return true;
				}
			}
			catch
			{
			}
			if (PlayerInventoryContains(c.player, (Item itemFromSlot) => (Object)(object)itemFromSlot != (Object)null && ItemPatch.IsBlowgunLike(itemFromSlot)))
			{
				return true;
			}
			return false;
		}

		private static Item GetHeldBlowgunItemForCharacter(Character c)
		{
			if ((Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return null;
			}
			try
			{
				CharacterData data = c.data;
				Item val = (((Object)(object)data != (Object)null) ? data.currentItem : null);
				if (IsHeldBlowgunOwnedByCharacter(val, c))
				{
					return val;
				}
			}
			catch
			{
			}
			Player player = c.player;
			if ((Object)(object)player != (Object)null && player.itemSlots != null)
			{
				ItemSlot[] itemSlots = player.itemSlots;
				for (int i = 0; i < itemSlots.Length; i++)
				{
					Item itemFromSlot = GetItemFromSlot(itemSlots[i]);
					if (IsHeldBlowgunOwnedByCharacter(itemFromSlot, c))
					{
						return itemFromSlot;
					}
				}
			}
			Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
			foreach (Item val2 in array)
			{
				if (IsHeldBlowgunOwnedByCharacter(val2, c))
				{
					return val2;
				}
			}
			return null;
		}

		private static Item GetVisualSourceItemForCharacter(Character c)
		{
			Item heldBlowgunItemForCharacter = GetHeldBlowgunItemForCharacter(c);
			if ((Object)(object)heldBlowgunItemForCharacter != (Object)null)
			{
				return heldBlowgunItemForCharacter;
			}
			if (TryResolveBaseWeaponItem(out var item))
			{
				return item;
			}
			return null;
		}

		private static bool CharacterAlreadyHasFirstAid(Character c)
		{
			if ((Object)(object)c == (Object)null)
			{
				return false;
			}
			try
			{
				CharacterData data = c.data;
				if (IsFirstAidLike(((Object)(object)data != (Object)null) ? data.currentItem : null))
				{
					return true;
				}
			}
			catch
			{
			}
			if (PlayerInventoryContains(c.player, IsFirstAidLike))
			{
				return true;
			}
			return false;
		}

		private static bool IsFirstAidLike(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			try
			{
				if (item.itemID == 29)
				{
					return true;
				}
				if ((Object)(object)item.isSecretlyOtherItemPrefab != (Object)null && item.isSecretlyOtherItemPrefab.itemID == 29)
				{
					return true;
				}
				string text = (((item.UIData?.itemName ?? item.GetName()) ?? string.Empty) + "|" + (((Object)item).name ?? string.Empty)).ToLowerInvariant();
				return text.Contains("firstaid") || text.Contains("first aid") || text.Contains("medkit") || text.Contains("bandage") || text.Contains("急救") || text.Contains("医疗");
			}
			catch
			{
				return false;
			}
		}

		private static bool PlayerInventoryContains(Player player, Func<Item, bool> matcher)
		{
			if ((Object)(object)player == (Object)null || matcher == null)
			{
				return false;
			}
			try
			{
				if (player.itemSlots != null)
				{
					ItemSlot[] itemSlots = player.itemSlots;
					for (int i = 0; i < itemSlots.Length; i++)
					{
						if (matcher(GetItemFromSlot(itemSlots[i])))
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			if (matcher(GetSpecialPlayerSlotItem(player, "backpackSlot")))
			{
				return true;
			}
			if (matcher(GetSpecialPlayerSlotItem(player, "tempFullSlot")))
			{
				return true;
			}
			return false;
		}

		private static Item GetSpecialPlayerSlotItem(Player player, string memberName)
		{
			if ((Object)(object)player == (Object)null || string.IsNullOrWhiteSpace(memberName))
			{
				return null;
			}
			try
			{
				Type type = ((object)player).GetType();
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				object obj = type.GetField(memberName, bindingAttr)?.GetValue(player);
				if (obj == null)
				{
					obj = type.GetProperty(memberName, bindingAttr)?.GetValue(player);
				}
				return GetItemFromSlot(obj);
			}
			catch
			{
				return null;
			}
		}

		private static Item GetItemFromSlot(object slot)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			try
			{
				if (slot == null)
				{
					return null;
				}
				Item val = (Item)((slot is Item) ? slot : null);
				if (val != null)
				{
					return val;
				}
				object obj = slot.GetType().GetProperty("item")?.GetValue(slot);
				if ((Object)((obj is Item) ? obj : null) != (Object)null)
				{
					return (Item)((obj is Item) ? obj : null);
				}
				FieldInfo field = slot.GetType().GetField("item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					object value = field.GetValue(slot);
					return (Item)((value is Item) ? value : null);
				}
			}
			catch
			{
			}
			return null;
		}

		private static bool TryGiveCompassTo(Character c)
		{
			if (!IsFogModeEnabled() || (Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return false;
			}
			try
			{
				Player player = c.player;
				if ((Object)(object)player == (Object)null || player.itemSlots == null)
				{
					return false;
				}
				if (CharacterAlreadyHasNormalCompass(c))
				{
					return true;
				}
				if (!TryResolveNormalCompassItem(out var item))
				{
					return false;
				}
				int preferredCompassSlot = GetPreferredCompassSlot(player);
				if (preferredCompassSlot >= 0)
				{
					if (!TrySetItemIntoSlot(player, preferredCompassSlot, item, 999))
					{
						return false;
					}
					if (EnableVerboseInfoLogs)
					{
						Log.LogInfo((object)("[ShootZombies] Compass granted to player: " + ((Object)c).name));
					}
					return true;
				}
				return TrySpawnCompassAboveHead(c, item);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TryGiveCompassTo failed: " + ex.Message));
				return false;
			}
		}

		private static int GetPreferredCompassSlot(Player player)
		{
			if ((Object)(object)player == (Object)null || player.itemSlots == null || player.itemSlots.Length == 0)
			{
				return -1;
			}
			if (player.itemSlots[0].IsEmpty())
			{
				return 0;
			}
			for (int i = 1; i < player.itemSlots.Length; i++)
			{
				if (player.itemSlots[i].IsEmpty())
				{
					return i;
				}
			}
			return -1;
		}

		private static bool CharacterAlreadyHasNormalCompass(Character c)
		{
			if ((Object)(object)c == (Object)null)
			{
				return false;
			}
			try
			{
				CharacterData data = c.data;
				if (IsNormalCompassLike(((Object)(object)data != (Object)null) ? data.currentItem : null))
				{
					return true;
				}
			}
			catch
			{
			}
			if (PlayerInventoryContains(c.player, IsNormalCompassLike))
			{
				return true;
			}
			return false;
		}

		private static bool IsNormalCompassLike(Item item)
		{
			return ScoreNormalCompassItem(item) > 0;
		}

		private static bool TryResolveNormalCompassItem(out Item item)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			item = null;
			int num = 0;
			try
			{
				Object[] array = Resources.FindObjectsOfTypeAll(typeof(Object));
				foreach (Object val in array)
				{
					if (val == (Object)null || ((object)val).GetType().Name != "ItemDatabase" || !(((object)val).GetType().GetField("itemLookup", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val) is IDictionary dictionary))
					{
						continue;
					}
					foreach (DictionaryEntry item2 in dictionary)
					{
						object value = item2.Value;
						Item val2 = (Item)((value is Item) ? value : null);
						int num2 = ScoreNormalCompassItem(val2);
						if (num2 > num)
						{
							num = num2;
							item = val2;
						}
					}
					break;
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TryResolveNormalCompassItem database scan failed: " + ex.Message));
			}
			if ((Object)(object)item == (Object)null)
			{
				try
				{
					Item[] array2 = Resources.FindObjectsOfTypeAll<Item>();
					foreach (Item val3 in array2)
					{
						int num3 = ScoreNormalCompassItem(val3);
						if (num3 > num)
						{
							num = num3;
							item = val3;
						}
					}
				}
				catch (Exception ex2)
				{
					Log.LogWarning((object)("[ShootZombies] TryResolveNormalCompassItem resource scan failed: " + ex2.Message));
				}
			}
			return (Object)(object)item != (Object)null;
		}

		private static int ScoreNormalCompassItem(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return 0;
			}
			string text = (((Object)((Component)item).gameObject).name ?? string.Empty).ToLowerInvariant();
			string text2 = (item.GetName() ?? string.Empty).ToLowerInvariant();
			string text3 = (item.UIData?.itemName ?? string.Empty).ToLowerInvariant();
			string text4 = text + "|" + text2 + "|" + text3;
			if (!text4.Contains("compass") && !text4.Contains("指南针") && !text4.Contains("罗盘"))
			{
				return 0;
			}
			if (text4.Contains("warp") || text4.Contains("pirate") || text4.Contains("传送") || text4.Contains("海盗"))
			{
				return 0;
			}
			if ((Object)(object)((Component)item).GetComponentInChildren(typeof(WarpCompassVFX), true) != (Object)null)
			{
				return 0;
			}
			int num = 1000;
			if (text4.Contains("normal") || text4.Contains("普通"))
			{
				num += 300;
			}
			if (TryIsNormalCompassPointer(item))
			{
				num += 800;
			}
			return num;
		}

		private static bool TryIsNormalCompassPointer(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			try
			{
				Type type = typeof(Item).Assembly.GetType("CompassPointer");
				if (type == null)
				{
					return false;
				}
				Component componentInChildren = ((Component)item).GetComponentInChildren(type, true);
				if ((Object)(object)componentInChildren == (Object)null)
				{
					return false;
				}
				FieldInfo field = type.GetField("compassType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null)
				{
					return false;
				}
				object value = field.GetValue(componentInChildren);
				return value != null && Convert.ToInt32(value, CultureInfo.InvariantCulture) == 0;
			}
			catch
			{
				return false;
			}
		}

		private static bool TrySpawnCompassAboveHead(Character c, Item item)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c == (Object)null || (Object)(object)item == (Object)null)
			{
				return false;
			}
			string name = ((Object)((Component)item).gameObject).name;
			Vector3 val = c.Center + Vector3.up * 3f;
			Quaternion identity = Quaternion.identity;
			try
			{
				Item val2 = null;
				if (PhotonNetwork.InRoom && !PhotonNetwork.OfflineMode && !string.IsNullOrWhiteSpace(name))
				{
					GameObject val3 = PhotonNetwork.Instantiate("0_Items/" + name, val, identity, (byte)0, (object[])null);
					if ((Object)(object)val3 != (Object)null)
					{
						val2 = val3.GetComponent<Item>();
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					GameObject gameObject = ((Component)item).gameObject;
					if ((Object)(object)gameObject != (Object)null)
					{
						val2 = Object.Instantiate<GameObject>(gameObject, val, identity).GetComponent<Item>();
					}
				}
				if ((Object)(object)val2 != (Object)null)
				{
					TrySetItemGroundState(val2);
					if (EnableVerboseInfoLogs)
					{
						Log.LogInfo((object)("[ShootZombies] Compass spawned above head for player: " + ((Object)c).name));
					}
					return true;
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TrySpawnCompassAboveHead failed: " + ex.Message));
			}
			return false;
		}

		private static void TrySetItemGroundState(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			try
			{
				Type type = ((object)item).GetType();
				MethodInfo method = type.GetMethod("SetState", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
				{
					type.Assembly.GetType("ItemState") ?? typeof(int),
					typeof(Character)
				}, null);
				if (method != null)
				{
					Type type2 = type.Assembly.GetType("ItemState");
					object obj = ((type2 != null && type2.IsEnum) ? Enum.ToObject(type2, 0) : ((object)0));
					method.Invoke(item, new object[2] { obj, null });
				}
				else
				{
					FieldInfo fieldInfo = type.GetField("<itemState>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? type.GetField("itemState", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (fieldInfo != null)
					{
						object value = ((fieldInfo.FieldType.IsEnum && fieldInfo.FieldType.FullName == "ItemState") ? Enum.ToObject(fieldInfo.FieldType, 0) : ((object)0));
						fieldInfo.SetValue(item, value);
					}
				}
			}
			catch
			{
			}
		}

		private static bool TrySpawnCompassViaCharacterItems(Character c, string itemObjectName)
		{
			return TrySpawnItemInHandViaCharacterItems(c, itemObjectName, "compass");
		}

		private static bool TrySpawnWeaponViaCharacterItems(Character c, Item item)
		{
			if ((Object)(object)c == (Object)null || (Object)(object)item == (Object)null)
			{
				return false;
			}
			string name = ((Object)((Component)item).gameObject).name;
			if (!TrySpawnItemInHandViaCharacterItems(c, name, "weapon"))
			{
				return false;
			}
			return CharacterAlreadyHasShootZombiesWeapon(c);
		}

		private static bool TrySpawnItemInHandViaCharacterItems(Character c, string itemObjectName, string context)
		{
			if ((Object)(object)c == (Object)null || string.IsNullOrWhiteSpace(itemObjectName))
			{
				return false;
			}
			try
			{
				object obj = c.refs?.items;
				MethodInfo methodInfo = obj?.GetType().GetMethod("SpawnItemInHand", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (methodInfo == null)
				{
					return false;
				}
				methodInfo.Invoke(obj, new object[1] { itemObjectName });
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TrySpawnItemInHandViaCharacterItems failed (" + context + "): " + ex.Message));
				return false;
			}
		}

		private static bool TryGiveFirstAidTo(Character c, bool ignoreFeatureGate = false)
		{
			try
			{
				if (!ignoreFeatureGate && !IsWeaponFeatureEnabled())
				{
					return false;
				}
				if ((Object)(object)c == (Object)null || c.isBot || c.isZombie)
				{
					return false;
				}
				if (!IsLoadoutGrantEligible(c))
				{
					return false;
				}
				Player player = c.player;
				if ((Object)(object)player == (Object)null || player.itemSlots == null)
				{
					return false;
				}
				if (CharacterAlreadyHasFirstAid(c))
				{
					MarkFirstAidGrantedForCharacter(c);
					return true;
				}
				int num = -1;
				for (int i = 0; i < player.itemSlots.Length; i++)
				{
					if (player.itemSlots[i].IsEmpty())
					{
						num = i;
						break;
					}
				}
				if (num == -1)
				{
					return false;
				}
				if (!TryResolveFirstAidItem(out var item))
				{
					return false;
				}
				if ((Object)(object)item == (Object)null)
				{
					return false;
				}
				if (!TrySetItemIntoSlot(player, num, item, 1))
				{
					return false;
				}
				MarkFirstAidGrantedForCharacter(c);
				TrySyncInventoryRpc(c, player, "first-aid");
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TryGiveFirstAidTo failed: " + ex.Message));
				return false;
			}
		}

		private static void TrySyncInventoryRpc(Character c, Player player, string context)
		{
			if ((Object)(object)c == (Object)null || (Object)(object)player == (Object)null || (Object)(object)c.refs?.view == (Object)null)
			{
				return;
			}
			try
			{
				Type type = typeof(Item).Assembly.GetType("InventorySyncData");
				Type type2 = typeof(Item).Assembly.GetType("InventorySyncData+SlotData");
				if (type == null || type2 == null)
				{
					return;
				}
				List<object> list = new List<object>();
				ItemSlot[] itemSlots = player.itemSlots;
				foreach (ItemSlot val in itemSlots)
				{
					object obj = Activator.CreateInstance(type2);
					FieldInfo field = type2.GetField("item", BindingFlags.Instance | BindingFlags.Public);
					FieldInfo field2 = type2.GetField("data", BindingFlags.Instance | BindingFlags.Public);
					object value = ((object)val).GetType().GetProperty("item")?.GetValue(val);
					object value2 = ((object)val).GetType().GetProperty("data")?.GetValue(val);
					if (field != null)
					{
						field.SetValue(obj, value);
					}
					if (field2 != null)
					{
						field2.SetValue(obj, value2);
					}
					list.Add(obj);
				}
				Array array = Array.CreateInstance(type2, list.Count);
				for (int j = 0; j < list.Count; j++)
				{
					array.SetValue(list[j], j);
				}
				object value3 = ((object)player).GetType().GetField("backpackSlot")?.GetValue(player);
				object value4 = ((object)player).GetType().GetField("tempFullSlot")?.GetValue(player);
				object obj2 = Activator.CreateInstance(type);
				FieldInfo field3 = type.GetField("slots", BindingFlags.Instance | BindingFlags.Public);
				FieldInfo field4 = type.GetField("backpackSlot", BindingFlags.Instance | BindingFlags.Public);
				FieldInfo field5 = type.GetField("tempFullSlot", BindingFlags.Instance | BindingFlags.Public);
				if (field3 != null)
				{
					field3.SetValue(obj2, array);
				}
				if (field4 != null)
				{
					field4.SetValue(obj2, value3);
				}
				if (field5 != null)
				{
					field5.SetValue(obj2, value4);
				}
				MethodInfo methodInfo = typeof(Item).Assembly.GetType("Zorro.Core.Serizalization.IBinarySerializable")?.GetMethod("ToManagedArray")?.MakeGenericMethod(type);
				if (!(methodInfo == null))
				{
					object obj3 = methodInfo.Invoke(null, new object[1] { obj2 });
					c.refs.view.RPC("SyncInventoryRPC", (RpcTarget)0, new object[2] { obj3, false });
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] Inventory sync failed (" + context + "): " + ex.Message));
			}
		}

		private static void TryScheduleDelayedBlowgunReplacement()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			try
			{
				if (!((Object)Instance == (Object)null))
				{
					RequestAkVisualRefresh();
					((MonoBehaviour)Instance).StartCoroutine(DelayedReplaceBlowgunModel());
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] Delayed blowgun replacement failed: " + ex.Message));
			}
		}

		private static void MarkWeaponGrantedForCharacter(Character c)
		{
			int characterGrantTrackingId = GetCharacterGrantTrackingId(c);
			if (characterGrantTrackingId != int.MinValue)
			{
				MarkWeaponGrantedForActor(characterGrantTrackingId);
			}
		}

		private static void MarkWeaponGrantedForActor(int actorNr)
		{
			_receivedItem.Add(actorNr);
			_persistentReceivedItem.Add(actorNr);
			_pendingRemoteWeaponGrantActors.Remove(actorNr);
			_lastWeaponGrantTimeByActor[actorNr] = Time.unscaledTime;
			_weaponMissingSinceByActor.Remove(actorNr);
			_recentWeaponDropTimeByActor.Remove(actorNr);
		}

		internal static void NotifyWeaponDropped(Character c)
		{
			int characterGrantTrackingId = GetCharacterGrantTrackingId(c);
			if (characterGrantTrackingId != int.MinValue)
			{
				if (ShouldSuppressWeaponRegrantAfterDrop(c))
				{
					_recentWeaponDropTimeByActor[characterGrantTrackingId] = Time.unscaledTime;
				}
				else
				{
					_recentWeaponDropTimeByActor.Remove(characterGrantTrackingId);
				}
				_weaponMissingSinceByActor.Remove(characterGrantTrackingId);
				_pendingRemoteWeaponGrantActors.Remove(characterGrantTrackingId);
			}
		}

		private static void MarkFirstAidGrantedForCharacter(Character c)
		{
			int firstAidGrantTrackingId = GetFirstAidGrantTrackingId(c);
			if (firstAidGrantTrackingId != int.MinValue)
			{
				MarkFirstAidGrantedForActor(firstAidGrantTrackingId);
			}
		}

		private static void MarkFirstAidGrantedForActor(int actorNr)
		{
			_receivedFirstAid.Add(actorNr);
			_persistentReceivedFirstAid.Add(actorNr);
			_pendingRemoteFirstAidGrantActors.Remove(actorNr);
			_lastFirstAidGrantTimeByActor[actorNr] = Time.unscaledTime;
		}

		private static bool HasWeaponGrantRecord(int actorNr)
		{
			if (!_receivedItem.Contains(actorNr))
			{
				return _persistentReceivedItem.Contains(actorNr);
			}
			return true;
		}

		private static bool HasRecentWeaponDrop(int actorNr)
		{
			if (!_recentWeaponDropTimeByActor.TryGetValue(actorNr, out var value))
			{
				return false;
			}
			if (Time.unscaledTime - value <= 15f)
			{
				return true;
			}
			_recentWeaponDropTimeByActor.Remove(actorNr);
			return false;
		}

		private static bool ShouldSuppressWeaponRegrantAfterDrop(Character c)
		{
			if ((Object)(object)c == (Object)null)
			{
				return true;
			}
			try
			{
				CharacterData data = c.data;
				if ((Object)(object)data != (Object)null && (data.dead || data.passedOut || data.fullyPassedOut))
				{
					return false;
				}
				return true;
			}
			catch
			{
				return true;
			}
		}

		private static bool HasFirstAidGrantRecord(int actorNr)
		{
			if (!_receivedFirstAid.Contains(actorNr))
			{
				return _persistentReceivedFirstAid.Contains(actorNr);
			}
			return true;
		}

		private static bool IsPendingRemoteWeaponGrant(int actorNr)
		{
			if (!_pendingRemoteWeaponGrantActors.Contains(actorNr))
			{
				return false;
			}
			if (_lastWeaponGrantTimeByActor.TryGetValue(actorNr, out var value) && Time.unscaledTime - value >= 2.5f)
			{
				_pendingRemoteWeaponGrantActors.Remove(actorNr);
				return false;
			}
			return true;
		}

		private static bool IsPendingRemoteFirstAidGrant(int actorNr)
		{
			if (!_pendingRemoteFirstAidGrantActors.Contains(actorNr))
			{
				return false;
			}
			if (_lastFirstAidGrantTimeByActor.TryGetValue(actorNr, out var value) && Time.unscaledTime - value >= 2.5f)
			{
				_pendingRemoteFirstAidGrantActors.Remove(actorNr);
				return false;
			}
			return true;
		}

		private static void ClearWeaponGrantRecordForActor(int actorNr)
		{
			_receivedItem.Remove(actorNr);
			_persistentReceivedItem.Remove(actorNr);
			_pendingRemoteWeaponGrantActors.Remove(actorNr);
			_lastWeaponGrantTimeByActor.Remove(actorNr);
			_weaponMissingSinceByActor.Remove(actorNr);
		}

		private static void RepairMissingWeaponGrantRecord(Character c, int actorNr)
		{
			if (actorNr == int.MinValue || (Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return;
			}
			float value;
			if (!HasWeaponGrantRecord(actorNr) || IsPendingRemoteWeaponGrant(actorNr))
			{
				_weaponMissingSinceByActor.Remove(actorNr);
			}
			else if (HasRecentWeaponDrop(actorNr))
			{
				_weaponMissingSinceByActor.Remove(actorNr);
			}
			else if (CharacterAlreadyHasShootZombiesWeapon(c))
			{
				_weaponMissingSinceByActor.Remove(actorNr);
			}
			else if (!_lastWeaponGrantTimeByActor.TryGetValue(actorNr, out value) || !(Time.unscaledTime - value < 4f))
			{
				if (!_weaponMissingSinceByActor.TryGetValue(actorNr, out var value2))
				{
					_weaponMissingSinceByActor[actorNr] = Time.unscaledTime;
				}
				else if (Time.unscaledTime - value2 >= 1.5f)
				{
					ClearWeaponGrantRecordForActor(actorNr);
				}
			}
		}

		private static bool TryRequestRemoteLoadoutGrant(Character c, int grantType)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (!HasOnlineRoomSession() || !PhotonNetwork.IsMasterClient || (Object)(object)c == (Object)null || c.isBot || c.isZombie || (Object)(object)c.refs?.view == (Object)null || c.refs.view.IsMine || c.refs.view.OwnerActorNr <= 0)
			{
				return false;
			}
			int ownerActorNr = c.refs.view.OwnerActorNr;
			if ((grantType == 1 && IsPendingRemoteWeaponGrant(ownerActorNr)) || (grantType == 2 && IsPendingRemoteFirstAidGrant(ownerActorNr)))
			{
				return true;
			}
			object[] array = new object[1] { grantType };
			RaiseEventOptions val = new RaiseEventOptions();
			val.TargetActors = new int[1] { ownerActorNr };
			RaiseEventOptions val2 = val;
			bool num = PhotonNetwork.RaiseEvent((byte)180, (object)array, val2, SendOptions.SendReliable);
			if (num)
			{
				switch (grantType)
				{
				case 1:
					_pendingRemoteWeaponGrantActors.Add(ownerActorNr);
					_lastWeaponGrantTimeByActor[ownerActorNr] = Time.unscaledTime;
					return num;
				case 2:
					_pendingRemoteFirstAidGrantActors.Add(ownerActorNr);
					_lastFirstAidGrantTimeByActor[ownerActorNr] = Time.unscaledTime;
					break;
				}
			}
			return num;
		}

		private static bool TrySendRemoteLoadoutGrantAck(int grantType)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!HasOnlineRoomSession() || PhotonNetwork.OfflineMode || PhotonNetwork.IsMasterClient || PhotonNetwork.MasterClient == null || PhotonNetwork.MasterClient.ActorNumber <= 0)
			{
				return false;
			}
			object[] array = new object[1] { grantType };
			RaiseEventOptions val = new RaiseEventOptions();
			val.TargetActors = new int[1] { PhotonNetwork.MasterClient.ActorNumber };
			RaiseEventOptions val2 = val;
			return PhotonNetwork.RaiseEvent((byte)182, (object)array, val2, SendOptions.SendReliable);
		}

		private void HandleRemoteLoadoutGrantEvent(object[] payload)
		{
			if (payload == null || payload.Length == 0)
			{
				return;
			}
			object obj = payload[0];
			if (obj is int)
			{
				switch ((int)obj)
				{
				default:
					return;
				case 1:
					_pendingRemoteWeaponGrant = true;
					break;
				case 2:
					_pendingRemoteFirstAidGrant = true;
					break;
				}
				ProcessPendingRemoteGrantRequests(force: true);
			}
		}

		private static void HandleRemoteLoadoutGrantAckEvent(EventData photonEvent)
		{
			if (!PhotonNetwork.IsMasterClient || photonEvent == null || photonEvent.Sender <= 0 || !(photonEvent.CustomData is object[] array) || array.Length == 0)
			{
				return;
			}
			object obj = array[0];
			if (obj is int)
			{
				switch ((int)obj)
				{
				case 1:
					MarkWeaponGrantedForActor(photonEvent.Sender);
					break;
				case 2:
					MarkFirstAidGrantedForActor(photonEvent.Sender);
					break;
				}
			}
		}

		private void HandleRemoteShotEffectsEvent(object[] payload)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_013b: 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)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			if (payload == null || payload.Length < 6)
			{
				return;
			}
			object obj = payload[0];
			if (!(obj is int))
			{
				return;
			}
			int num = (int)obj;
			obj = payload[1];
			if (!(obj is Vector3))
			{
				return;
			}
			Vector3 val = (Vector3)obj;
			obj = payload[2];
			if (!(obj is Vector3))
			{
				return;
			}
			Vector3 direction = (Vector3)obj;
			obj = payload[3];
			if (!(obj is Vector3))
			{
				return;
			}
			Vector3 val2 = (Vector3)obj;
			obj = payload[4];
			if (!(obj is bool))
			{
				return;
			}
			bool flag = (bool)obj;
			obj = payload[5];
			if (!(obj is Vector3))
			{
				return;
			}
			Vector3 endpoint = (Vector3)obj;
			string text2 = ((payload.Length >= 7 && payload[6] is string text) ? text : null);
			Character val3 = ResolveCharacterFromPhotonViewId(num);
			PhotonView val4 = ((!((Object)(object)val3 != (Object)null)) ? null : val3.refs?.view);
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = PhotonView.Find(num);
			}
			if (!((Object)(object)val3 != (Object)null) || !((Object)(object)val3 == (Object)(object)_localCharacter))
			{
				if (string.IsNullOrWhiteSpace(text2) && (Object)(object)val4 != (Object)null && val4.OwnerActorNr > 0)
				{
					text2 = GetAkSoundSelectionForActor(val4.OwnerActorNr);
				}
				if (val2 == Vector3.zero)
				{
					val2 = val;
				}
				if (((Vector3)(ref direction)).sqrMagnitude <= 1E-06f)
				{
					direction = (((Object)(object)val3 != (Object)null && (Object)(object)val3.refs?.view != (Object)null) ? ((Component)val3.refs.view).transform.forward : Vector3.forward);
				}
				CreateMuzzleFlash(val, direction);
				PlayRemoteGunshotSound(val2, text2);
				if (flag)
				{
					SpawnRemoteShotImpactVisual(val3, endpoint);
				}
			}
		}

		private static void SpawnRemoteShotImpactVisual(Character shooter, Vector3 endpoint)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Item visualSourceItemForCharacter = GetVisualSourceItemForCharacter(shooter);
				if ((Object)(object)visualSourceItemForCharacter != (Object)null)
				{
					SpawnDartImpactVisualOnly(visualSourceItemForCharacter, endpoint);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] SpawnRemoteShotImpactVisual failed: " + ex.Message));
			}
		}

		private void ProcessPendingRemoteGrantRequests(bool force = false)
		{
			if ((!_pendingRemoteWeaponGrant && !_pendingRemoteFirstAidGrant) || PhotonNetwork.IsMasterClient || !HasOnlineRoomSession() || (!force && Time.unscaledTime - _lastPendingRemoteGrantAttemptTime < 0.5f))
			{
				return;
			}
			_lastPendingRemoteGrantAttemptTime = Time.unscaledTime;
			Character val = Character.localCharacter ?? _localCharacter;
			if ((Object)(object)val == (Object)null || val.isZombie || val.isBot || !IsLoadoutGrantEligible(val))
			{
				return;
			}
			Player player = val.player;
			if (!((Object)(object)player == (Object)null) && player.itemSlots != null)
			{
				if (_pendingRemoteWeaponGrant && (CharacterAlreadyHasShootZombiesWeapon(val) || TryGiveItemTo(val, ignoreFeatureGate: true)))
				{
					_pendingRemoteWeaponGrant = false;
					TrySendRemoteLoadoutGrantAck(1);
				}
				if (_pendingRemoteFirstAidGrant && (CharacterAlreadyHasFirstAid(val) || TryGiveFirstAidTo(val, ignoreFeatureGate: true)))
				{
					_pendingRemoteFirstAidGrant = false;
					TrySendRemoteLoadoutGrantAck(2);
				}
			}
		}

		private static int GetCharacterGrantTrackingId(Character c)
		{
			if ((Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return int.MinValue;
			}
			PhotonView val = c.refs?.view;
			if ((Object)(object)val != (Object)null && val.OwnerActorNr > 0)
			{
				return val.OwnerActorNr;
			}
			Player player = c.player;
			if (HasOnlineRoomSession())
			{
				if ((Object)(object)c == (Object)(object)Character.localCharacter || (Object)(object)c == (Object)(object)_localCharacter || ((Object)(object)val != (Object)null && val.IsMine))
				{
					Player localPlayer = PhotonNetwork.LocalPlayer;
					if (localPlayer != null && localPlayer.ActorNumber > 0)
					{
						return localPlayer.ActorNumber;
					}
				}
				return int.MinValue;
			}
			if ((Object)(object)player != (Object)null)
			{
				return -Mathf.Abs(((Object)player).GetInstanceID());
			}
			if ((Object)(object)c == (Object)(object)Character.localCharacter || (Object)(object)c == (Object)(object)_localCharacter)
			{
				return -Mathf.Abs(((Object)c).GetInstanceID());
			}
			return int.MinValue;
		}

		private static int GetFirstAidGrantTrackingId(Character c)
		{
			if ((Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return int.MinValue;
			}
			if (HasOnlineRoomSession())
			{
				int characterGrantTrackingId = GetCharacterGrantTrackingId(c);
				if (characterGrantTrackingId != int.MinValue)
				{
					return characterGrantTrackingId;
				}
				if ((Object)(object)c == (Object)(object)Character.localCharacter || (Object)(object)c == (Object)(object)_localCharacter)
				{
					Player localPlayer = PhotonNetwork.LocalPlayer;
					if (localPlayer != null && localPlayer.ActorNumber > 0)
					{
						return localPlayer.ActorNumber;
					}
				}
				return int.MinValue;
			}
			if ((Object)(object)c == (Object)(object)Character.localCharacter || (Object)(object)c == (Object)(object)_localCharacter)
			{
				return -1;
			}
			Player player = c.player;
			if ((Object)(object)player != (Object)null)
			{
				return -Mathf.Abs(((Object)player).GetInstanceID());
			}
			return int.MinValue;
		}

		private static void ApplyWarmBabyEffect(Character c)
		{
			try
			{
				if ((Object)(object)c == (Object)null || c.isZombie || c.isBot)
				{
					return;
				}
				CharacterAfflictions val = c.refs?.afflictions;
				if (!((Object)(object)val != (Object)null))
				{
					return;
				}
				Type type = Type.GetType("Peak.Afflictions.Affliction_AdjustColdOverTime");
				if (type != null)
				{
					object obj = Activator.CreateInstance(type);
					FieldInfo field = type.GetField("statusPerSecond", BindingFlags.Instance | BindingFlags.Public);
					FieldInfo field2 = type.GetField("totalTime", BindingFlags.Instance | BindingFlags.Public);
					FieldInfo field3 = type.GetField("character", BindingFlags.Instance | BindingFlags.Public);
					if (field != null)
					{
						field.SetValue(obj, -10f);
					}
					if (field2 != null)
					{
						field2.SetValue(obj, 10f);
					}
					if (field3 != null)
					{
						field3.SetValue(obj, c);
					}
					MethodInfo method = ((object)val).GetType().GetMethod("AddAffliction", new Type[2]
					{
						type,
						typeof(bool)
					});
					if (method != null)
					{
						method.Invoke(val, new object[2] { obj, false });
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private void Start()
		{
			ZombieBehaviorDifficultyPreset currentZombieBehaviorDifficultyPresetRuntime = GetCurrentZombieBehaviorDifficultyPresetRuntime();
			_cachedIsChineseLanguage = IsChineseLanguage();
			_lastLanguageSetting = _cachedIsChineseLanguage;
			_lastLanguagePollTime = Time.unscaledTime;
			_lastZombieMoveSpeed = GetZombieMoveSpeedMultiplierRuntime();
			_lastZombieKnockbackForce = GetZombieKnockbackForceRuntime();
			_lastZombieSpawnEnabled = IsZombieSpawnFeatureEnabled();
			_lastZombieSpawnInterval = ZombieSpawnInterval.Value;
			_lastZombieSpawnIntervalRandom = GetDerivedZombieSpawnIntervalRandomRangeRuntime();
			_lastZombieSpawnCount = GetDerivedZombieWaveMaxCount();
			_lastZombieSpawnCountRandom = Mathf.Max(GetDerivedZombieWaveMaxCount() - GetDerivedZombieWaveMinCount(), 0);
			_lastZombieSpawnRadius = GetDerivedZombieSpawnRadiusRuntime();
			_lastMaxZombies = MaxZombies.Value;
			_lastZombieMaxLifetime = ZombieMaxLifetime.Value;
			_lastDistanceBeforeWakeup = currentZombieBehaviorDifficultyPresetRuntime.DistanceBeforeWakeup;
			_lastZombieSprintDistance = currentZombieBehaviorDifficultyPresetRuntime.SprintDistance;
			_lastChaseTimeBeforeSprint = currentZombieBehaviorDifficultyPresetRuntime.ChaseTimeBeforeSprint;
			_lastZombieLungeDistance = currentZombieBehaviorDifficultyPresetRuntime.LungeDistance;
			_lastZombieBiteRecoveryTime = currentZombieBehaviorDifficultyPresetRuntime.BiteRecoveryTime;
			_lastZombieLungeTime = currentZombieBehaviorDifficultyPresetRuntime.LungeTime;
			_lastZombieLungeRecoveryTime = currentZombieBehaviorDifficultyPresetRuntime.LungeRecoveryTime;
			_lastZombieLookAngleBeforeWakeup = currentZombieBehaviorDifficultyPresetRuntime.LookAngleBeforeWakeup;
			_lastZombieBehaviorDifficulty = NormalizeZombieBehaviorDifficultySelection(ZombieBehaviorDifficulty.Value);
			_lastModEnabled = ModEnabled?.Value ?? true;
			_lastWeaponEnabled = WeaponEnabled?.Value ?? true;
			EnsureVanillaBlowgunFunctionalityWhenWeaponDisabled();
			_lastWeaponSelection = GetCurrentWeaponSelection();
			ApplySelectedWeaponAssets();
			_lastWeaponModelPitch = GetWeaponModelPitch();
			_lastWeaponModelYaw = GetWeaponModelYaw();
			_lastWeaponModelRoll = GetWeaponModelRoll();
			_lastWeaponModelScale = GetWeaponModelScale();
			_lastWeaponModelOffsetX = GetWeaponModelOffsetX();
			_lastWeaponModelOffsetY = GetWeaponModelOffsetY();
			_lastWeaponModelOffsetZ = GetWeaponModelOffsetZ();
			_pendingZombieSpeedRefresh = true;
			_lastFireInterval = FireInterval.Value;
			_lastFireVolume = FireVolume.Value;
			_lastZombieTimeReduction = ZombieTimeReduction.Value;
			ResetScheduledUpdateState();
			LogNightTestHotkeyHint();
			if (IsModConfigUiRuntimeSafe())
			{
				((MonoBehaviour)this).StartCoroutine(RefreshLocalizedUiAfterStartup());
			}
			_lobbyConfigPanel = new LobbyConfigPanel(this);
		}

		[IteratorStateMachine(typeof(<RefreshLocalizedUiAfterStartup>d__959))]
		private IEnumerator RefreshLocalizedUiAfterStartup()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RefreshLocalizedUiAfterStartup>d__959(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			UpdateMuzzleFlashPool();
			UpdateRemoteGunshotAudioPool();
			UpdateDartImpactVfxPool();
			if (!_resourcesLoaded)
			{
				LoadResources();
			}
			bool cachedChineseLanguageSetting = GetCachedChineseLanguageSetting();
			if (cachedChineseLanguageSetting != _lastLanguageSetting)
			{
				_lastLanguageSetting = cachedChineseLanguageSetting;
				if (IsModConfigUiRuntimeSafe())
				{
					ReinitializeConfig();
				}
				_lobbyConfigPanel?.NotifyLanguageChanged(cachedChineseLanguageSetting);
			}
			RunAlwaysScheduledTasks();
			EnsureVanillaBlowgunFunctionalityWhenWeaponDisabled();
			_lobbyConfigPanel?.Tick();
			if (!IsModFeatureEnabled())
			{
				_hasWeapon = false;
				return;
			}
			if (IsRuntimeVisualRefreshBlocked())
			{
				CleanupLocalWeaponVisual();
				_hasWeapon = false;
				return;
			}
			RunFeatureScheduledTasks();
			Item heldBlowgunItem = GetHeldBlowgunItem();
			CheckSpawnWeaponKey();
			CheckNightTestHotkey();
			_hasWeapon = IsWeaponFeatureEnabled() && (Object)(object)heldBlowgunItem != (Object)null;
			if ((Object)(object)heldBlowgunItem != (Object)null)
			{
				_lastHeldWeaponSeenTime = Time.time;
				if (IsWeaponFeatureEnabled())
				{
					SyncBlowgunChargeState(heldBlowgunItem);
				}
			}
			else
			{
				_lastChargeSyncItemId = int.MinValue;
			}
			if (_pendingAkVisualRefresh)
			{
				try
				{
					ItemPatch.EnsureAkVisualOnAllItems(_pendingAkVisualForceRefresh);
					if (_pendingAkUiRefresh)
					{
						ItemUIDataPatch.ForceRefreshVisibleUi();
					}
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("[ShootZombies] Periodic AK visual refresh failed: " + ex.Message));
				}
				_pendingAkVisualRefresh = false;
				_pendingAkVisualForceRefresh = false;
				_pendingAkUiRefresh = false;
			}
			if (IsWeaponFeatureEnabled() && EnableLocalWeaponVisualFollower)
			{
				EnsureLocalWeaponVisual(heldBlowgunItem);
			}
			else if (IsWeaponFeatureEnabled())
			{
				CleanupLocalWeaponVisual();
			}
			if (IsWeaponFeatureEnabled() && _hasWeapon && (Object)(object)heldBlowgunItem != (Object)null)
			{
				EnsureLocalHeldDebugSphere(heldBlowgunItem);
			}
			else
			{
				CleanupLocalHeldDebugSphere();
			}
			if (IsWeaponFeatureEnabled() && _hasWeapon && (Object)(object)_localCharacter != (Object)null && CanProcessLocalWeaponFireInput(_localCharacter) && Input.GetMouseButton(0) && Time.time - _lastFireTime >= FireInterval.Value)
			{
				TryFire();
			}
		}

		private void ResetScheduledUpdateState()
		{
			float time = Time.time;
			float num = (_nextLobbyNoticeUpdateTime = (_nextConfigCheckTime = (_nextRoomConfigSyncTime = Time.unscaledTime)));
			_nextZombieTimerUpdateTime = time;
			_nextZombieSpeedUpdateCheckTime = time;
			_nextZombieHealthBarRefreshTime = time;
			_nextLocalCharacterRefreshTime = num;
			_nextPendingRemoteGrantProcessTime = num;
			_nextWeaponOwnershipUpdateTime = num;
		}

		private void RunAlwaysScheduledTasks()
		{
			float unscaledTime = Time.unscaledTime;
			if (ShouldRunScheduledTask(ref _nextRoomConfigSyncTime, unscaledTime, 0.1f))
			{
				UpdateRoomConfigSynchronization();
			}
			if (ShouldRunScheduledTask(ref _nextConfigCheckTime, unscaledTime, 0.1f))
			{
				CheckConfigChanges();
			}
			if (ShouldRunScheduledTask(ref _nextLobbyNoticeUpdateTime, unscaledTime, 0.25f))
			{
				UpdateWeaponLobbyNotice();
			}
		}

		private void RunFeatureScheduledTasks()
		{
			float time = Time.time;
			float unscaledTime = Time.unscaledTime;
			if (ShouldRunScheduledTask(ref _nextZombieTimerUpdateTime, time, 0.25f))
			{
				ZombieSpawner.UpdateZombieTimers();
			}
			if (ShouldRunScheduledTask(ref _nextZombieSpeedUpdateCheckTime, time, 0.5f))
			{
				UpdateZombieSpeed();
			}
			if (ShouldRunScheduledTask(ref _nextZombieHealthBarRefreshTime, time, 0.25f))
			{
				ZombieHealthBar.RefreshAll();
			}
			if (ShouldRunScheduledTask(ref _nextLocalCharacterRefreshTime, unscaledTime, 0.1f))
			{
				RefreshLocalCharacterReference();
			}
			if (ShouldRunScheduledTask(ref _nextPendingRemoteGrantProcessTime, unscaledTime, 0.25f))
			{
				ProcessPendingRemoteGrantRequests();
			}
			if (ShouldRunScheduledTask(ref _nextWeaponOwnershipUpdateTime, unscaledTime, 0.25f))
			{
				NormalizeLocalWeaponOwnership();
			}
		}

		private static bool ShouldRunScheduledTask(ref float nextRunTime, float now, float interval)
		{
			if (now < nextRunTime)
			{
				return false;
			}
			nextRunTime = now + interval;
			return true;
		}

		private void UpdateRoomConfigSynchronization()
		{
			if (!HasOnlineRoomSession())
			{
				RestoreLocalRoomConfigBackupIfNeeded();
				ResetRoomConfigSynchronizationState();
				return;
			}
			string text = PhotonNetwork.CurrentRoom.Name ?? string.Empty;
			bool flag = false;
			if (!string.Equals(_activeRoomConfigRoomName, text, StringComparison.Ordinal))
			{
				RestoreLocalRoomConfigBackupIfNeeded();
				ResetRoomConfigSynchronizationState(clearBackup: false);
				_activeRoomConfigRoomName = text;
				flag = true;
			}
			RefreshPlayerWeaponSelectionCache();
			RefreshPlayerAkSoundSelectionCache();
			PublishLocalWeaponSelectionToPlayerProperties(flag || string.IsNullOrEmpty(_lastPublishedLocalWeaponSelection));
			PublishLocalAkSoundSelectionToPlayerProperties(flag || string.IsNullOrEmpty(_lastPublishedLocalAkSoundSelection));
			if (PhotonNetwork.IsMasterClient)
			{
				if (!_wasRoomMasterClient)
				{
					RestoreLocalRoomConfigBackupIfNeeded();
					MarkRoomConfigDirty(forceImmediate: true);
				}
				if ((_roomConfigDirty || string.IsNullOrEmpty(_lastPublishedRoomConfigPayload)) && Time.unscaledTime - _lastRoomConfigPublishTime >= 0.35f)
				{
					PublishHostConfigToRoom(string.IsNullOrEmpty(_lastPublishedRoomConfigPayload));
				}
			}
			else
			{
				CaptureLocalRoomConfigBackupIfNeeded();
				if (flag || string.IsNullOrEmpty(_lastAppliedRoomConfigPayload))
				{
					ApplyHostRoomConfigIfNeeded();
				}
				if (Time.unscaledTime - _lastRoomConfigPollTime >= 1f)
				{
					_lastRoomConfigPollTime = Time.unscaledTime;
					ApplyHostRoomConfigIfNeeded();
				}
			}
			_wasRoomMasterClient = PhotonNetwork.IsMasterClient;
		}

		private void ResetRoomConfigSynchronizationState(bool clearBackup = true)
		{
			_activeRoomConfigRoomName = string.Empty;
			_lastPublishedRoomConfigPayload = string.Empty;
			_lastAppliedRoomConfigPayload = string.Empty;
			_lastPublishedLocalWeaponSelection = string.Empty;
			_lastPublishedLocalAkSoundSelection = string.Empty;
			_lastRoomConfigPublishTime = -10f;
			_lastRoomConfigPollTime = -10f;
			_wasRoomMasterClient = false;
			_roomConfigDirty = true;
			_pendingRemoteWeaponGrant = false;
			_pendingRemoteFirstAidGrant = false;
			_lastPendingRemoteGrantAttemptTime = -10f;
			_playerWeaponSelectionsByActor.Clear();
			_playerAkSoundSelectionsByActor.Clear();
			if (clearBackup)
			{
				_localRoomConfigBackupPayload = string.Empty;
				_hasLocalRoomConfigBackup = false;
			}
		}

		private void MarkRoomConfigDirty(bool forceImmediate = false)
		{
			_roomConfigDirty = true;
			if (forceImmediate)
			{
				_lastRoomConfigPublishTime = -10f;
			}
		}

		private void MarkRoomConfigDirtyIfPublishedPayloadChanged()
		{
			if (!_applyingRoomConfigPayload && HasOnlineRoomSession() && PhotonNetwork.IsMasterClient)
			{
				string text = BuildRoomConfigPayload();
				if (!string.IsNullOrWhiteSpace(text) && !string.Equals(text, _lastPublishedRoomConfigPayload, StringComparison.Ordinal))
				{
					MarkRoomConfigDirty(forceImmediate: true);
				}
			}
		}

		private void CaptureLocalRoomConfigBackupIfNeeded()
		{
			if (!_hasLocalRoomConfigBackup)
			{
				_localRoomConfigBackupPayload = BuildRoomConfigPayload();
				_hasLocalRoomConfigBackup = !string.IsNullOrWhiteSpace(_localRoomConfigBackupPayload);
			}
		}

		private void RestoreLocalRoomConfigBackupIfNeeded()
		{
			if (_hasLocalRoomConfigBackup && !string.IsNullOrWhiteSpace(_localRoomConfigBackupPayload))
			{
				ApplyRoomConfigPayload(_localRoomConfigBackupPayload);
				_localRoomConfigBackupPayload = string.Empty;
				_hasLocalRoomConfigBackup = false;
			}
		}

		private void PublishHostConfigToRoom(bool force = false)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0077: Expected O, but got Unknown
			if (!_applyingRoomConfigPayload && PhotonNetwork.IsMasterClient && PhotonNetwork.CurrentRoom != null)
			{
				string text = BuildRoomConfigPayload();
				if (string.IsNullOrWhiteSpace(text))
				{
					_roomConfigDirty = false;
					_lastRoomConfigPublishTime = Time.unscaledTime;
					return;
				}
				if (!force && string.Equals(text, _lastPublishedRoomConfigPayload, StringComparison.Ordinal))
				{
					_roomConfigDirty = false;
					_lastRoomConfigPublishTime = Time.unscaledTime;
					return;
				}
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)val).Add((object)"ShootZombies.HostConfig", (object)text);
				Hashtable val2 = val;
				PhotonNetwork.CurrentRoom.SetCustomProperties(val2, (Hashtable)null, (WebFlags)null);
				_lastPublishedRoomConfigPayload = text;
				_lastAppliedRoomConfigPayload = text;
				_roomConfigDirty = false;
				_lastRoomConfigPublishTime = Time.unscaledTime;
			}
		}

		private void ApplyHostRoomConfigIfNeeded()
		{
			if (!_applyingRoomConfigPayload && !PhotonNetwork.IsMasterClient && TryGetRoomConfigPayload(out var payload) && (!string.Equals(payload, _lastAppliedRoomConfigPayload, StringComparison.Ordinal) || !IsCurrentRoomConfigPayload(payload)))
			{
				ApplyRoomConfigPayload(payload);
				_lastAppliedRoomConfigPayload = payload;
			}
		}

		private static bool TryGetRoomConfigPayload(out string payload)
		{
			payload = null;
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Hashtable val = ((currentRoom != null) ? ((RoomInfo)currentRoom).CustomProperties : null);
			if (val == null)
			{
				return false;
			}
			if (!((Dictionary<object, object>)(object)val).TryGetValue((object)"ShootZombies.HostConfig", out object value))
			{
				return false;
			}
			payload = value as string;
			return !string.IsNullOrWhiteSpace(payload);
		}

		private bool IsCurrentRoomConfigPayload(string payload)
		{
			if (!string.IsNullOrWhiteSpace(payload))
			{
				return string.Equals(payload, BuildRoomConfigPayload(), StringComparison.Ordinal);
			}
			return false;
		}

		private void HandleRoomPropertiesUpdated(Hashtable propertiesThatChanged)
		{
			if (propertiesThatChanged != null && ((Dictionary<object, object>)(object)propertiesThatChanged).ContainsKey("ShootZombies.HostConfig") && HasOnlineRoomSession() && !PhotonNetwork.IsMasterClient)
			{
				_lastRoomConfigPollTime = Time.unscaledTime;
				ApplyHostRoomConfigIfNeeded();
			}
		}

		private static void RefreshPlayerWeaponSelectionCache()
		{
			if (!PhotonNetwork.InRoom)
			{
				_playerWeaponSelectionsByActor.Clear();
				return;
			}
			Player[] array = PhotonNetwork.PlayerList ?? Array.Empty<Player>();
			foreach (Player val in array)
			{
				if (val != null && val.ActorNumber > 0)
				{
					_playerWeaponSelectionsByActor[val.ActorNumber] = GetWeaponSelectionForPlayer(val);
				}
			}
		}

		private static void RefreshPlayerAkSoundSelectionCache()
		{
			if (!PhotonNetwork.InRoom)
			{
				_playerAkSoundSelectionsByActor.Clear();
				return;
			}
			Player[] array = PhotonNetwork.PlayerList ?? Array.Empty<Player>();
			foreach (Player val in array)
			{
				if (val != null && val.ActorNumber > 0)
				{
					_playerAkSoundSelectionsByActor[val.ActorNumber] = GetAkSoundSelectionForPlayer(val);
				}
			}
		}

		private void PublishLocalWeaponSelectionToPlayerProperties(bool force = false)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			string currentWeaponSelection = GetCurrentWeaponSelection();
			if (PhotonNetwork.LocalPlayer != null && PhotonNetwork.LocalPlayer.ActorNumber > 0)
			{
				_playerWeaponSelectionsByActor[PhotonNetwork.LocalPlayer.ActorNumber] = currentWeaponSelection;
			}
			if (!PhotonNetwork.InRoom || PhotonNetwork.LocalPlayer == null)
			{
				_lastPublishedLocalWeaponSelection = string.Empty;
			}
			else if (PhotonNetwork.OfflineMode)
			{
				_lastPublishedLocalWeaponSelection = currentWeaponSelection;
			}
			else if (force || !string.Equals(currentWeaponSelection, _lastPublishedLocalWeaponSelection, StringComparison.Ordinal))
			{
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)(object)val).Add((object)"sz.weapon", (object)currentWeaponSelection);
				PhotonNetwork.LocalPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
				if (PhotonNetwork.LocalPlayer.ActorNumber > 0)
				{
					_playerWeaponSelectionsByActor[PhotonNetwork.LocalPlayer.ActorNumber] = currentWeaponSelection;
				}
				_lastPublishedLocalWeaponSelection = currentWeaponSelection;
			}
		}

		private void PublishLocalAkSoundSelectionToPlayerProperties(bool force = false)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			string currentAkSoundSelection = GetCurrentAkSoundSelection();
			if (PhotonNetwork.LocalPlayer != null && PhotonNetwork.LocalPlayer.ActorNumber > 0)
			{
				_playerAkSoundSelectionsByActor[PhotonNetwork.LocalPlayer.ActorNumber] = currentAkSoundSelection;
			}
			if (!PhotonNetwork.InRoom || PhotonNetwork.LocalPlayer == null)
			{
				_lastPublishedLocalAkSoundSelection = string.Empty;
			}
			else if (PhotonNetwork.OfflineMode)
			{
				_lastPublishedLocalAkSoundSelection = currentAkSoundSelection;
			}
			else if (force || !string.Equals(currentAkSoundSelection, _lastPublishedLocalAkSoundSelection, StringComparison.Ordinal))
			{
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)(object)val).Add((object)"sz.sound", (object)currentAkSoundSelection);
				PhotonNetwork.LocalPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
				if (PhotonNetwork.LocalPlayer.ActorNumber > 0)
				{
					_playerAkSoundSelectionsByActor[PhotonNetwork.LocalPlayer.ActorNumber] = currentAkSoundSelection;
				}
				_lastPublishedLocalAkSoundSelection = currentAkSoundSelection;
			}
		}

		private void HandlePlayerPropertiesUpdated(Player targetPlayer, Hashtable changedProps)
		{
			if (targetPlayer == null || changedProps == null)
			{
				return;
			}
			bool flag = ((Dictionary<object, object>)(object)changedProps).ContainsKey("sz.weapon");
			bool flag2 = ((Dictionary<object, object>)(object)changedProps).ContainsKey("sz.sound");
			if (!flag && !flag2)
			{
				return;
			}
			if (targetPlayer.ActorNumber > 0)
			{
				if (flag)
				{
					_playerWeaponSelectionsByActor[targetPlayer.ActorNumber] = GetWeaponSelectionForPlayer(targetPlayer);
				}
				if (flag2)
				{
					_playerAkSoundSelectionsByActor[targetPlayer.ActorNumber] = GetAkSoundSelectionForPlayer(targetPlayer);
				}
			}
			if (flag)
			{
				RequestAkVisualRefresh(includeUiRefresh: true, forceRefresh: true);
			}
		}

		private void HandleRoomPlayerListChanged()
		{
			TrimStalePendingRemoteGrantActors();
			RefreshPlayerWeaponSelectionCache();
			RefreshPlayerAkSoundSelectionCache();
			if (PhotonNetwork.IsMasterClient)
			{
				MarkRoomConfigDirty(forceImmediate: true);
			}
			else if (PhotonNetwork.InRoom)
			{
				ApplyHostRoomConfigIfNeeded();
			}
		}

		private void HandleMasterClientChanged()
		{
			_lastRoomConfigPollTime = -10f;
			TrimStalePendingRemoteGrantActors();
			if (PhotonNetwork.IsMasterClient)
			{
				RestoreLocalRoomConfigBackupIfNeeded();
				ZombieSpawner.RebuildLiveZombieRegistryFromScene();
				MarkRoomConfigDirty(forceImmediate: true);
			}
			else
			{
				CaptureLocalRoomConfigBackupIfNeeded();
				ApplyHostRoomConfigIfNeeded();
			}
		}

		private void TrimStalePendingRemoteGrantActors()
		{
			if (!PhotonNetwork.InRoom)
			{
				_pendingRemoteWeaponGrantActors.Clear();
				_pendingRemoteFirstAidGrantActors.Clear();
				return;
			}
			HashSet<int> hashSet = new HashSet<int>(from player in PhotonNetwork.PlayerList
				where player != null && player.ActorNumber > 0
				select player.ActorNumber);
			_pendingRemoteWeaponGrantActors.RemoveWhere((int actorNr) => !hashSet.Contains(actorNr));
			_pendingRemoteFirstAidGrantActors.RemoveWhere((int actorNr) => !hashSet.Contains(actorNr));
			PruneGrantTrackingDictionary(_lastWeaponGrantTimeByActor, hashSet);
			PruneGrantTrackingDictionary(_lastFirstAidGrantTimeByActor, hashSet);
			PruneGrantTrackingDictionary(_weaponMissingSinceByActor, hashSet);
			PruneGrantTrackingDictionary(_recentWeaponDropTimeByActor, hashSet);
		}

		private static void PruneGrantTrackingDictionary(Dictionary<int, float> tracking, HashSet<int> liveActors)
		{
			if (tracking == null || tracking.Count == 0)
			{
				return;
			}
			List<int> list = null;
			foreach (int key in tracking.Keys)
			{
				if (!liveActors.Contains(key))
				{
					(list ?? (list = new List<int>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				tracking.Remove(item);
			}
		}

		private void HandlePhotonEvent(EventData photonEvent)
		{
			if (photonEvent != null && photonEvent.CustomData != null)
			{
				switch (photonEvent.Code)
				{
				case 178:
					HandleZombieHitEvent(photonEvent.CustomData as object[]);
					break;
				case 180:
					HandleRemoteLoadoutGrantEvent(photonEvent.CustomData as object[]);
					break;
				case 182:
					HandleRemoteLoadoutGrantAckEvent(photonEvent);
					break;
				case 181:
					HandleRemoteShotEffectsEvent(photonEvent.CustomData as object[]);
					break;
				case 183:
					HandlePlayerShotStatusEvent(photonEvent.CustomData as object[]);
					break;
				case 184:
					HandleZombieHealthEvent(photonEvent.CustomData as object[]);
					break;
				case 179:
					break;
				}
			}
		}

		private void HandleZombieHitEvent(object[] payload)
		{
			if (HasGameplayAuthority() && TryGetZombieFromEventPayload(payload, out var zombie, out var origin))
			{
				ApplyZombieHitLocal(zombie, origin);
			}
		}

		private static void HandleZombieHealthEvent(object[] payload)
		{
			if (payload == null || payload.Length < 2)
			{
				return;
			}
			object obj = payload[0];
			if (!(obj is int))
			{
				return;
			}
			int viewId = (int)obj;
			float health;
			if (payload[1] is float num)
			{
				health = num;
			}
			else
			{
				obj = payload[1];
				if (!(obj is double))
				{
					return;
				}
				double num2 = (double)obj;
				health = (float)num2;
			}
			Character val = ResolveCharacterFromPhotonViewId(viewId);
			if (!((Object)(object)val == (Object)null) && (val.isZombie || !((Object)(object)((Component)val).GetComponentInParent<MushroomZombie>() == (Object)null) || !((Object)(object)((Component)val).GetComponentInChildren<MushroomZombie>(true) == (Object)null)))
			{
				ZombieHealthBar.SetHealth(val, health);
			}
		}

		private static bool TryGetZombieFromEventPayload(object[] payload, out Character zombie, out Vector3? origin)
		{
			//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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			zombie = null;
			origin = null;
			if (payload == null || payload.Length < 3 || !(payload[0] is int viewId) || !(payload[1] is bool flag))
			{
				return false;
			}
			zombie = ResolveCharacterFromPhotonViewId(viewId);
			if ((Object)(object)zombie == (Object)null || (!zombie.isZombie && !zombie.isBot))
			{
				zombie = null;
				return false;
			}
			if (flag && payload[2] is Vector3 value && IsFiniteVector(value))
			{
				origin = value;
			}
			return true;
		}

		private void HandlePlayerShotStatusEvent(object[] payload)
		{
			if (TryGetPlayerCharacterFromEventPayload(payload, out var playerCharacter))
			{
				ApplyPlayerShotStatusIfOwnedLocal(playerCharacter);
			}
		}

		private static bool TryGetPlayerCharacterFromEventPayload(object[] payload, out Character playerCharacter)
		{
			playerCharacter = null;
			if (payload == null || payload.Length < 1 || !(payload[0] is int viewId))
			{
				return false;
			}
			playerCharacter = ResolveCharacterFromPhotonViewId(viewId);
			if ((Object)(object)playerCharacter == (Object)null || playerCharacter.isZombie || playerCharacter.isBot)
			{
				playerCharacter = null;
				return false;
			}
			return true;
		}

		private static Character ResolveCharacterFromPhotonViewId(int viewId)
		{
			if (viewId <= 0)
			{
				return null;
			}
			PhotonView val = PhotonView.Find(viewId);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return ((Component)val).GetComponent<Character>() ?? ((Component)val).GetComponentInParent<Character>() ?? ((Component)val).GetComponentInChildren<Character>(true);
		}

		private static string BuildRoomConfigPayload()
		{
			StringBuilder stringBuilder = new StringBuilder(512);
			AppendRoomConfigValue(stringBuilder, "Version", 2);
			AppendRoomConfigValue(stringBuilder, "ModEnabled", ModEnabled?.Value ?? true);
			AppendRoomConfigValue(stringBuilder, "WeaponEnabled", WeaponEnabled?.Value ?? true);
			AppendRoomConfigValue(stringBuilder, "FireInterval", FireInterval?.Value ?? 0.4f);
			AppendRoomConfigValue(stringBuilder, "ZombieTimeReduction", ZombieTimeReduction?.Value ?? 25f);
			AppendRoomConfigValue(stringBuilder, "ZombieSpawnInterval", ZombieSpawnInterval?.Value ?? 15f);
			AppendRoomConfigValue(stringBuilder, "MaxZombies", MaxZombies?.Value ?? 2);
			AppendRoomConfigValue(stringBuilder, "ZombieSpawnCount", ZombieSpawnCount?.Value ?? 1);
			AppendRoomConfigValue(stringBuilder, "ZombieMaxLifetime", ZombieMaxLifetime?.Value ?? 120f);
			AppendRoomConfigValue(stringBuilder, "ZombieBehaviorDifficulty", ZombieBehaviorDifficulty?.Value ?? "Easy");
			AppendRoomConfigValue(stringBuilder, "ZombieKnockbackForce", GetZombieKnockbackForceRuntime());
			return stringBuilder.ToString();
		}

		private static void AppendRoomConfigValue(StringBuilder builder, string key, bool value)
		{
			AppendRoomConfigValue(builder, key, value ? "1" : "0");
		}

		private static void AppendRoomConfigValue(StringBuilder builder, string key, int value)
		{
			AppendRoomConfigValue(builder, key, value.ToString(CultureInfo.InvariantCulture));
		}

		private static void AppendRoomConfigValue(StringBuilder builder, string key, float value)
		{
			AppendRoomConfigValue(builder, key, value.ToString("R", CultureInfo.InvariantCulture));
		}

		private static void AppendRoomConfigValue(StringBuilder builder, string key, string value)
		{
			if (builder.Length > 0)
			{
				builder.Append('|');
			}
			builder.Append(key).Append('=').Append(Uri.EscapeDataString(value ?? string.Empty));
		}

		private void ApplyRoomConfigPayload(string payload)
		{
			if (string.IsNullOrWhiteSpace(payload))
			{
				return;
			}
			Dictionary<string, string> dictionary = ParseRoomConfigPayload(payload);
			if (dictionary.Count == 0)
			{
				return;
			}
			_applyingRoomConfigPayload = true;
			try
			{
				ApplyBoolRoomConfig(dictionary, "ModEnabled", ModEnabled);
				ApplyBoolRoomConfig(dictionary, "WeaponEnabled", WeaponEnabled);
				ApplyFloatRoomConfig(dictionary, "FireInterval", FireInterval);
				ApplyFloatRoomConfig(dictionary, "ZombieTimeReduction", ZombieTimeReduction);
				ApplyFloatRoomConfig(dictionary, "ZombieSpawnInterval", ZombieSpawnInterval);
				ApplyIntRoomConfig(dictionary, "MaxZombies", MaxZombies);
				ApplyIntRoomConfig(dictionary, "ZombieSpawnCount", ZombieSpawnCount);
				ApplyFloatRoomConfig(dictionary, "ZombieMaxLifetime", ZombieMaxLifetime);
				ApplyStringRoomConfig(dictionary, "ZombieBehaviorDifficulty", ZombieBehaviorDifficulty, NormalizeZombieBehaviorDifficultySelection);
				ApplyFloatRoomConfig(dictionary, "ZombieKnockbackForce", ZombieKnockbackForce);
				ApplyZombieBehaviorDifficultyPreset();
				ApplySimplifiedZombieDerivedValues();
				if (ZombieBehaviorDifficulty != null)
				{
					_lastZombieBehaviorDifficulty = NormalizeZombieBehaviorDifficultySelection(ZombieBehaviorDifficulty.Value);
				}
				NormalizeConfigRanges();
			}
			finally
			{
				_applyingRoomConfigPayload = false;
			}
		}

		public static bool IsModFeatureEnabled()
		{
			if (ModEnabled != null)
			{
				return ModEnabled.Value;
			}
			return true;
		}

		internal static bool HasOnlineRoomSession()
		{
			if (!PhotonNetwork.InRoom || PhotonNetwork.OfflineMode)
			{
				return false;
			}
			return PhotonNetwork.CurrentRoom != null;
		}

		internal static bool HasGameplayAuthority()
		{
			if (PhotonNetwork.OfflineMode)
			{
				return true;
			}
			if (!PhotonNetwork.InRoom || PhotonNetwork.CurrentRoom == null)
			{
				return true;
			}
			return PhotonNetwork.IsMasterClient;
		}

		private static bool ShouldRelayZombieHitToHost()
		{
			if (HasOnlineRoomSession())
			{
				return !PhotonNetwork.IsMasterClient;
			}
			return false;
		}

		public static bool IsWeaponFeatureEnabled()
		{
			if (IsModFeatureEnabled())
			{
				if (WeaponEnabled != null)
				{
					return WeaponEnabled.Value;
				}
				return true;
			}
			return false;
		}

		private static bool IsZombieSpawnFeatureEnabled()
		{
			if (IsModFeatureEnabled())
			{
				return Mathf.Max((MaxZombies != null) ? MaxZombies.Value : 0, 0) > 0;
			}
			return false;
		}

		internal static bool IsZombieSpawnFeatureEnabledRuntime()
		{
			return IsZombieSpawnFeatureEnabled();
		}

		private static bool IsFogModeEnabled()
		{
			return false;
		}

		public static void ClearLocalAmbientColdStatus()
		{
		}

		private void RemoveLegacyRecoilConfig()
		{
			try
			{
				ConfigFile config = ((BaseUnityPlugin)this).Config;
				IDictionary dictionary = ((config != null) ? (((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(config) as IDictionary) : null);
				string[] array = new string[5] { "Recoil", "Enable Recoil", "Recoil Pitch", "Recoil Yaw", "Recoil Max Angle" };
				foreach (string key in array)
				{
					foreach (ConfigDefinition item in BuildConfigDefinitionAliases("Weapon", key))
					{
						if (config != null)
						{
							config.Remove(item);
						}
						dictionary?.Remove(item);
					}
					foreach (ConfigDefinition item2 in BuildConfigDefinitionAliases("Features", key))
					{
						if (config != null)
						{
							config.Remove(item2);
						}
						dictionary?.Remove(item2);
					}
				}
				if (config != null)
				{
					config.Save();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] RemoveLegacyRecoilConfig failed: " + DescribeReflectionException(ex)));
			}
		}

		private bool ShouldShowWeaponLobbyNotice()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (IsLobbyScene(activeScene) && IsWeaponFeatureEnabled())
			{
				return !IsTitleScene(activeScene);
			}
			return false;
		}

		private void CheckSpawnWeaponKey()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (IsWeaponFeatureEnabled() && SpawnWeaponKey != null && (int)SpawnWeaponKey.Value != 0 && Input.GetKeyDown(SpawnWeaponKey.Value))
			{
				SpawnWeaponAtPlayer();
			}
		}

		private static void SetLayerRecursively(Transform root, int layer)
		{
			if (!((Object)(object)root == (Object)null))
			{
				((Component)root).gameObject.layer = layer;
				for (int i = 0; i < root.childCount; i++)
				{
					SetLayerRecursively(root.GetChild(i), layer);
				}
			}
		}

		private void LogLocalHeldDebugSphereState(string phase, Item sourceItem, Transform viewAnchor, int resolvedLayer)
		{
			//IL_00c7: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_localHeldDebugSphereRoot == (Object)null))
			{
				Camera val = ResolveCameraForAnchor(viewAnchor);
				int num = (((Object)(object)sourceItem != (Object)null) ? ((Object)sourceItem).GetInstanceID() : 0);
				string key = "local-held-debug-sphere:" + phase + ":" + num + ":" + ((Object)_localHeldDebugSphereRoot).GetInstanceID();
				object[] obj = new object[11]
				{
					phase,
					FormatHeldItemForDiagnostics(sourceItem),
					FormatTransformPath(viewAnchor),
					((Object)(object)val != (Object)null) ? ((Object)val).name : "null",
					resolvedLayer,
					FormatTransformPath(_localHeldDebugSphereRoot),
					_localHeldDebugSphereRoot.localPosition,
					null,
					null,
					null,
					null
				};
				Quaternion localRotation = _localHeldDebugSphereRoot.localRotation;
				obj[7] = ((Quaternion)(ref localRotation)).eulerAngles;
				obj[8] = _localHeldDebugSphereRoot.localScale;
				obj[9] = DescribeLocalBoundsForDiagnostics(_localHeldDebugSphereRoot);
				obj[10] = DescribeLocalRendererCollectionForDiagnostics(_localHeldDebugSphereRoot);
				LogDiagnosticOnce(key, string.Format("Local held debug sphere: phase={0}, item={1}, view={2}, camera={3}, resolvedLayer={4}, rootPath={5}, localPos={6}, localRot={7}, localScale={8}, bounds={9}, renderers={10}", obj));
			}
		}

		private static int GetPreferredWeaponSlot(Player player)
		{
			if ((Object)(object)player == (Object)null || player.itemSlots == null || player.itemSlots.Length == 0)
			{
				return -1;
			}
			if (player.itemSlots[0].IsEmpty())
			{
				return 0;
			}
			for (int i = 1; i < player.itemSlots.Length; i++)
			{
				if (player.itemSlots[i].IsEmpty())
				{
					return i;
				}
			}
			return -1;
		}

		private static Dictionary<string, string> ParseRoomConfigPayload(string payload)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			if (string.IsNullOrWhiteSpace(payload))
			{
				return dictionary;
			}
			string[] array = payload.Split(new char[1] { '|' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0 && num < text.Length - 1)
				{
					string key = text.Substring(0, num);
					string value = Uri.UnescapeDataString(text.Substring(num + 1));
					dictionary[key] = value;
				}
			}
			return dictionary;
		}

		private void InitializeRoomConfigCallbacks()
		{
			if (!_roomConfigCallbacksRegistered)
			{
				if (_roomConfigCallbackProxy == null)
				{
					_roomConfigCallbackProxy = new RoomConfigCallbackProxy();
				}
				PhotonNetwork.AddCallbackTarget((object)_roomConfigCallbackProxy);
				_roomConfigCallbacksRegistered = true;
			}
		}

		private void ReleaseRoomConfigCallbacks()
		{
			if (_roomConfigCallbacksRegistered && _roomConfigCallbackProxy != null)
			{
				PhotonNetwork.RemoveCallbackTarget((object)_roomConfigCallbackProxy);
				_roomConfigCallbacksRegistered = false;
			}
		}

		private void SubscribeOwnedConfigEntryChanges()
		{
			try
			{
				ConfigEntryBase[] configEntriesSnapshot = GetConfigEntriesSnapshot(((BaseUnityPlugin)this).Config);
				foreach (ConfigEntryBase val in configEntriesSnapshot)
				{
					if (val == null || _observedConfigEntries.ContainsKey(val))
					{
						continue;
					}
					EventInfo @event = ((object)val).GetType().GetEvent("SettingChanged", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (!(@event == null))
					{
						MethodInfo method = ((object)this).GetType().GetMethod("OnOwnedConfigEntryChanged", BindingFlags.Instance | BindingFlags.NonPublic);
						Delegate @delegate = ((method != null) ? Delegate.CreateDelegate(@event.EventHandlerType, this, method, throwOnBindFailure: false) : null);
						if ((object)@delegate != null)
						{
							@event.AddEventHandler(val, @delegate);
							_observedConfigEntries[val] = @delegate;
						}
					}
				}
			}
			catch
			{
			}
		}

		private void UnsubscribeOwnedConfigEntryChanges()
		{
			foreach (KeyValuePair<ConfigEntryBase, Delegate> observedConfigEntry in _observedConfigEntries)
			{
				if (observedConfigEntry.Key != null && (object)observedConfigEntry.Value != null)
				{
					((object)observedConfigEntry.Key).GetType().GetEvent("SettingChanged", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.RemoveEventHandler(observedConfigEntry.Key, observedConfigEntry.Value);
				}
			}
			_observedConfigEntries.Clear();
		}

		private void OnOwnedConfigEntryChanged(object sender, EventArgs args)
		{
			if (!_applyingRoomConfigPayload && HasOnlineRoomSession() && PhotonNetwork.IsMasterClient)
			{
				MarkRoomConfigDirty(forceImmediate: true);
			}
		}

		private static void ApplyBoolRoomConfig(IReadOnlyDictionary<string, string> values, string key, ConfigEntry<bool> entry)
		{
			if (entry != null && values.TryGetValue(key, out var value))
			{
				bool result;
				if (string.Equals(value, "1", StringComparison.Ordinal))
				{
					entry.Value = true;
				}
				else if (string.Equals(value, "0", StringComparison.Ordinal))
				{
					entry.Value = false;
				}
				else if (bool.TryParse(value, out result))
				{
					entry.Value = result;
				}
			}
		}

		private static void ApplyIntRoomConfig(IReadOnlyDictionary<string, string> values, string key, ConfigEntry<int> entry)
		{
			if (entry != null && values.TryGetValue(key, out var value) && int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				entry.Value = result;
			}
		}

		private static void ApplyFloatRoomConfig(IReadOnlyDictionary<string, string> values, string key, ConfigEntry<float> entry)
		{
			if (entry != null && values.TryGetValue(key, out var value) && float.TryParse(value, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out var result))
			{
				entry.Value = result;
			}
		}

		private static void ApplyStringRoomConfig(IReadOnlyDictionary<string, string> values, string key, ConfigEntry<string> entry, Func<string, string> normalizer = null)
		{
			if (entry != null && values.TryGetValue(key, out var value))
			{
				entry.Value = ((normalizer != null) ? normalizer(value) : value);
			}
		}

		private bool IsGameplayScene()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsGameplayScene(SceneManager.GetActiveScene());
		}

		private static string FormatHeldItemForDiagnostics(Item sourceItem)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected I4, but got Unknown
			if ((Object)(object)sourceItem == (Object)null)
			{
				return "null";
			}
			string text = (((Object)(object)sourceItem.holderCharacter != (Object)null) ? ((Object)sourceItem.holderCharacter).name : null) ?? (((Object)(object)sourceItem.trueHolderCharacter != (Object)null) ? ((Object)sourceItem.trueHolderCharacter).name : null) ?? "null";
			return $"name={((Object)sourceItem).name},id={sourceItem.itemID},state={(int)sourceItem.itemState},holder={text}";
		}

		private bool TryLoadLightweightAkResources()
		{
			try
			{
				if (!AkLightweightAssetLoader.TryLoad(out var prefab, out var diagnostic))
				{
					LogDiagnosticOnce("ak-lightweight-unavailable", "Lightweight AK resources unavailable: " + diagnostic);
					return false;
				}
				ResetAkBundleSelectionState();
				_ak47Prefab = prefab;
				_ak47Bundle = null;
				_ak47VFX = null;
				_ak47ItemContent = null;
				_ak47IconTexture = null;
				if (AkLightweightAssetLoader.TryLoadIconTexture(out var texture, out var diagnostic2))
				{
					_ak47IconTexture = texture;
					LogDiagnosticOnce("ak-lightweight-icon-loaded", "Loaded lightweight AK icon: " + diagnostic2);
				}
				CaptureGenericResolvedWeaponAssets();
				ApplySelectedWeaponAssets();
				if (!HasAkVisualPrefab())
				{
					LogDiagnosticOnce("ak-lightweight-invalid", "Lightweight AK load produced no renderable prefab: " + DescribeAkVisualPrefabForDiagnostics());
					ResetAkBundleSelectionState();
					return false;
				}
				LogDiagnosticOnce("ak-lightweight-loaded", "Loaded lightweight AK resources: " + diagnostic + ", prefab=" + DescribeAkVisualPrefabForDiagnostics());
				ReplaceBlowgunSound();
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] Lightweight AK load failed, falling back to bundle: " + ex.Message));
				ResetAkBundleSelectionState();
				return false;
			}
		}

		private void LoadBundleInternal()
		{
			try
			{
				List<string> list = FindBundleCandidatePaths().Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList();
				if (list.Count == 0)
				{
					Log.LogWarning((object)"[ShootZombies] No bundle files found");
					return;
				}
				foreach (string item in list)
				{
					ResetAkBundleSelectionState();
					AssetBundle val = AssetBundle.LoadFromFile(item);
					if ((Object)(object)val == (Object)null)
					{
						Log.LogWarning((object)("[ShootZombies] Failed to load bundle from path: " + item));
						continue;
					}
					OnBundleLoaded(val);
					if (HasAkVisualPrefab())
					{
						LogDiagnosticOnce("ak-bundle-accepted:" + item, "Accepted AK bundle path: " + item);
						return;
					}
					LogDiagnosticOnce("ak-bundle-rejected:" + item, "Rejected AK bundle path because no renderable AK prefab was resolved: " + item + ", prefab=" + DescribeAkVisualPrefabForDiagnostics());
					Log.LogWarning((object)("[ShootZombies] Bundle loaded but no model found, trying next candidate: " + item));
					val.Unload(false);
					if ((Object)(object)_ak47Bundle == (Object)(object)val)
					{
						_ak47Bundle = null;
					}
					ResetAkBundleSelectionState();
				}
				ResetAkBundleSelectionState();
				Log.LogWarning((object)"[ShootZombies] No usable AK bundle found after scanning all candidate paths");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[ShootZombies] LoadBundleInternal error: " + ex));
			}
		}

		[IteratorStateMachine(typeof(<FindBundleCandidatePaths>d__1027))]
		private static IEnumerable<string> FindBundleCandidatePaths()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindBundleCandidatePaths>d__1027(-2);
		}

		[IteratorStateMachine(typeof(<GetBundleSearchRoots>d__1028))]
		private static IEnumerable<string> GetBundleSearchRoots()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetBundleSearchRoots>d__1028(-2);
		}

		private void OnBundleLoaded(AssetBundle bundle)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			if ((Object)(object)bundle == (Object)null)
			{
				Log.LogError((object)"[ShootZombies] AssetBundle is null");
				return;
			}
			try
			{
				_ak47Bundle = bundle;
				_ak47VFX = null;
				TryResolvePreferredAkAssets(bundle);
				TryResolveKnownAkItemContent(bundle);
				Object[] array = bundle.LoadAllAssets();
				foreach (Object val in array)
				{
					Type type = ((object)val).GetType();
					if (type.Name.Contains("ItemContent") || type.Name.Contains("IC_AK"))
					{
						_ak47ItemContent = val;
						LogItemContentReflectionDiagnosis(_ak47ItemContent);
						FieldInfo field = type.GetField("ItemPrefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						PropertyInfo property = type.GetProperty("ItemPrefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (property != null)
						{
							object value = property.GetValue(val);
							_ak47Prefab = (GameObject)((value is GameObject) ? value : null);
						}
						else if (field != null)
						{
							object value2 = field.GetValue(val);
							_ak47Prefab = (GameObject)((value2 is GameObject) ? value2 : null);
						}
						if ((Object)(object)_ak47IconTexture == (Object)null)
						{
							Texture2D val2 = TryExtractIconFromItemContent(_ak47ItemContent);
							if ((Object)(object)val2 != (Object)null)
							{
								_ak47IconTexture = val2;
							}
						}
					}
					GameObject val3 = (GameObject)((val is GameObject) ? val : null);
					if ((Object)val3 != (Object)null && IsLikelyAkVisualPrefab(val3))
					{
						_ak47VFX = val3;
					}
					if ((Object)val3 != (Object)null && (Object)(object)_ak47Prefab == (Object)null)
					{
						MeshRenderer[] componentsInChildren = val3.GetComponentsInChildren<MeshRenderer>(true);
						SkinnedMeshRenderer[] componentsInChildren2 = val3.GetComponentsInChildren<SkinnedMeshRenderer>(true);
						MeshFilter[] componentsInChildren3 = val3.GetComponentsInChildren<MeshFilter>(true);
						if (componentsInChildren.Length != 0 || componentsInChildren2.Length != 0 || componentsInChildren3.Length != 0)
						{
							_ak47Prefab = val3;
						}
					}
					Texture2D val4 = (Texture2D)((val is Texture2D) ? val : null);
					if ((Object)val4 != (Object)null && (Object)(object)_ak47IconTexture == (Object)null && IsLikelyIconTexture(val4))
					{
						_ak47IconTexture = val4;
					}
				}
				TryResolveItemContentFromNamedAssets(bundle);
				if ((Object)(object)_ak47Prefab == (Object)null)
				{
					GameObject[] array2 = bundle.LoadAllAssets<GameObject>();
					GameObject[] array3 = array2;
					foreach (GameObject val5 in array3)
					{
						MeshRenderer[] componentsInChildren4 = val5.GetComponentsInChildren<MeshRenderer>(true);
						SkinnedMeshRenderer[] componentsInChildren5 = val5.GetComponentsInChildren<SkinnedMeshRenderer>(true);
						MeshFilter[] componentsInChildren6 = val5.GetComponentsInChildren<MeshFilter>(true);
						if (componentsInChildren4.Length != 0 || componentsInChildren5.Length != 0 || componentsInChildren6.Length != 0)
						{
							_ak47Prefab = val5;
						}
					}
					if ((Object)(object)_ak47Prefab == (Object)null && array2.Length != 0)
					{
						_ak47Prefab = array2[0];
					}
				}
				if (!HasRenderableGeometry(_ak47Prefab))
				{
					GameObject val6 = TryLoadRenderablePrefabFromNamedAssets(bundle);
					if ((Object)(object)val6 != (Object)null)
					{
						_ak47Prefab = val6;
					}
				}
				if (!HasRenderableGeometry(_ak47Prefab))
				{
					Mesh[] meshes = bundle.LoadAllAssets<Mesh>();
					Material[] materials = bundle.LoadAllAssets<Material>();
					Texture2D[] textures = bundle.LoadAllAssets<Texture2D>();
					GameObject val7 = TryCreateSyntheticAkPrefabFromBundle(meshes, materials, textures);
					if ((Object)(object)val7 != (Object)null)
					{
						_ak47Prefab = val7;
					}
				}
				if (!HasRenderableGeometry(_ak47Prefab))
				{
					GameObject val8 = TryCreateSyntheticAkPrefabFromNamedAssets(bundle);
					if ((Object)(object)val8 != (Object)null)
					{
						_ak47Prefab = val8;
					}
				}
				if ((Object)(object)_ak47Prefab == (Object)null)
				{
					Log.LogWarning((object)"[ShootZombies] No model found in bundle, creating fallback cube model");
					_ak47Prefab = CreateFallbackModel();
				}
				if ((Object)(object)_ak47VFX == (Object)null)
				{
					GameObject val9 = bundle.LoadAsset<GameObject>("VFX_AK");
					if ((Object)(object)val9 != (Object)null)
					{
						_ak47VFX = val9;
					}
				}
				Texture2D[] array4 = bundle.LoadAllAssets<Texture2D>();
				if (array4 != null && array4.Length != 0 && (Object)(object)_ak47IconTexture == (Object)null)
				{
					Texture2D[] array5 = array4;
					foreach (Texture2D val10 in array5)
					{
						if (IsLikelyIconTexture(val10))
						{
							_ak47IconTexture = val10;
							break;
						}
					}
				}
				if ((Object)(object)_ak47IconTexture == (Object)null && _ak47ItemContent != null)
				{
					Texture2D val11 = TryExtractIconFromItemContent(_ak47ItemContent);
					if ((Object)(object)val11 != (Object)null)
					{
						_ak47IconTexture = val11;
					}
				}
				CaptureGenericResolvedWeaponAssets();
				TryResolveSelectableWeaponAssets(bundle);
				ApplySelectedWeaponAssets();
				LogBundleSelectionDiagnosis(bundle);
				ReplaceBlowgunSound();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[ShootZombies] OnBundleLoaded error: " + ex));
			}
		}

		private static void ResetAkBundleSelectionState()
		{
			for (int num = _runtimeWeaponPrefabClones.Count - 1; num >= 0; num--)
			{
				GameObject val = _runtimeWeaponPrefabClones[num];
				if (!((Object)(object)val == (Object)null))
				{
					try
					{
						Object.DestroyImmediate((Object)(object)val);
					}
					catch
					{
					}
				}
			}
			_runtimeWeaponPrefabClones.Clear();
			_resolvedWeaponPrefabs.Clear();
			_resolvedWeaponIcons.Clear();
			_ak47Bundle = null;
			_ak47Prefab = null;
			_ak47VFX = null;
			_ak47ItemContent = null;
			_ak47IconTexture = null;
			_genericResolvedWeaponPrefab = null;
			_genericResolvedWeaponIcon = null;
			_useExplicitSelectedWeaponIcon = false;
		}

		private void TryResolveItemContentFromNamedAssets(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null || _ak47ItemContent != null)
			{
				return;
			}
			TryResolveKnownAkItemContent(bundle);
			if (_ak47ItemContent != null)
			{
				return;
			}
			string[] array = bundle.GetAllAssetNames() ?? Array.Empty<string>();
			foreach (string text in array)
			{
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				Object val = null;
				try
				{
					val = bundle.LoadAsset(text);
				}
				catch (Exception ex)
				{
					LogDiagnosticOnce("ak-itemcontent-load-error:" + text, "Named asset load failed: asset=" + text + ", error=" + ex.GetType().Name);
				}
				if (val == (Object)null)
				{
					if (text.IndexOf("ic_ak", StringComparison.OrdinalIgnoreCase) < 0)
					{
						continue;
					}
					LogDiagnosticOnce("ak-itemcontent-null:" + text, "Named asset load returned null: asset=" + text);
					Object[] array2 = null;
					try
					{
						array2 = bundle.LoadAssetWithSubAssets(text);
					}
					catch (Exception ex2)
					{
						LogDiagnosticOnce("ak-itemcontent-subasset-error:" + text, "LoadAssetWithSubAssets failed: asset=" + text + ", error=" + ex2.GetType().Name);
					}
					if (array2 == null || array2.Length == 0)
					{
						LogDiagnosticOnce("ak-itemcontent-subasset-empty:" + text, "LoadAssetWithSubAssets returned no sub-assets: asset=" + text);
						continue;
					}
					string text2 = string.Join(" || ", (from item in array2
						where item != (Object)null
						select ((object)item).GetType().FullName + ":" + item.name).Take(24));
					LogDiagnosticOnce("ak-itemcontent-subasset-list:" + text, "LoadAssetWithSubAssets returned: asset=" + text + ", items=" + text2);
					Object[] array3 = array2;
					foreach (Object val2 in array3)
					{
						if (val2 == (Object)null)
						{
							continue;
						}
						Type type = ((object)val2).GetType();
						if (type.Name.Contains("ItemContent") || type.Name.Contains("IC_AK"))
						{
							_ak47ItemContent = val2;
							LogItemContentReflectionDiagnosis(_ak47ItemContent);
							TryAssignAkPrefabFromItemContent(_ak47ItemContent);
							if ((Object)(object)_ak47IconTexture == (Object)null)
							{
								_ak47IconTexture = TryExtractIconFromItemContent(_ak47ItemContent);
							}
							LogDiagnosticOnce("ak-itemcontent-resolved-subasset", "Resolved IC_AK from sub-asset: " + text + ", type=" + type.FullName + ", name=" + val2.name);
							break;
						}
					}
					if (_ak47ItemContent != null)
					{
						break;
					}
					continue;
				}
				Type type2 = ((object)val).GetType();
				LogDiagnosticOnce("ak-itemcontent-load:" + text, "Named asset load: asset=" + text + ", type=" + type2.FullName + ", name=" + val.name);
				if (type2.Name.Contains("ItemContent") || type2.Name.Contains("IC_AK"))
				{
					_ak47ItemContent = val;
					LogItemContentReflectionDiagnosis(_ak47ItemContent);
					TryAssignAkPrefabFromItemContent(_ak47ItemContent);
					if ((Object)(object)_ak47IconTexture == (Object)null)
					{
						_ak47IconTexture = TryExtractIconFromItemContent(_ak47ItemContent);
					}
					LogDiagnosticOnce("ak-itemcontent-resolved", "Resolved IC_AK from named asset: " + text);
					break;
				}
			}
		}

		private void TryAssignAkPrefabFromItemContent(object itemContent)
		{
			if (itemContent == null || (Object)(object)_ak47Prefab != (Object)null)
			{
				return;
			}
			try
			{
				Type type = itemContent.GetType();
				PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0)
					{
						object value = null;
						try
						{
							value = propertyInfo.GetValue(itemContent, null);
						}
						catch
						{
						}
						if (TryAssignAkPrefabFromValue(value, "prop " + propertyInfo.Name))
						{
							return;
						}
					}
				}
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					object value2 = null;
					try
					{
						value2 = fieldInfo.GetValue(itemContent);
					}
					catch
					{
					}
					if (TryAssignAkPrefabFromValue(value2, "field " + fieldInfo.Name))
					{
						break;
					}
				}
			}
			catch (Exception ex)
			{
				LogDiagnosticOnce("ak-itemcontent-prefab-error", "TryAssignAkPrefabFromItemContent failed: " + ex.GetType().Name + ": " + ex.Message);
			}
		}

		private bool TryAssignAkPrefabFromValue(object value, string source)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val != (Object)null && HasRenderableGeometry(val))
			{
				_ak47Prefab = val;
				LogDiagnosticOnce("ak-itemcontent-prefab:" + source, "Resolved AK prefab from IC_AK " + source + ": " + DescribeGameObjectForDiagnostics(val));
				return true;
			}
			Item val2 = (Item)((value is Item) ? value : null);
			if ((Object)(object)val2 != (Object)null && HasRenderableGeometry(((Component)val2).gameObject))
			{
				_ak47Prefab = ((Component)val2).gameObject;
				LogDiagnosticOnce("ak-itemcontent-item:" + source, "Resolved AK item/prefab from IC_AK " + source + ": " + DescribeGameObjectForDiagnostics(_ak47Prefab));
				return true;
			}
			Component val3 = (Component)((value is Component) ? value : null);
			if ((Object)(object)val3 != (Object)null && HasRenderableGeometry(val3.gameObject))
			{
				_ak47Prefab = val3.gameObject;
				LogDiagnosticOnce("ak-itemcontent-component:" + source, "Resolved AK component/prefab from IC_AK " + source + ": " + DescribeGameObjectForDiagnostics(_ak47Prefab));
				return true;
			}
			return false;
		}

		private void LogBundleSelectionDiagnosis(AssetBundle bundle)
		{
			string text = _ak47ItemContent?.GetType().FullName ?? "null";
			string text2 = (((Object)(object)_ak47VFX != (Object)null) ? ((Object)_ak47VFX).name : "null");
			string text3 = DescribeBundleAssetSummary(bundle);
			LogDiagnosticOnce("ak-bundle-selection", "Bundle selection complete: bundle=" + (((Object)(object)bundle != (Object)null) ? ((Object)bundle).name : "null") + ", itemContentType=" + text + ", prefab=" + DescribeAkVisualPrefabForDiagnostics() + ", vfx=" + text2 + ", icon=" + DescribeTextureForDiagnostics(_ak47IconTexture) + ", assets=" + text3);
		}

		private static string DescribeBundleAssetSummary(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return "bundle=null";
			}
			try
			{
				GameObject[] array = bundle.LoadAllAssets<GameObject>();
				Mesh[] array2 = bundle.LoadAllAssets<Mesh>();
				Material[] array3 = bundle.LoadAllAssets<Material>();
				Texture2D[] array4 = bundle.LoadAllAssets<Texture2D>();
				string[] array5 = bundle.GetAllAssetNames() ?? Array.Empty<string>();
				string[] array6 = bundle.GetAllScenePaths() ?? Array.Empty<string>();
				string text = string.Join(", ", from go in array.Take(6)
					select ((Object)go).name);
				string text2 = string.Join(", ", from mesh in array2.OrderByDescending((Mesh mesh) => ((Object)(object)mesh != (Object)null) ? mesh.vertexCount : 0).Take(6)
					select $"{((Object)mesh).name}:{mesh.vertexCount}");
				string text3 = string.Join(", ", from material in array3.Take(6)
					select ((Object)material).name);
				string text4 = string.Join(", ", from texture in array4.Take(6)
					select $"{((Object)texture).name}:{((Texture)texture).width}x{((Texture)texture).height}");
				string text5 = string.Join(", ", array5.Take(8));
				string text6 = string.Join(", ", array6.Take(4));
				return $"go[{array.Length}]={text}; mesh[{array2.Length}]={text2}; mat[{array3.Length}]={text3}; tex[{array4.Length}]={text4}; names[{array5.Length}]={text5}; scenes[{array6.Length}]={text6}";
			}
			catch (Exception ex)
			{
				return "asset-summary-error:" + ex.GetType().Name;
			}
		}

		private void LogItemContentReflectionDiagnosis(object itemContent)
		{
			if (itemContent == null)
			{
				return;
			}
			try
			{
				Type type = itemContent.GetType();
				List<string> list = new List<string>();
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				foreach (FieldInfo item in from f in type.GetFields(bindingAttr)
					orderby f.Name
					select f)
				{
					string text = "unreadable";
					try
					{
						text = DescribeReflectionValue(item.GetValue(itemContent));
					}
					catch (Exception ex)
					{
						text = "error:" + ex.GetType().Name;
					}
					list.Add("field " + item.Name + "=" + text);
				}
				foreach (PropertyInfo item2 in from p in type.GetProperties(bindingAttr)
					orderby p.Name
					select p)
				{
					if (item2.CanRead && item2.GetIndexParameters().Length == 0)
					{
						string text2 = "unreadable";
						try
						{
							text2 = DescribeReflectionValue(item2.GetValue(itemContent, null));
						}
						catch (Exception ex2)
						{
							text2 = "error:" + ex2.GetType().Name;
						}
						list.Add("prop " + item2.Name + "=" + text2);
					}
				}
				LogDiagnosticOnce("ak-ic-members:" + type.FullName, "IC_AK members: type=" + type.FullName + ", summary=" + string.Join(" || ", list.Take(24)));
				List<DiagnosticGraphHit> list2 = new List<DiagnosticGraphHit>();
				HashSet<object> visited = new HashSet<object>(ReferenceIdentityComparer.Instance);
				InspectItemContentGraph(itemContent, "IC_AK", 0, 3, visited, list2);
				if (list2.Count == 0)
				{
					LogDiagnosticOnce("ak-ic-candidates:" + type.FullName, "IC_AK graph candidates: none");
					return;
				}
				string text3 = string.Join(" || ", from hit in (from hit in list2
						orderby hit.Score descending, hit.Path
						select hit).Take(16)
					select hit.Path + " => " + hit.Summary);
				LogDiagnosticOnce("ak-ic-candidates:" + type.FullName, "IC_AK graph candidates: " + text3);
			}
			catch (Exception ex3)
			{
				LogDiagnosticOnce("ak-ic-reflection-error", "IC_AK reflection diagnosis failed: " + ex3.GetType().Name + ": " + ex3.Message);
			}
		}

		private static void InspectItemContentGraph(object value, string path, int depth, int maxDepth, HashSet<object> visited, List<DiagnosticGraphHit> hits)
		{
			if (value == null || depth > maxDepth)
			{
				return;
			}
			Type type = value.GetType();
			if (!(value is string) && !type.IsValueType && !visited.Add(value))
			{
				return;
			}
			if (TryCreateDiagnosticGraphHit(value, path, out var hit))
			{
				hits.Add(hit);
			}
			if (depth >= maxDepth || IsTerminalDiagnosticType(type))
			{
				return;
			}
			if (value is IEnumerable enumerable && !(value is string))
			{
				int num = 0;
				{
					foreach (object item in enumerable)
					{
						InspectItemContentGraph(item, path + "[" + num + "]", depth + 1, maxDepth, visited, hits);
						num++;
						if (num >= 8)
						{
							break;
						}
					}
					return;
				}
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			FieldInfo[] fields = type.GetFields(bindingAttr);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (!ShouldSkipDiagnosticMember(fieldInfo.FieldType))
				{
					object obj = null;
					try
					{
						obj = fieldInfo.GetValue(value);
					}
					catch
					{
					}
					if (obj != null)
					{
						InspectItemContentGraph(obj, path + "." + fieldInfo.Name, depth + 1, maxDepth, visited, hits);
					}
				}
			}
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0 && !ShouldSkipDiagnosticMember(propertyInfo.PropertyType))
				{
					object obj3 = null;
					try
					{
						obj3 = propertyInfo.GetValue(value, null);
					}
					catch
					{
					}
					if (obj3 != null)
					{
						InspectItemContentGraph(obj3, path + "." + propertyInfo.Name, depth + 1, maxDepth, visited, hits);
					}
				}
			}
		}

		private static bool TryCreateDiagnosticGraphHit(object value, string path, out DiagnosticGraphHit hit)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Expected O, but got Unknown
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Expected O, but got Unknown
			hit = null;
			Item val = (Item)((value is Item) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				GameObject gameObject = ((Component)val).gameObject;
				hit = new DiagnosticGraphHit
				{
					Path = path,
					Summary = string.Format("Item(type={0}, go={1}, itemID={2}, uiName={3}, renderable={4}, detail={5})", value.GetType().FullName, ((Object)gameObject).name, val.itemID, val.UIData?.itemName ?? "null", HasRenderableGeometry(gameObject), DescribeGameObjectForDiagnostics(gameObject, 4)),
					Score = ScoreDiagnosticGameObject(gameObject)
				};
				return true;
			}
			GameObject val2 = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val2 != (Object)null)
			{
				hit = new DiagnosticGraphHit
				{
					Path = path,
					Summary = $"GameObject(type={value.GetType().FullName}, renderable={HasRenderableGeometry(val2)}, detail={DescribeGameObjectForDiagnostics(val2, 4)})",
					Score = ScoreDiagnosticGameObject(val2)
				};
				return true;
			}
			Component val3 = (Component)((value is Component) ? value : null);
			if ((Object)(object)val3 != (Object)null)
			{
				GameObject gameObject2 = val3.gameObject;
				hit = new DiagnosticGraphHit
				{
					Path = path,
					Summary = $"Component(type={value.GetType().FullName}, go={((Object)gameObject2).name}, renderable={HasRenderableGeometry(gameObject2)}, detail={DescribeGameObjectForDiagnostics(gameObject2, 4)})",
					Score = ScoreDiagnosticGameObject(gameObject2)
				};
				return true;
			}
			Texture2D val4 = (Texture2D)((value is Texture2D) ? value : null);
			if ((Object)(object)val4 != (Object)null)
			{
				hit = new DiagnosticGraphHit
				{
					Path = path,
					Summary = "Texture2D(" + DescribeTextureForDiagnostics(val4) + ")",
					Score = 200
				};
				return true;
			}
			Material val5 = (Material)((value is Material) ? value : null);
			if ((Object)(object)val5 != (Object)null)
			{
				DiagnosticGraphHit diagnosticGraphHit = new DiagnosticGraphHit
				{
					Path = path
				};
				DiagnosticGraphHit diagnosticGraphHit2 = diagnosticGraphHit;
				string[] obj = new string[7]
				{
					"Material(name=",
					((Object)val5).name,
					", shader=",
					null,
					null,
					null,
					null
				};
				Shader shader = val5.shader;
				obj[3] = ((shader != null) ? ((Object)shader).name : null) ?? "null";
				obj[4] = ", mainTex=";
				obj[5] = (((Object)(object)val5.mainTexture != (Object)null) ? ((Object)val5.mainTexture).name : "null");
				obj[6] = ")";
				diagnosticGraphHit2.Summary = string.Concat(obj);
				diagnosticGraphHit.Score = 150;
				hit = diagnosticGraphHit;
				return true;
			}
			Mesh val6 = (Mesh)((value is Mesh) ? value : null);
			if ((Object)(object)val6 != (Object)null)
			{
				hit = new DiagnosticGraphHit
				{
					Path = path,
					Summary = $"Mesh(name={((Object)val6).name}, verts={val6.vertexCount}, subMeshes={val6.subMeshCount})",
					Score = 100 + val6.vertexCount
				};
				return true;
			}
			Object val7 = (Object)((value is Object) ? value : null);
			if (val7 != (Object)null)
			{
				hit = new DiagnosticGraphHit
				{
					Path = path,
					Summary = "UnityObject(type=" + value.GetType().FullName + ", name=" + val7.name + ")",
					Score = 50
				};
				return true;
			}
			return false;
		}

		private static int ScoreDiagnosticGameObject(GameObject candidate)
		{
			if ((Object)(object)candidate == (Object)null)
			{
				return int.MinValue;
			}
			int num = 0;
			string text = (((Object)candidate).name ?? string.Empty).ToLowerInvariant();
			if (text.Contains("ak") || text.Contains("rifle") || text.Contains("gun") || text.Contains("weapon"))
			{
				num += 12000;
			}
			if (text.Contains("vfx") || text.Contains("effect") || text.Contains("flash") || text.Contains("particle") || text.Contains("smoke"))
			{
				num -= 20000;
			}
			MeshFilter[] componentsInChildren = candidate.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.sharedMesh != (Object)null)
				{
					num += val.sharedMesh.vertexCount;
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = candidate.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMesh != (Object)null)
				{
					num += val2.sharedMesh.vertexCount;
				}
			}
			return num;
		}

		private static bool IsTerminalDiagnosticType(Type type)
		{
			if (type == null)
			{
				return true;
			}
			if (type.IsPrimitive || type.IsEnum || type == typeof(string) || type == typeof(decimal))
			{
				return true;
			}
			if (typeof(Object).IsAssignableFrom(type))
			{
				return true;
			}
			string text = type.FullName ?? string.Empty;
			if (!text.StartsWith("System.", StringComparison.Ordinal) && !text.StartsWith("UnityEngine.", StringComparison.Ordinal))
			{
				return text.StartsWith("TMPro.", StringComparison.Ordinal);
			}
			return true;
		}

		private static bool ShouldSkipDiagnosticMember(Type memberType)
		{
			if (memberType == null)
			{
				return true;
			}
			if (memberType.IsPointer)
			{
				return true;
			}
			if (!typeof(Delegate).IsAssignableFrom(memberType))
			{
				if (!(memberType == typeof(IntPtr)))
				{
					return memberType == typeof(UIntPtr);
				}
				return true;
			}
			return true;
		}

		private static string DescribeReflectionValue(object value)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			if (value == null)
			{
				return "null";
			}
			Type type = value.GetType();
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				return $"GameObject(name={((Object)val).name}, renderable={HasRenderableGeometry(val)})";
			}
			Item val2 = (Item)((value is Item) ? value : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return string.Format("Item(go={0}, itemID={1}, uiName={2})", ((Object)((Component)val2).gameObject).name, val2.itemID, val2.UIData?.itemName ?? "null");
			}
			Component val3 = (Component)((value is Component) ? value : null);
			if ((Object)(object)val3 != (Object)null)
			{
				return "Component(type=" + type.FullName + ", go=" + ((Object)val3.gameObject).name + ")";
			}
			Texture2D val4 = (Texture2D)((value is Texture2D) ? value : null);
			if ((Object)(object)val4 != (Object)null)
			{
				return "Texture2D(" + DescribeTextureForDiagnostics(val4) + ")";
			}
			Material val5 = (Material)((value is Material) ? value : null);
			if ((Object)(object)val5 != (Object)null)
			{
				string[] obj = new string[5]
				{
					"Material(name=",
					((Object)val5).name,
					", shader=",
					null,
					null
				};
				Shader shader = val5.shader;
				obj[3] = ((shader != null) ? ((Object)shader).name : null) ?? "null";
				obj[4] = ")";
				return string.Concat(obj);
			}
			Mesh val6 = (Mesh)((value is Mesh) ? value : null);
			if ((Object)(object)val6 != (Object)null)
			{
				return $"Mesh(name={((Object)val6).name}, verts={val6.vertexCount})";
			}
			Object val7 = (Object)((value is Object) ? value : null);
			if (val7 != (Object)null)
			{
				return "UnityObject(type=" + type.FullName + ", name=" + val7.name + ")";
			}
			if (value is IEnumerable enumerable && !(value is string))
			{
				int num = 0;
				foreach (object item in enumerable)
				{
					_ = item;
					num++;
					if (num >= 8)
					{
						break;
					}
				}
				return $"Enumerable(type={type.FullName}, count>={num})";
			}
			return "Object(type=" + type.FullName + ")";
		}

		private static bool IsLikelyIconTexture(Texture2D texture)
		{
			if ((Object)(object)texture == (Object)null)
			{
				return false;
			}
			int width = ((Texture)texture).width;
			int height = ((Texture)texture).height;
			if (width <= 0 || height <= 0)
			{
				return false;
			}
			string text = (((Object)texture).name ?? string.Empty).ToLowerInvariant();
			if (text.Contains("icon") || text.Contains("ui") || text.Contains("thumb") || text.Contains("inventory"))
			{
				if (width <= 4096 && height <= 4096)
				{
					return Mathf.Abs(width - height) <= Mathf.Max(4, Mathf.RoundToInt((float)Mathf.Max(width, height) * 0.02f));
				}
				return false;
			}
			if (width >= 32 && height >= 32 && width <= 512 && height <= 512)
			{
				return Mathf.Abs(width - height) <= 2;
			}
			return false;
		}

		private static Texture2D TryExtractIconFromItemContent(object itemContent)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			if (itemContent == null)
			{
				return null;
			}
			try
			{
				Type type = itemContent.GetType();
				object obj = type.GetProperty("Item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(itemContent) ?? type.GetField("Item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(itemContent);
				Texture2D val = TryExtractIconFromItem((Item)((obj is Item) ? obj : null));
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				if (obj != null && obj != itemContent)
				{
					Texture2D val2 = TryExtractIconFromItemContent(obj);
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
				object obj2 = type.GetProperty("icon", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(itemContent);
				Texture2D val3 = (Texture2D)((obj2 is Texture2D) ? obj2 : null);
				if ((Object)(object)val3 != (Object)null)
				{
					return val3;
				}
				object obj3 = type.GetField("icon", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(itemContent);
				Texture2D val4 = (Texture2D)((obj3 is Texture2D) ? obj3 : null);
				if ((Object)(object)val4 != (Object)null)
				{
					return val4;
				}
			}
			catch
			{
			}
			return null;
		}

		private static Texture2D TryExtractIconFromItem(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			try
			{
				Texture2D val = item.UIData?.icon;
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				Texture2D val2 = item.UIData?.altIcon;
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
				ItemUIData uIData = item.UIData;
				Texture2D val3 = ((uIData != null) ? uIData.GetIcon() : null);
				if ((Object)(object)val3 != (Object)null)
				{
					return val3;
				}
			}
			catch
			{
			}
			return null;
		}

		private void TryResolveKnownAkItemContent(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null || _ak47ItemContent != null)
			{
				return;
			}
			Type type = ResolveLoadedType("PEAKLib.Items.UnityEditor.UnityItemContent", "com.github.PEAKModding.PEAKLib.Items") ?? ResolveLoadedType("PEAKLib.Items.ItemContent", "com.github.PEAKModding.PEAKLib.Items");
			if (type == null)
			{
				LogDiagnosticOnce("ak-itemcontent-type-missing", "PEAKLib.Items is not loaded, so IC_AK cannot be deserialized from the AK bundle.");
				return;
			}
			IEnumerable<string> source = bundle.GetAllAssetNames() ?? Array.Empty<string>();
			foreach (string item in PreferredAkItemContentAssetNames.Concat(source.Where((string name) => !string.IsNullOrWhiteSpace(name) && name.IndexOf("ic_ak", StringComparison.OrdinalIgnoreCase) >= 0)).Distinct<string>(StringComparer.OrdinalIgnoreCase))
			{
				if (string.IsNullOrWhiteSpace(item))
				{
					continue;
				}
				Object val = null;
				try
				{
					val = bundle.LoadAsset(item, type);
				}
				catch (Exception ex)
				{
					LogDiagnosticOnce("ak-itemcontent-typed-load-error:" + item, "Typed IC_AK load failed: asset=" + item + ", type=" + type.FullName + ", error=" + ex.GetType().Name);
				}
				if (!(val == (Object)null))
				{
					_ak47ItemContent = val;
					LogItemContentReflectionDiagnosis(_ak47ItemContent);
					TryAssignAkPrefabFromItemContent(_ak47ItemContent);
					if ((Object)(object)_ak47IconTexture == (Object)null)
					{
						_ak47IconTexture = TryExtractIconFromItemContent(_ak47ItemContent);
					}
					LogDiagnosticOnce("ak-itemcontent-typed-load:" + item, "Resolved IC_AK using exact type load: asset=" + item + ", type=" + type.FullName + ", name=" + val.name);
					break;
				}
			}
		}

		private GameObject CreateFallbackModel()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0072: 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)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)obj).name = "AK47_Fallback";
			obj.transform.localScale = new Vector3(0.1f, 0.1f, 0.5f);
			MeshRenderer component = obj.GetComponent<MeshRenderer>();
			if ((Object)(object)component != (Object)null)
			{
				Material val = new Material(ResolveLocalVisualCompatibleShader());
				if (val.HasProperty("_BaseColor"))
				{
					val.SetColor("_BaseColor", new Color(0.2f, 0.2f, 0.2f, 1f));
				}
				if (val.HasProperty("_Color"))
				{
					val.SetColor("_Color", new Color(0.2f, 0.2f, 0.2f, 1f));
				}
				((Renderer)component).material = val;
			}
			return obj;
		}

		private static GameObject TryCreateSyntheticAkPrefabFromBundle(Mesh[] meshes, Material[] materials, Texture2D[] textures)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			Mesh val = SelectBestBundleMesh(meshes);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			int num = Mathf.Max(val.subMeshCount, 1);
			Material[] array = ChooseBundleMaterials(materials, textures, num);
			if (array == null || array.Length == 0)
			{
				array = (Material[])(object)new Material[num];
				for (int i = 0; i < num; i++)
				{
					array[i] = CreateSyntheticFallbackMaterial(null);
				}
			}
			GameObject val2 = new GameObject("AK");
			((Object)val2).hideFlags = (HideFlags)61;
			val2.SetActive(false);
			GameObject val3 = new GameObject("Mesh")
			{
				hideFlags = (HideFlags)61
			};
			val3.transform.SetParent(val2.transform, false);
			MeshFilter val4 = val3.AddComponent<MeshFilter>();
			MeshRenderer val5 = val3.AddComponent<MeshRenderer>();
			val4.sharedMesh = val;
			((Renderer)val5).sharedMaterials = NormalizeBundleMaterialArray(array, num);
			LogDiagnosticOnce("ak-synthetic-prefab:" + ((Object)val).name, $"Created synthetic AK prefab from raw bundle mesh: mesh={((Object)val).name}, verts={val.vertexCount}, subMeshes={num}, mats={((Renderer)val5).sharedMaterials.Length}");
			return val2;
		}

		private static GameObject TryLoadRenderablePrefabFromNamedAssets(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return null;
			}
			string[] obj = bundle.GetAllAssetNames() ?? Array.Empty<string>();
			GameObject val = null;
			int num = int.MinValue;
			string[] array = obj;
			foreach (string text in array)
			{
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				GameObject val2 = null;
				try
				{
					val2 = bundle.LoadAsset<GameObject>(text);
				}
				catch
				{
				}
				if (!((Object)(object)val2 == (Object)null) && HasRenderableGeometry(val2))
				{
					int num2 = ScoreNamedRenderablePrefab(text, val2);
					if (num2 > num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				LogDiagnosticOnce("ak-named-prefab", "Loaded renderable prefab from named asset: asset=" + FindAssetNameForObject(bundle, (Object)(object)val) + ", prefab=" + DescribeGameObjectForDiagnostics(val));
			}
			return val;
		}

		private static int ScoreNamedRenderablePrefab(string assetName, GameObject candidate)
		{
			int num = 0;
			string text = ((assetName ?? string.Empty) + "/" + (((Object)candidate).name ?? string.Empty)).ToLowerInvariant();
			if (text.Contains("ak") || text.Contains("rifle") || text.Contains("gun") || text.Contains("weapon"))
			{
				num += 12000;
			}
			if (text.Contains("prefab") || text.Contains("model") || text.Contains("mesh"))
			{
				num += 4000;
			}
			if (text.Contains("vfx") || text.Contains("effect") || text.Contains("flash") || text.Contains("smoke") || text.Contains("particle") || text.Contains("muzzle"))
			{
				num -= 20000;
			}
			MeshFilter[] componentsInChildren = candidate.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.sharedMesh != (Object)null)
				{
					num += val.sharedMesh.vertexCount;
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = candidate.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMesh != (Object)null)
				{
					num += val2.sharedMesh.vertexCount;
				}
			}
			return num;
		}

		private static GameObject TryCreateSyntheticAkPrefabFromNamedAssets(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return null;
			}
			string[] obj = bundle.GetAllAssetNames() ?? Array.Empty<string>();
			List<Mesh> list = new List<Mesh>();
			List<Material> list2 = new List<Material>();
			List<Texture2D> list3 = new List<Texture2D>();
			string[] array = obj;
			foreach (string text in array)
			{
				if (!string.IsNullOrWhiteSpace(text))
				{
					TryAddNamedAsset(bundle, text, list, list2, list3);
				}
			}
			if (list.Count == 0 && list2.Count == 0 && list3.Count == 0)
			{
				return null;
			}
			LogDiagnosticOnce("ak-named-assets-scan", $"Named asset scan found mesh={list.Count}, mat={list2.Count}, tex={list3.Count}");
			return TryCreateSyntheticAkPrefabFromBundle(list.Distinct().ToArray(), list2.Distinct().ToArray(), list3.Distinct().ToArray());
		}

		private static void TryAddNamedAsset(AssetBundle bundle, string assetName, List<Mesh> meshes, List<Material> materials, List<Texture2D> textures)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			try
			{
				Mesh val = bundle.LoadAsset<Mesh>(assetName);
				if ((Object)(object)val != (Object)null)
				{
					meshes.Add(val);
				}
			}
			catch
			{
			}
			try
			{
				Material val2 = bundle.LoadAsset<Material>(assetName);
				if ((Object)(object)val2 != (Object)null)
				{
					materials.Add(val2);
				}
			}
			catch
			{
			}
			try
			{
				Texture2D val3 = bundle.LoadAsset<Texture2D>(assetName);
				if ((Object)(object)val3 != (Object)null)
				{
					textures.Add(val3);
				}
			}
			catch
			{
			}
			try
			{
				Object[] array = bundle.LoadAssetWithSubAssets(assetName);
				if (array == null)
				{
					return;
				}
				Object[] array2 = array;
				foreach (Object val4 in array2)
				{
					Mesh val5 = (Mesh)((val4 is Mesh) ? val4 : null);
					if ((Object)(object)val5 != (Object)null)
					{
						meshes.Add(val5);
						continue;
					}
					Material val6 = (Material)((val4 is Material) ? val4 : null);
					if ((Object)(object)val6 != (Object)null)
					{
						materials.Add(val6);
						continue;
					}
					Texture2D val7 = (Texture2D)((val4 is Texture2D) ? val4 : null);
					if ((Object)(object)val7 != (Object)null)
					{
						textures.Add(val7);
					}
				}
			}
			catch
			{
			}
		}

		private static string FindAssetNameForObject(AssetBundle bundle, Object target)
		{
			if ((Object)(object)bundle == (Object)null || target == (Object)null)
			{
				return "unknown";
			}
			string[] array = bundle.GetAllAssetNames() ?? Array.Empty<string>();
			foreach (string text in array)
			{
				try
				{
					if (bundle.LoadAsset(text) == target)
					{
						return text;
					}
				}
				catch
				{
				}
			}
			return "unknown";
		}

		private static void TryResolvePreferredAkAssets(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return;
			}
			if (!HasRenderableGeometry(_ak47Prefab))
			{
				GameObject val = TryLoadNamedGameObject(bundle, PreferredAkPrefabAssetNames);
				if ((Object)(object)val != (Object)null && HasRenderableGeometry(val))
				{
					_ak47Prefab = val;
					LogDiagnosticOnce("ak-preferred-prefab", "Resolved AK prefab from top-level bundle asset: " + DescribeGameObjectForDiagnostics(val));
				}
			}
			if ((Object)(object)_ak47IconTexture == (Object)null)
			{
				Texture2D val2 = TryLoadNamedTexture(bundle, PreferredAkIconAssetNames);
				if ((Object)(object)val2 != (Object)null)
				{
					_ak47IconTexture = val2;
					LogDiagnosticOnce("ak-preferred-icon", "Resolved AK icon from top-level bundle asset: " + DescribeTextureForDiagnostics(val2));
				}
			}
			if ((Object)(object)_ak47VFX == (Object)null)
			{
				GameObject val3 = TryLoadNamedGameObject(bundle, PreferredAkVfxAssetNames);
				if ((Object)(object)val3 != (Object)null)
				{
					_ak47VFX = val3;
				}
			}
		}

		private static GameObject TryLoadNamedGameObject(AssetBundle bundle, IEnumerable<string> assetNames)
		{
			if ((Object)(object)bundle == (Object)null || assetNames == null)
			{
				return null;
			}
			foreach (string assetName in assetNames)
			{
				if (string.IsNullOrWhiteSpace(assetName))
				{
					continue;
				}
				try
				{
					GameObject val = bundle.LoadAsset<GameObject>(assetName);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static Texture2D TryLoadNamedTexture(AssetBundle bundle, IEnumerable<string> assetNames)
		{
			if ((Object)(object)bundle == (Object)null || assetNames == null)
			{
				return null;
			}
			foreach (string assetName in assetNames)
			{
				if (string.IsNullOrWhiteSpace(assetName))
				{
					continue;
				}
				try
				{
					Texture2D val = bundle.LoadAsset<Texture2D>(assetName);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static Mesh SelectBestBundleMesh(Mesh[] meshes)
		{
			if (meshes == null || meshes.Length == 0)
			{
				return null;
			}
			Mesh val = null;
			int num = int.MinValue;
			foreach (Mesh val2 in meshes)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					string text = (((Object)val2).name ?? string.Empty).ToLowerInvariant();
					int num2 = val2.vertexCount;
					if (num2 <= 24)
					{
						num2 -= 20000;
					}
					if (text.Contains("ak") || text.Contains("rifle") || text.Contains("gun") || text.Contains("weapon"))
					{
						num2 += 12000;
					}
					if (text.Contains("mesh") || text.Contains("body"))
					{
						num2 += 2000;
					}
					if (text.Contains("vfx") || text.Contains("effect") || text.Contains("spawn") || text.Contains("muzzle") || text.Contains("flash") || text.Contains("smoke") || text.Contains("hand") || text.Contains("arm") || text.Contains("finger") || text.Contains("trigger") || text.Contains("collider") || text.Contains("cube") || text.Contains("plane") || text.Contains("quad") || text.Contains("sphere") || text.Contains("capsule"))
					{
						num2 -= 30000;
					}
					if (num2 > num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				LogDiagnosticOnce("ak-synthetic-mesh-candidate", $"Selected raw bundle mesh candidate: name={((Object)val).name}, verts={val.vertexCount}, score={num}");
			}
			return val;
		}

		private static Material[] ChooseBundleMaterials(Material[] materials, Texture2D[] textures, int subMeshCount)
		{
			subMeshCount = Mathf.Max(subMeshCount, 1);
			List<Material> list = new List<Material>();
			if (materials != null)
			{
				foreach (Material item in materials.OrderByDescending(ScoreBundleMaterial))
				{
					if (!((Object)(object)item == (Object)null) && ScoreBundleMaterial(item) >= -1000)
					{
						list.Add(item);
						if (list.Count >= subMeshCount)
						{
							break;
						}
					}
				}
			}
			if (list.Count == 0)
			{
				Texture2D mainTexture = SelectBestBundleTexture(textures);
				for (int i = 0; i < subMeshCount; i++)
				{
					list.Add(CreateSyntheticFallbackMaterial(mainTexture));
				}
			}
			return NormalizeBundleMaterialArray(list.ToArray(), subMeshCount);
		}

		private static int ScoreBundleMaterial(Material material)
		{
			if ((Object)(object)material == (Object)null)
			{
				return int.MinValue;
			}
			string text = (((Object)material).name ?? string.Empty).ToLowerInvariant();
			int num = 0;
			if (text.Contains("ak") || text.Contains("gun") || text.Contains("weapon") || text.Contains("body") || text.Contains("mat"))
			{
				num += 4000;
			}
			if (text.Contains("vfx") || text.Contains("effect") || text.Contains("particle") || text.Contains("smoke") || text.Contains("flash"))
			{
				num -= 12000;
			}
			if ((Object)(object)material.mainTexture != (Object)null)
			{
				num += 2500;
			}
			Shader shader = material.shader;
			string text2 = ((shader == null) ? null : ((Object)shader).name?.ToLowerInvariant()) ?? string.Empty;
			if (text2.Contains("particle") || text2.Contains("vfx"))
			{
				num -= 10000;
			}
			return num;
		}

		private static Texture2D SelectBestBundleTexture(Texture2D[] textures)
		{
			if (textures == null || textures.Length == 0)
			{
				return null;
			}
			Texture2D result = null;
			int num = int.MinValue;
			foreach (Texture2D val in textures)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string text = (((Object)val).name ?? string.Empty).ToLowerInvariant();
					int num2 = ((Texture)val).width * ((Texture)val).height;
					if (IsLikelyIconTexture(val))
					{
						num2 -= 20000;
					}
					if (text.Contains("ak") || text.Contains("gun") || text.Contains("weapon") || text.Contains("body") || text.Contains("albedo") || text.Contains("base"))
					{
						num2 += 12000;
					}
					if (text.Contains("icon") || text.Contains("ui") || text.Contains("thumb") || text.Contains("inventory") || text.Contains("vfx") || text.Contains("effect") || text.Contains("particle"))
					{
						num2 -= 15000;
					}
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static Material CreateSyntheticFallbackMaterial(Texture2D mainTexture)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Material val = new Material(ResolveLocalVisualCompatibleShader());
			if (val.HasProperty("_BaseColor"))
			{
				val.SetColor("_BaseColor", Color.white);
			}
			if (val.HasProperty("_Color"))
			{
				val.SetColor("_Color", Color.white);
			}
			if ((Object)(object)mainTexture != (Object)null)
			{
				if (val.HasProperty("_BaseMap"))
				{
					val.SetTexture("_BaseMap", (Texture)(object)mainTexture);
				}
				if (val.HasProperty("_MainTex"))
				{
					val.SetTexture("_MainTex", (Texture)(object)mainTexture);
				}
			}
			return val;
		}

		private static Material[] NormalizeBundleMaterialArray(Material[] source, int subMeshCount)
		{
			subMeshCount = Mathf.Max(subMeshCount, 1);
			Material[] array = (Material[])(object)new Material[subMeshCount];
			if (source == null || source.Length == 0)
			{
				for (int i = 0; i < subMeshCount; i++)
				{
					array[i] = CreateSyntheticFallbackMaterial(null);
				}
				return array;
			}
			for (int j = 0; j < subMeshCount; j++)
			{
				Material val = source[Mathf.Clamp(j, 0, source.Length - 1)];
				array[j] = (((Object)(object)val != (Object)null) ? val : CreateSyntheticFallbackMaterial(null));
			}
			return array;
		}

		private bool IsChineseLanguage()
		{
			bool isChinese;
			string languageName;
			string source;
			return TryResolveGameLanguage(out isChinese, out languageName, out source) && isChinese;
		}

		private bool GetCachedChineseLanguageSetting(bool forceRefresh = false)
		{
			if (forceRefresh || Time.unscaledTime - _lastLanguagePollTime >= 0.5f)
			{
				_cachedIsChineseLanguage = IsChineseLanguage();
				_lastLanguagePollTime = Time.unscaledTime;
			}
			return _cachedIsChineseLanguage;
		}

		internal bool GetCachedChineseLanguageSettingRuntime(bool forceRefresh = false)
		{
			return GetCachedChineseLanguageSetting(forceRefresh);
		}

		private bool TryResolveGameLanguage(out bool isChinese, out string languageName, out string source)
		{
			if (TryGetConfiguredGameLanguage(out isChinese, out languageName))
			{
				source = "PlayerPrefs.LanguageSetting";
				return true;
			}
			if (TryGetLocalizedTextCurrentLanguage(out isChinese, out languageName))
			{
				source = "LocalizedText.CURRENT_LANGUAGE";
				return true;
			}
			isChinese = false;
			languageName = string.Empty;
			source = string.Empty;
			return false;
		}

		private static bool TryGetConfiguredGameLanguage(out bool isChinese, out string languageName)
		{
			isChinese = false;
			languageName = string.Empty;
			try
			{
				if (!PlayerPrefs.HasKey("LanguageSetting"))
				{
					return false;
				}
				if (TryGetPlayerPrefsInt("LanguageSetting", out var value))
				{
					languageName = GetConfiguredLanguageName(value);
					isChinese = value == 9;
					return true;
				}
				string @string = PlayerPrefs.GetString("LanguageSetting", string.Empty);
				if (string.IsNullOrWhiteSpace(@string))
				{
					return false;
				}
				if (int.TryParse(@string, NumberStyles.Integer, CultureInfo.InvariantCulture, out value))
				{
					languageName = GetConfiguredLanguageName(value);
					isChinese = value == 9;
					return true;
				}
				languageName = @string;
				isChinese = IsChineseLanguageName(@string);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsLikelyAkVisualPrefab(GameObject candidate)
		{
			if ((Object)(object)candidate == (Object)null)
			{
				return false;
			}
			string text = (((Object)candidate).name ?? string.Empty).ToLowerInvariant();
			if (!(text == "vfx_ak") && !text.Contains("vfx_ak"))
			{
				if (text.Contains("vfx"))
				{
					return text.Contains("ak");
				}
				return false;
			}
			return true;
		}

		private static string DescribeRenderableCounts(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return "no-renderers";
			}
			MeshRenderer[] componentsInChildren = root.GetComponentsInChildren<MeshRenderer>(true);
			SkinnedMeshRenderer[] componentsInChildren2 = root.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			MeshFilter[] componentsInChildren3 = root.GetComponentsInChildren<MeshFilter>(true);
			return $"{componentsInChildren.Length} MeshRenderers, {componentsInChildren2.Length} SkinnedMeshRenderers, {componentsInChildren3.Length} MeshFilters";
		}

		private static bool TryGetLocalizedTextCurrentLanguage(out bool isChinese, out string languageName)
		{
			isChinese = false;
			languageName = string.Empty;
			try
			{
				object obj = ((typeof(Item).Assembly.GetType("LocalizedText") ?? ResolveLoadedType("LocalizedText"))?.GetField("CURRENT_LANGUAGE", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))?.GetValue(null);
				if (obj == null)
				{
					return false;
				}
				languageName = obj.ToString() ?? string.Empty;
				if (string.IsNullOrWhiteSpace(languageName))
				{
					languageName = Convert.ToInt32(obj, CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture);
				}
				isChinese = IsChineseLanguageName(languageName);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetPlayerPrefsInt(string key, out int value)
		{
			value = int.MinValue;
			try
			{
				value = PlayerPrefs.GetInt(key, int.MinValue);
				return value != int.MinValue;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsChineseLanguageName(string languageName)
		{
			if (string.IsNullOrWhiteSpace(languageName))
			{
				return false;
			}
			if (languageName.IndexOf("SimplifiedChinese", StringComparison.OrdinalIgnoreCase) < 0 && languageName.IndexOf("TraditionalChinese", StringComparison.OrdinalIgnoreCase) < 0 && !languageName.StartsWith("zh", StringComparison.OrdinalIgnoreCase) && languageName.IndexOf("Chinese", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return languageName.IndexOf("中文", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static string GetConfiguredLanguageName(int languageValue)
		{
			return languageValue switch
			{
				0 => "English", 
				1 => "French", 
				2 => "Italian", 
				3 => "German", 
				4 => "SpanishSpain", 
				5 => "SpanishLatam", 
				6 => "BRPortuguese", 
				7 => "Russian", 
				8 => "Ukrainian", 
				9 => "SimplifiedChinese", 
				10 => "Japanese", 
				11 => "Korean", 
				12 => "Polish", 
				13 => "Turkish", 
				_ => languageValue.ToString(CultureInfo.InvariantCulture), 
			};
		}

		private ConfigEntry<float> BindRangedFloat(string section, string key, float defaultValue, float minValue, float maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			return ((BaseUnityPlugin)this).Config.Bind<float>(section, key, defaultValue, new ConfigDescription(GetLocalizedDescription(key, isChinese: false), (AcceptableValueBase)new AcceptableValueRange<float>(minValue, maxValue), Array.Empty<object>()));
		}

		private ConfigEntry<int> BindRangedInt(string section, string key, int defaultValue, int minValue, int maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			return ((BaseUnityPlugin)this).Config.Bind<int>(section, key, defaultValue, new ConfigDescription(GetLocalizedDescription(key, isChinese: false), (AcceptableValueBase)new AcceptableValueRange<int>(minValue, maxValue), Array.Empty<object>()));
		}

		private ConfigEntry<string> BindSelectableString(string section, string key, string defaultValue, string[] values)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return ((BaseUnityPlugin)this).Config.Bind<string>(section, key, defaultValue, new ConfigDescription(GetLocalizedDescription(key, isChinese: false), (AcceptableValueBase)new AcceptableValueList<string>(values ?? Array.Empty<string>()), Array.Empty<object>()));
		}

		private static string GetConfigBindingSectionName(string canonicalSection, bool isChinese)
		{
			return NormalizeSectionAlias(canonicalSection);
		}

		private static string GetConfigBindingKeyName(string canonicalKey, bool isChinese)
		{
			return NormalizeConfigKeyAlias(canonicalKey);
		}

		private static void NormalizeConfigRanges()
		{
			if (ZombieBehaviorDifficulty != null)
			{
				ZombieBehaviorDifficulty.Value = NormalizeZombieBehaviorDifficultySelection(ZombieBehaviorDifficulty.Value);
			}
			FireInterval.Value = Mathf.Clamp(FireInterval.Value, 0.1f, 3f);
			FireVolume.Value = Mathf.Clamp(FireVolume.Value, 0f, 1.5f);
			WeaponModelPitch.Value = Mathf.Clamp(WeaponModelPitch.Value, -180f, 180f);
			WeaponModelYaw.Value = Mathf.Clamp(WeaponModelYaw.Value, -180f, 180f);
			WeaponModelRoll.Value = Mathf.Clamp(WeaponModelRoll.Value, -180f, 180f);
			WeaponModelScale.Value = Mathf.Clamp(WeaponModelScale.Value, 0.3f, 2f);
			WeaponModelOffsetX.Value = Mathf.Clamp(WeaponModelOffsetX.Value, -0.5f, 0.5f);
			WeaponModelOffsetY.Value = Mathf.Clamp(WeaponModelOffsetY.Value, -0.5f, 0.5f);
			WeaponModelOffsetZ.Value = Mathf.Clamp(WeaponModelOffsetZ.Value, -0.5f, 0.5f);
			ZombieTimeReduction.Value = Mathf.Clamp(ZombieTimeReduction.Value, 0f, 60f);
			MaxZombies.Value = Mathf.Clamp(MaxZombies.Value, 0, 30);
			ZombieSpawnCount.Value = Mathf.Clamp(ZombieSpawnCount.Value, 0, 30);
			ZombieSpawnInterval.Value = Mathf.Clamp(ZombieSpawnInterval.Value, 1f, 120f);
			ZombieMaxLifetime.Value = Mathf.Clamp(ZombieMaxLifetime.Value, 10f, 600f);
			if (ZombieKnockbackForce != null)
			{
				ZombieKnockbackForce.Value = Mathf.Clamp(ZombieKnockbackForce.Value, 0f, 2000f);
			}
		}

		private void InitConfig()
		{
			bool isChinese = IsChineseLanguage();
			string configBindingSectionName = GetConfigBindingSectionName("Features", isChinese);
			string configBindingSectionName2 = GetConfigBindingSectionName("Weapon", isChinese);
			string configBindingSectionName3 = GetConfigBindingSectionName("Zombie", isChinese);
			ModEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>(configBindingSectionName, GetConfigBindingKeyName("Mod", isChinese), true, GetLocalizedDescription("Mod", isChinese: false));
			OpenConfigPanelKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>(configBindingSectionName, GetConfigBindingKeyName("Open Config Panel", isChinese), (KeyCode)92, GetLocalizedDescription("Open Config Panel", isChinese: false));
			ConfigPanelTheme = BindSelectableString(configBindingSectionName, GetConfigBindingKeyName("Config Panel Theme", isChinese), "dark", ConfigPanelThemeValues);
			string text = LobbyConfigPanel.NormalizeThemeSelectionValue(ConfigPanelTheme.Value);
			if (!string.Equals(ConfigPanelTheme.Value, text, StringComparison.Ordinal))
			{
				ConfigPanelTheme.Value = text;
				SavePluginConfigQuietly();
			}
			WeaponEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>(configBindingSectionName2, GetConfigBindingKeyName("Weapon", isChinese), true, GetLocalizedDescription("Weapon", isChinese: false));
			WeaponSelection = BindSelectableString(configBindingSectionName2, GetConfigBindingKeyName("Weapon Selection", isChinese), "AK47", WeaponSelectionValues);
			string text2 = NormalizeWeaponSelection(WeaponSelection.Value);
			if (!string.Equals(WeaponSelection.Value, text2, StringComparison.Ordinal))
			{
				WeaponSelection.Value = text2;
				SavePluginConfigQuietly();
			}
			SpawnWeaponKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>(configBindingSectionName2, GetConfigBindingKeyName("Spawn Weapon", isChinese), (KeyCode)116, GetLocalizedDescription("Spawn Weapon", isChinese: false));
			FireInterval = BindRangedFloat(configBindingSectionName2, GetConfigBindingKeyName("Fire Interval", isChinese), 0.4f, 0.1f, 3f);
			FireVolume = BindRangedFloat(configBindingSectionName2, GetConfigBindingKeyName("Fire Volume", isChinese), 0.8f, 0f, 1.5f);
			AkSoundSelection = BindSelectableString(configBindingSectionName2, GetConfigBindingKeyName("AK Sound", isChinese), "ak_sound1", AkSoundSelectionValues);
			string text3 = NormalizeAkSoundSelection(AkSoundSelection.Value);
			if (!string.Equals(AkSoundSelection.Value, text3, StringComparison.Ordinal))
			{
				AkSoundSelection.Value = text3;
				SavePluginConfigQuietly();
			}
			AkSoundSelection.SettingChanged += delegate
			{
				OnAkSoundSelectionChanged();
			};
			ZombieTimeReduction = BindRangedFloat(configBindingSectionName2, GetConfigBindingKeyName("Zombie Time Reduction", isChinese), 25f, 0f, 60f);
			WeaponModelScale = BindRangedFloat(configBindingSectionName2, GetConfigBindingKeyName("Weapon Model Scale", isChinese), _localWeaponModelScale.x, 0.3f, 2f);
			WeaponModelPitch = BindRangedFloat(configBindingSectionName, GetConfigBindingKeyName("Weapon Model X Rotation", isChinese), _localWeaponModelEuler.x, -180f, 180f);
			WeaponModelYaw = BindRangedFloat(configBindingSectionName, GetConfigBindingKeyName("Weapon Model Y Rotation", isChinese), _localWeaponModelEuler.y, -180f, 180f);
			WeaponModelRoll = BindRangedFloat(configBindingSectionName, GetConfigBindingKeyName("Weapon Model Z Rotation", isChinese), _localWeaponModelEuler.z, -180f, 180f);
			WeaponModelOffsetX = BindRangedFloat(configBindingSectionName, GetConfigBindingKeyName("Weapon Model X Position", isChinese), _localWeaponModelOffset.x, -0.5f, 0.5f);
			WeaponModelOffsetY = BindRangedFloat(configBindingSectionName, GetConfigBindingKeyName("Weapon Model Y Position", isChinese), _localWeaponModelOffset.y, -0.5f, 0.5f);
			WeaponModelOffsetZ = BindRangedFloat(configBindingSectionName, GetConfigBindingKeyName("Weapon Model Z Position", isChinese), _localWeaponModelOffset.z, -0.5f, 0.5f);
			if (Mathf.Abs(WeaponModelYaw.Value - 10f) < 0.001f || Mathf.Abs(WeaponModelYaw.Value - 11.5f) < 0.001f || Mathf.Abs(WeaponModelYaw.Value - -4f) < 0.001f)
			{
				WeaponModelYaw.Value = _localWeaponModelEuler.y;
				SavePluginConfigQuietly();
			}
			if (Mathf.Abs(WeaponModelScale.Value - 2.8f) < 0.001f || Mathf.Abs(WeaponModelScale.Value - 2.55f) < 0.001f || Mathf.Abs(WeaponModelScale.Value - 0.8f) < 0.001f)
			{
				WeaponModelScale.Value = _localWeaponModelScale.x;
				SavePluginConfigQuietly();
			}
			if (Mathf.Abs(WeaponModelOffsetX.Value - -0.01f) < 0.001f && Mathf.Abs(WeaponModelOffsetY.Value - 0.01f) < 0.001f && Mathf.Abs(WeaponModelOffsetZ.Value) < 0.001f)
			{
				WeaponModelOffsetX.Value = _localWeaponModelOffset.x;
				WeaponModelOffsetY.Value = _localWeaponModelOffset.y;
				WeaponModelOffsetZ.Value = _localWeaponModelOffset.z;
				SavePluginConfigQuietly();
			}
			MaxZombies = BindRangedInt(configBindingSectionName3, GetConfigBindingKeyName("Max Count", isChinese), 2, 0, 30);
			ZombieSpawnCount = BindRangedInt(configBindingSectionName3, GetConfigBindingKeyName("Spawn Count", isChinese), 1, 0, 30);
			ZombieSpawnInterval = BindRangedFloat(configBindingSectionName3, GetConfigBindingKeyName("Spawn Interval", isChinese), 15f, 1f, 120f);
			ZombieMaxLifetime = BindRangedFloat(configBindingSectionName3, GetConfigBindingKeyName("Max Lifetime", isChinese), 120f, 10f, 600f);
			ZombieBehaviorDifficulty = BindSelectableString(configBindingSectionName3, GetConfigBindingKeyName("Behavior Difficulty", isChinese), "Easy", ZombieBehaviorDifficultyValues);
			ZombieKnockbackForce = BindRangedFloat(configBindingSectionName3, GetConfigBindingKeyName("Knockback Force", isChinese), 200f, 0f, 2000f);
			string text4 = NormalizeZombieBehaviorDifficultySelection(string.IsNullOrWhiteSpace(_loadedZombieBehaviorDifficultyMetadata) ? ZombieBehaviorDifficulty.Value : _loadedZombieBehaviorDifficultyMetadata);
			if (!string.Equals(ZombieBehaviorDifficulty.Value, text4, StringComparison.Ordinal))
			{
				ZombieBehaviorDifficulty.Value = text4;
			}
			ApplyZombieBehaviorDifficultyPreset(text4);
			ApplySimplifiedZombieDerivedValues();
			_lastZombieBehaviorDifficulty = text4;
			NormalizeConfigRanges();
			RemoveLegacyInventorySlotConfig();
			RemoveLegacyFogModeConfig();
			RemoveLegacyPlayerShotConfig();
			RemoveLegacyRecoilConfig();
			RefreshOwnedConfigEntryCache();
			SubscribeOwnedConfigEntryChanges();
			SavePluginConfigQuietly();
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			ReleaseRoomConfigCallbacks();
			UnsubscribeOwnedConfigEntryChanges();
			StopGameplayLoadoutBootstrap();
			StopOwnedModConfigStabilizer();
			CleanupLocalHeldDebugSphere();
			CleanupMuzzleFlashPool();
			CleanupRemoteGunshotAudioPool();
			CleanupDartImpactVfxPool();
			ClearRuntimePatchCaches();
			_lobbyConfigPanel?.Dispose();
			_lobbyConfigPanel = null;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			string sceneBucket = GetSceneBucket(scene);
			if (string.Equals(sceneBucket, "other", StringComparison.Ordinal) || string.Equals(sceneBucket, _activeSceneBucket, StringComparison.Ordinal))
			{
				return;
			}
			_activeSceneBucket = sceneBucket;
			BeginSceneRuntimeWarmup(scene);
			ClearRuntimePatchCaches();
			if (_scanCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_scanCoroutine);
				_scanCoroutine = null;
			}
			StopGameplayLoadoutBootstrap();
			ResetLoadoutGrantTracking(clearPersistentRecords: true);
			CleanupWeaponLobbyNotice();
			CleanupLocalWeaponVisual();
			CleanupLocalHeldDebugSphere();
			RequestAkVisualRefresh();
			_lastLocalizedModConfigUiFrame = -1;
			_localCharacter = null;
			_hasWeapon = false;
			_cachedHeldBlowgunItem = null;
			_lastHeldBlowgunSearchTime = -10f;
			_pendingRemoteWeaponGrant = false;
			_pendingRemoteFirstAidGrant = false;
			_lastPendingRemoteGrantAttemptTime = -10f;
			ZombieSpawner.StopZombieSpawning();
			ZombieSpawner.ClearZombies();
			bool flag = ((Scene)(ref scene)).name != null && ((Scene)(ref scene)).name.Contains("Airport");
			if (((Scene)(ref scene)).name != null && !((Scene)(ref scene)).name.Contains("Pretitle") && !((Scene)(ref scene)).name.Contains("Title") && !flag)
			{
				_resourcesLoaded = false;
				_scanCoroutine = ((MonoBehaviour)this).StartCoroutine(PeriodicPlayerScan());
				if (IsZombieSpawnFeatureEnabled())
				{
					ZombieSpawner.StartZombieSpawning();
				}
			}
			if (IsModConfigUiRuntimeSafeScene(scene))
			{
				((MonoBehaviour)this).StartCoroutine(RefreshLocalizedUiAfterStartup());
			}
		}

		private static void ClearRuntimePatchCaches()
		{
			InventoryItemUiPatch.ClearCaches();
			AkUiPatchHelpers.ClearRuntimeCaches();
			ZombieDeathPatch.ClearCaches();
		}

		private static void ResetLoadoutGrantTracking(bool clearPersistentRecords)
		{
			_receivedItem.Clear();
			_receivedFirstAid.Clear();
			if (clearPersistentRecords)
			{
				_persistentReceivedItem.Clear();
				_persistentReceivedFirstAid.Clear();
			}
			_pendingRemoteWeaponGrantActors.Clear();
			_pendingRemoteFirstAidGrantActors.Clear();
			_lastWeaponGrantTimeByActor.Clear();
			_lastFirstAidGrantTimeByActor.Clear();
			_weaponMissingSinceByActor.Clear();
			_recentWeaponDropTimeByActor.Clear();
		}

		private void StopGameplayLoadoutBootstrap()
		{
			if (_gameplayLoadoutBootstrapCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_gameplayLoadoutBootstrapCoroutine);
				_gameplayLoadoutBootstrapCoroutine = null;
			}
		}

		private void RestartGameplayLoadoutBootstrapIfNeeded()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			StopGameplayLoadoutBootstrap();
			if (IsGameplayScene(SceneManager.GetActiveScene()) && IsWeaponFeatureEnabled())
			{
				_gameplayLoadoutBootstrapCoroutine = ((MonoBehaviour)this).StartCoroutine(GameplayLoadoutBootstrapCoroutine());
			}
		}

		[IteratorStateMachine(typeof(<GameplayLoadoutBootstrapCoroutine>d__1087))]
		private IEnumerator GameplayLoadoutBootstrapCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GameplayLoadoutBootstrapCoroutine>d__1087(0)
			{
				<>4__this = this
			};
		}

		private void LoadResources()
		{
			if (_resourcesLoaded)
			{
				return;
			}
			try
			{
				ReplaceBlowgunSound();
				_resourcesLoaded = true;
			}
			catch (Exception)
			{
			}
		}

		private void CreateIconFromModel()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_004f: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: 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_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Expected O, but got Unknown
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_ak47Prefab == (Object)null)
			{
				return;
			}
			try
			{
				GameObject val = new GameObject("AK47IconCamera");
				Camera val2 = val.AddComponent<Camera>();
				val2.orthographic = false;
				val2.fieldOfView = 18f;
				val2.clearFlags = (CameraClearFlags)2;
				val2.backgroundColor = new Color(0f, 0f, 0f, 0f);
				val2.cullingMask = -1;
				val2.nearClipPlane = 0.01f;
				val2.farClipPlane = 100f;
				val2.allowHDR = false;
				val2.allowMSAA = true;
				val2.useOcclusionCulling = false;
				GameObject val3 = new GameObject("IconLight");
				val3.transform.SetParent(val.transform);
				val3.transform.localPosition = new Vector3(2.2f, 2.8f, -2.8f);
				Light obj = val3.AddComponent<Light>();
				obj.type = (LightType)1;
				obj.intensity = 2.1f;
				obj.color = Color.white;
				GameObject val4 = new GameObject("FillLight");
				val4.transform.SetParent(val.transform);
				val4.transform.localPosition = new Vector3(-2.1f, 1.4f, -2.2f);
				Light obj2 = val4.AddComponent<Light>();
				obj2.type = (LightType)1;
				obj2.intensity = 0.95f;
				obj2.color = Color.white;
				int num = 256;
				RenderTexture val5 = new RenderTexture(num, num, 24, (RenderTextureFormat)0);
				val5.antiAliasing = 2;
				val5.useMipMap = false;
				val5.autoGenerateMips = false;
				((Texture)val5).filterMode = (FilterMode)1;
				val5.Create();
				val2.targetTexture = val5;
				GameObject val6 = Object.Instantiate<GameObject>(_ak47Prefab);
				val6.transform.position = Vector3.zero;
				val6.transform.rotation = Quaternion.Euler(-5f, -90f, 0f);
				val6.transform.localScale = Vector3.one * 0.54f;
				ItemPatch.PrepareAkVisualRenderers(val6, null);
				if (TryGetAkIconBounds(val6, out var bounds))
				{
					Vector3 val7 = ((Bounds)(ref bounds)).center + new Vector3(0.04f, -0.02f, 0f);
					float num2 = Mathf.Max(new float[3]
					{
						((Bounds)(ref bounds)).extents.x,
						((Bounds)(ref bounds)).extents.y,
						((Bounds)(ref bounds)).extents.z
					});
					float num3 = Mathf.Max(1.8f, num2 / Mathf.Tan(val2.fieldOfView * 0.5f * ((float)Math.PI / 180f)) * 2.15f);
					val.transform.position = val7 - Vector3.forward * num3;
					val.transform.rotation = Quaternion.identity;
				}
				else
				{
					val.transform.position = new Vector3(0.03f, -0.02f, -2.4f);
					val.transform.rotation = Quaternion.identity;
				}
				RenderTexture.active = val5;
				GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
				RenderTexture.active = null;
				val2.Render();
				_ak47IconTexture = new Texture2D(num, num, (TextureFormat)4, false);
				((Object)_ak47IconTexture).name = "AK47_GeneratedIcon";
				((Texture)_ak47IconTexture).wrapMode = (TextureWrapMode)1;
				((Texture)_ak47IconTexture).filterMode = (FilterMode)1;
				RenderTexture.active = val5;
				_ak47IconTexture.ReadPixels(new Rect(0f, 0f, (float)num, (float)num), 0, 0);
				ForceTransparentBackground(_ak47IconTexture);
				_ak47IconTexture.Apply();
				RenderTexture.active = null;
				val2.targetTexture = null;
				val5.Release();
				Object.DestroyImmediate((Object)(object)val5);
				Object.DestroyImmediate((Object)(object)val6);
				Object.DestroyImmediate((Object)(object)val);
			}
			catch (Exception)
			{
			}
		}

		public static Texture2D GetAkIconTexture()
		{
			if ((Object)(object)_ak47IconTexture != (Object)null && !IsLikelyIconTexture(_ak47IconTexture))
			{
				_ak47IconTexture = null;
			}
			if ((Object)(object)_ak47IconTexture == (Object)null && _ak47ItemContent != null)
			{
				_ak47IconTexture = TryExtractIconFromItemContent(_ak47ItemContent);
			}
			if ((Object)(object)_ak47IconTexture != (Object)null && !_useExplicitSelectedWeaponIcon && !IsGeneratedModelIcon(_ak47IconTexture) && IsIconLikelyTooDark(_ak47IconTexture))
			{
				LogDiagnosticOnce("ak-icon-too-dark:" + DescribeTextureForDiagnostics(_ak47IconTexture), "AK icon rejected as too dark: " + DescribeTextureForDiagnostics(_ak47IconTexture));
				_ak47IconTexture = null;
			}
			if ((Object)(object)_ak47IconTexture == (Object)null)
			{
				Instance?.CreateIconFromModel();
				if ((Object)(object)_ak47IconTexture != (Object)null)
				{
					LogDiagnosticOnce("ak-icon-generated:" + DescribeTextureForDiagnostics(_ak47IconTexture), "CreateIconFromModel result: " + DescribeTextureForDiagnostics(_ak47IconTexture));
				}
			}
			if ((Object)(object)_ak47IconTexture != (Object)null && !_useExplicitSelectedWeaponIcon && !IsGeneratedModelIcon(_ak47IconTexture) && IsIconLikelyTooDark(_ak47IconTexture))
			{
				LogDiagnosticOnce("ak-icon-post-generate-too-dark:" + DescribeTextureForDiagnostics(_ak47IconTexture), "AK icon rejected after generation check: " + DescribeTextureForDiagnostics(_ak47IconTexture));
				_ak47IconTexture = null;
			}
			if ((Object)(object)_ak47IconTexture != (Object)null && !IsLikelyIconTexture(_ak47IconTexture))
			{
				LogDiagnosticOnce("ak-icon-invalid:" + DescribeTextureForDiagnostics(_ak47IconTexture), "AK icon rejected as invalid UI texture: " + DescribeTextureForDiagnostics(_ak47IconTexture));
				_ak47IconTexture = null;
			}
			if ((Object)(object)_ak47IconTexture == (Object)null)
			{
				LogDiagnosticOnce("ak-icon-fallback", "AK icon fell back to built-in placeholder icon");
				_ak47IconTexture = CreateFallbackIconTexture();
			}
			return _ak47IconTexture;
		}

		public static Texture2D GetAkIconTexture(string selection)
		{
			string text = NormalizeWeaponSelection(selection);
			if (TryGetResolvedWeaponIcon(text, out var icon) && (Object)(object)icon != (Object)null)
			{
				return icon;
			}
			if (string.Equals(text, GetCurrentWeaponSelection(), StringComparison.OrdinalIgnoreCase))
			{
				return GetAkIconTexture();
			}
			if ((Object)(object)_genericResolvedWeaponIcon != (Object)null)
			{
				return _genericResolvedWeaponIcon;
			}
			return GetAkIconTexture();
		}

		internal static void LogDiagnosticOnce(string key, string message)
		{
			try
			{
				if (!EnableDiagnosticLogs)
				{
					return;
				}
				if (string.IsNullOrWhiteSpace(key))
				{
					key = "diagnostic:" + message;
				}
				if (_diagnosticLogKeys.Add(key))
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogInfo((object)("[ShootZombies][Diag] " + message));
					}
				}
			}
			catch
			{
			}
		}

		internal static void LogDiagnostic(string message)
		{
			try
			{
				if (EnableDiagnosticLogs)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogInfo((object)("[ShootZombies][Diag] " + message));
					}
				}
			}
			catch
			{
			}
		}

		private static bool TryGetAkIconBounds(GameObject root, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			if ((Object)(object)root == (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			bool flag = false;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null) && val.enabled && !val.forceRenderingOff)
				{
					if (!flag)
					{
						bounds = val.bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(val.bounds);
					}
				}
			}
			return flag;
		}

		private static void ForceTransparentBackground(Texture2D texture)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				return;
			}
			try
			{
				Color32[] pixels = texture.GetPixels32();
				if (pixels == null || pixels.Length == 0)
				{
					return;
				}
				for (int i = 0; i < pixels.Length; i++)
				{
					if (pixels[i].a <= 10)
					{
						pixels[i] = new Color32((byte)0, (byte)0, (byte)0, (byte)0);
					}
				}
				texture.SetPixels32(pixels);
			}
			catch
			{
			}
		}

		internal static string DescribeAkVisualPrefabForDiagnostics()
		{
			return DescribeGameObjectForDiagnostics(_ak47Prefab);
		}

		internal static string DescribeAkVisualPrefabForDiagnostics(string selection)
		{
			return DescribeGameObjectForDiagnostics(GetAkVisualPrefab(selection));
		}

		private static bool IsGeneratedModelIcon(Texture2D texture)
		{
			if ((Object)(object)texture == (Object)null)
			{
				return false;
			}
			string text = ((Object)texture).name ?? string.Empty;
			if (!text.Equals("AK47_GeneratedIcon", StringComparison.Ordinal))
			{
				return text.Equals("AK47_FallbackIcon", StringComparison.Ordinal);
			}
			return true;
		}

		public static GameObject GetAkVisualPrefab()
		{
			return _ak47Prefab;
		}

		public static GameObject GetAkVisualPrefab(string selection)
		{
			if (TryGetResolvedWeaponPrefab(selection, out var prefab) && HasRenderableGeometry(prefab))
			{
				return prefab;
			}
			if (HasRenderableGeometry(_genericResolvedWeaponPrefab))
			{
				return _genericResolvedWeaponPrefab;
			}
			return _ak47Prefab;
		}

		public static bool HasAkVisualPrefab()
		{
			return HasRenderableGeometry(_ak47Prefab);
		}

		public static bool HasAkVisualPrefab(string selection)
		{
			return HasRenderableGeometry(GetAkVisualPrefab(selection));
		}

		internal static bool IsLocalWeaponVisualFollowerEnabled()
		{
			return EnableLocalWeaponVisualFollower;
		}

		internal static float GetWeaponModelYaw()
		{
			return Mathf.Clamp(WeaponModelYaw?.Value ?? _localWeaponModelEuler.y, -180f, 180f);
		}

		internal static float GetWeaponModelPitch()
		{
			return Mathf.Clamp(WeaponModelPitch?.Value ?? _localWeaponModelEuler.x, -180f, 180f);
		}

		internal static float GetWeaponModelRoll()
		{
			return Mathf.Clamp(WeaponModelRoll?.Value ?? _localWeaponModelEuler.z, -180f, 180f);
		}

		internal static float GetWeaponModelScale()
		{
			return Mathf.Clamp(WeaponModelScale?.Value ?? _localWeaponModelScale.x, 0.3f, 2f);
		}

		internal static float GetWeaponVariantScaleMultiplier(string selection)
		{
			return Mathf.Clamp(GetWeaponVariantDefinition(selection)?.ScaleMultiplier ?? 1f, 0.3f, 3f);
		}

		internal static Vector3 GetWeaponVariantPositionOffset(string selection)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return GetWeaponVariantDefinition(selection)?.PositionOffset ?? Vector3.zero;
		}

		internal static float GetEffectiveWeaponModelScale(string selection)
		{
			return Mathf.Clamp(GetWeaponModelScale() * GetWeaponVariantScaleMultiplier(selection), 0.3f, 6f);
		}

		internal static float GetWeaponModelOffsetX()
		{
			return Mathf.Clamp(WeaponModelOffsetX?.Value ?? _localWeaponModelOffset.x, -0.5f, 0.5f);
		}

		internal static float GetWeaponModelOffsetY()
		{
			return Mathf.Clamp(WeaponModelOffsetY?.Value ?? _localWeaponModelOffset.y, -0.5f, 0.5f);
		}

		internal static float GetWeaponModelOffsetZ()
		{
			return Mathf.Clamp(WeaponModelOffsetZ?.Value ?? _localWeaponModelOffset.z, -0.5f, 0.5f);
		}

		internal static Quaternion GetDirectAkRotationOverride()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.Euler(_weaponBaseEuler.x + GetWeaponModelPitch(), _weaponBaseEuler.y + GetWeaponModelYaw(), _weaponBaseEuler.z + GetWeaponModelRoll());
		}

		internal static Vector3 GetDirectAkPositionOverride(string selection)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(GetWeaponModelOffsetX(), GetWeaponModelOffsetY(), GetWeaponModelOffsetZ()) + GetWeaponVariantPositionOffset(selection);
		}

		internal static Vector3 GetDirectAkPositionOverride()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return GetDirectAkPositionOverride(GetCurrentWeaponSelection());
		}

		private static Vector3 GetConfiguredLocalWeaponModelEuler()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(_weaponBaseEuler.x + GetWeaponModelPitch(), _weaponBaseEuler.y + GetWeaponModelYaw(), _weaponBaseEuler.z + GetWeaponModelRoll());
		}

		private static Vector3 GetConfiguredLocalWeaponModelOffset()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetDirectAkPositionOverride();
		}

		private static bool HasRenderableGeometry(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			MeshFilter[] componentsInChildren = prefab.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.sharedMesh != (Object)null)
				{
					return true;
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = prefab.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMesh != (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		private static string FormatTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return "null";
			}
			List<string> list = new List<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private static string DescribeGameObjectForDiagnostics(GameObject root, int maxEntries = 6)
		{
			if ((Object)(object)root == (Object)null)
			{
				return "prefab=null";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("name=").Append(((Object)root).name);
			stringBuilder.Append(", counts=").Append(DescribeRenderableCounts(root));
			List<string> list = new List<string>();
			MeshFilter[] componentsInChildren = root.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sharedMesh == (Object)null))
				{
					MeshRenderer component = ((Component)val).GetComponent<MeshRenderer>();
					list.Add(string.Format("{0}|mesh={1}|verts={2}|renderer={3}", FormatTransformPath(((Component)val).transform), ((Object)val.sharedMesh).name, val.sharedMesh.vertexCount, ((Object)(object)component != (Object)null) ? ((Object)component).name : "none"));
					if (list.Count >= maxEntries)
					{
						break;
					}
				}
			}
			if (list.Count == 0)
			{
				SkinnedMeshRenderer[] componentsInChildren2 = root.GetComponentsInChildren<SkinnedMeshRenderer>(true);
				foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
				{
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.sharedMesh == (Object)null))
					{
						list.Add($"{FormatTransformPath(((Component)val2).transform)}|skinnedMesh={((Object)val2.sharedMesh).name}|verts={val2.sharedMesh.vertexCount}");
						if (list.Count >= maxEntries)
						{
							break;
						}
					}
				}
			}
			if (list.Count != 0)
			{
				stringBuilder.Append(", candidates=").Append(string.Join(" || ", list));
			}
			return stringBuilder.ToString();
		}

		private static string DescribeTextureForDiagnostics(Texture2D texture)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				return "null";
			}
			return $"name={((Object)texture).name}, size={((Texture)texture).width}x{((Texture)texture).height}, format={texture.format}, instance={((Object)texture).GetInstanceID()}";
		}

		private static bool IsIconLikelyTooDark(Texture2D texture)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				return false;
			}
			try
			{
				Color32[] pixels = texture.GetPixels32();
				if (pixels == null || pixels.Length == 0)
				{
					return false;
				}
				float num = 0f;
				int num2 = 0;
				int num3 = Mathf.Max(1, pixels.Length / 1024);
				for (int i = 0; i < pixels.Length; i += num3)
				{
					Color32 val = pixels[i];
					if (!((float)(int)val.a / 255f < 0.08f))
					{
						float num4 = (0.2126f * (float)(int)val.r + 0.7152f * (float)(int)val.g + 0.0722f * (float)(int)val.b) / 255f;
						num += num4;
						num2++;
					}
				}
				if (num2 < 8)
				{
					return false;
				}
				return num / (float)num2 < 0.08f;
			}
			catch
			{
				return false;
			}
		}

		private static Texture2D CreateFallbackIconTexture()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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)
			try
			{
				Texture2D val = new Texture2D(128, 128, (TextureFormat)5, false);
				((Object)val).name = "AK47_FallbackIcon";
				Color val2 = default(Color);
				((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
				Color val3 = default(Color);
				((Color)(ref val3))..ctor(0.94f, 0.94f, 0.94f, 1f);
				Color val4 = default(Color);
				((Color)(ref val4))..ctor(0.62f, 0.62f, 0.62f, 1f);
				Color[] array = (Color[])(object)new Color[16384];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = val2;
				}
				val.SetPixels(array);
				for (int j = 18; j < 104; j++)
				{
					for (int k = 58; k < 68; k++)
					{
						val.SetPixel(j, k, val3);
					}
				}
				for (int l = 76; l < 112; l++)
				{
					for (int m = 68; m < 80; m++)
					{
						val.SetPixel(l, m, val4);
					}
				}
				for (int n = 22; n < 40; n++)
				{
					for (int num = 44; num < 58; num++)
					{
						val.SetPixel(n, num, val3);
					}
				}
				for (int num2 = 52; num2 < 72; num2++)
				{
					for (int num3 = 68; num3 < 92; num3++)
					{
						if (num3 - 68 >= (num2 - 52) / 2)
						{
							val.SetPixel(num2, num3, val3);
						}
					}
				}
				for (int num4 = 92; num4 < 112; num4++)
				{
					for (int num5 = 54; num5 < 62; num5++)
					{
						val.SetPixel(num4, num5, val4);
					}
				}
				val.Apply();
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[ShootZombies] Using fallback icon texture");
				}
				return val;
			}
			catch
			{
				return null;
			}
		}

		private void ReplaceBlowgunModel()
		{
			if (IsRuntimeVisualRefreshBlocked() || (Object)(object)_ak47Prefab == (Object)null)
			{
				return;
			}
			try
			{
				if (TryResolveBaseWeaponItem(out var item))
				{
					ItemPatch.EnsureAkVisual(item, forceRefreshMarker: true);
					ItemPatch.EnsureAkVisualOnAllItems(forceRefresh: true);
				}
			}
			catch (Exception)
			{
			}
		}

		private void RefreshWeaponModelVisuals()
		{
			try
			{
				ApplyLocalWeaponModelPose();
				ReplaceBlowgunModel();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[ShootZombies] RefreshWeaponModelVisuals failed: " + ex.Message));
				}
			}
		}

		private void ReplaceBlowgunLocalization()
		{
			try
			{
				Type type = typeof(Item).Assembly.GetType("LocalizedText");
				if (type != null)
				{
					FieldInfo field = type.GetField("mainTable", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						object value = field.GetValue(null);
						if (value != null)
						{
							PropertyInfo property = value.GetType().GetProperty("Item");
							if (property != null)
							{
								List<string> list = new List<string>(15);
								for (int i = 0; i < 15; i++)
								{
									list.Add("AK-47");
								}
								property.SetValue(value, list, new object[1] { "NAME_AK" });
							}
						}
					}
				}
				if (_ak47ItemContent != null)
				{
					_ = (Object)(object)_ak47Prefab != (Object)null;
				}
			}
			catch (Exception)
			{
			}
		}

		private void ReplaceBlowgunInstances()
		{
			if ((Object)(object)_ak47Prefab == (Object)null)
			{
				Log.LogWarning((object)"[ShootZombies] AK47 prefab is null, cannot replace blowgun");
				return;
			}
			try
			{
				ItemPatch.EnsureAkVisualOnAllItems();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[ShootZombies] ReplaceBlowgunInstances error: " + ex));
			}
		}

		private void ReplaceBlowgunInstances_Old()
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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)
			if ((Object)(object)_ak47Prefab == (Object)null)
			{
				return;
			}
			try
			{
				Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
				int num = 0;
				Item[] array2 = array;
				foreach (Item val in array2)
				{
					if (_replacedBlowguns.Contains(((Component)val).gameObject))
					{
						continue;
					}
					string name = val.GetName();
					if (!ItemPatch.IsBlowgunLike(val, name))
					{
						continue;
					}
					MeshRenderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<MeshRenderer>();
					MeshRenderer[] array3 = componentsInChildren;
					foreach (MeshRenderer val2 in array3)
					{
						if (!((Object)val2).name.Contains("Hand"))
						{
							((Renderer)val2).enabled = false;
						}
					}
					SkinnedMeshRenderer[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<SkinnedMeshRenderer>();
					SkinnedMeshRenderer[] array4 = componentsInChildren2;
					foreach (SkinnedMeshRenderer val3 in array4)
					{
						if (!((Object)val3).name.Contains("Hand"))
						{
							((Renderer)val3).enabled = false;
						}
					}
					GameObject val4 = Object.Instantiate<GameObject>(_ak47Prefab, ((Component)val).transform);
					val4.transform.localPosition = Vector3.zero;
					val4.transform.localRotation = Quaternion.identity;
					val4.transform.localScale = Vector3.one;
					componentsInChildren = val4.GetComponentsInChildren<MeshRenderer>();
					for (int k = 0; k < componentsInChildren.Length; k++)
					{
						((Renderer)componentsInChildren[k]).enabled = true;
					}
					componentsInChildren2 = val4.GetComponentsInChildren<SkinnedMeshRenderer>();
					for (int l = 0; l < componentsInChildren2.Length; l++)
					{
						((Renderer)componentsInChildren2[l]).enabled = true;
					}
					_replacedBlowguns.Add(((Component)val).gameObject);
					num++;
				}
			}
			catch (Exception)
			{
			}
		}

		[IteratorStateMachine(typeof(<DelayedReplaceBlowgunModel>d__1130))]
		private static IEnumerator DelayedReplaceBlowgunModel()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedReplaceBlowgunModel>d__1130(0);
		}

		private static string NormalizeAkSoundSelection(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "ak_sound1";
			}
			string a = value.Trim();
			string[] akSoundSelectionValues = AkSoundSelectionValues;
			foreach (string text in akSoundSelectionValues)
			{
				if (string.Equals(a, text, StringComparison.OrdinalIgnoreCase))
				{
					return text;
				}
			}
			switch (NormalizeLookupToken(value))
			{
			case "1":
			case "aksound1":
			case "aksounds1":
			case "sound1":
			case "声音1":
			case "音效1":
				return "ak_sound1";
			case "2":
			case "aksound2":
			case "aksounds2":
			case "sound2":
			case "声音2":
			case "音效2":
				return "ak_sound2";
			case "3":
			case "aksound3":
			case "aksounds3":
			case "sound3":
			case "声音3":
			case "音效3":
				return "ak_sound3";
			default:
				if (!string.Equals(a, "默认", StringComparison.OrdinalIgnoreCase) && !string.Equals(a, "Default", StringComparison.OrdinalIgnoreCase))
				{
					string.Equals(a, "default", StringComparison.OrdinalIgnoreCase);
				}
				return "ak_sound1";
			}
		}

		private static string NormalizeZombieBehaviorDifficultySelection(string value)
		{
			string text = NormalizeLookupToken(value);
			if (string.IsNullOrEmpty(text))
			{
				return "Easy";
			}
			switch (text)
			{
			case "1":
			case "easy":
			case "simple":
			case "casual":
			case "简单":
			case "休闲":
				return "Easy";
			case "2":
			case "normal":
			case "默认":
			case "标准":
			case "standard":
				return "Standard";
			case "3":
			case "hard":
			case "困难":
				return "Hard";
			case "4":
			case "insane":
			case "brutal":
			case "疯狂":
			case "残酷":
				return "Insane";
			case "5":
			case "hell":
			case "地狱":
			case "噩梦":
			case "nightmare":
				return "Nightmare";
			default:
			{
				string[] zombieBehaviorDifficultyValues = ZombieBehaviorDifficultyValues;
				foreach (string text2 in zombieBehaviorDifficultyValues)
				{
					if (string.Equals(text, NormalizeLookupToken(text2), StringComparison.Ordinal))
					{
						return text2;
					}
				}
				return "Easy";
			}
			}
		}

		private static int GetZombieBehaviorDifficultyPresetIndex(string difficulty)
		{
			string value = NormalizeZombieBehaviorDifficultySelection(difficulty);
			int num = Array.IndexOf(ZombieBehaviorDifficultyValues, value);
			if (num >= 0)
			{
				return num;
			}
			return 1;
		}

		private static ZombieBehaviorDifficultyPreset GetZombieBehaviorDifficultyPreset(string difficulty)
		{
			int zombieBehaviorDifficultyPresetIndex = GetZombieBehaviorDifficultyPresetIndex(difficulty);
			return ZombieBehaviorDifficultyPresets[Mathf.Clamp(zombieBehaviorDifficultyPresetIndex, 0, ZombieBehaviorDifficultyPresets.Length - 1)];
		}

		private void ApplyZombieBehaviorDifficultyPreset(string difficulty = null)
		{
			if (ZombieBehaviorDifficulty != null)
			{
				string text = NormalizeZombieBehaviorDifficultySelection(difficulty ?? ZombieBehaviorDifficulty.Value);
				if (!string.Equals(ZombieBehaviorDifficulty.Value, text, StringComparison.Ordinal))
				{
					ZombieBehaviorDifficulty.Value = text;
				}
				DisableZombieSleepPatch.ResetRuntimeState();
				_pendingZombieSpeedRefresh = true;
				UpdateZombieSpeed(forceRefresh: true);
				ZombieSpawner.RefreshLiveZombieProperties();
			}
		}

		private void ApplySimplifiedZombieDerivedValues()
		{
			if (Application.isPlaying)
			{
				if (IsZombieSpawnFeatureEnabled())
				{
					ZombieSpawner.StartZombieSpawning();
				}
				else
				{
					ZombieSpawner.StopZombieSpawning();
				}
			}
		}

		private static float GetDerivedZombieSpawnIntervalRandomRange()
		{
			return Mathf.Clamp(Mathf.Max((ZombieSpawnInterval != null) ? ZombieSpawnInterval.Value : 15f, 1f) * 0.2f, 2f, 6f);
		}

		internal static float GetDerivedZombieSpawnIntervalRandomRangeRuntime()
		{
			return GetDerivedZombieSpawnIntervalRandomRange();
		}

		private static int GetDerivedZombieWaveMaxCount()
		{
			int num = Mathf.Max((MaxZombies != null) ? MaxZombies.Value : 2, 0);
			if (num <= 0)
			{
				return 0;
			}
			return Mathf.Clamp(Mathf.Max((ZombieSpawnCount == null) ? 1 : ZombieSpawnCount.Value, 0), 0, num);
		}

		private static int GetDerivedZombieWaveMinCount()
		{
			return 0;
		}

		internal static int GetDerivedZombieWaveSpawnCountRuntime()
		{
			int derivedZombieWaveMaxCount = GetDerivedZombieWaveMaxCount();
			if (derivedZombieWaveMaxCount <= 0)
			{
				return 0;
			}
			return derivedZombieWaveMaxCount;
		}

		private static float GetDerivedZombieSpawnRadius()
		{
			int num = Mathf.Max((MaxZombies != null) ? MaxZombies.Value : 2, 0);
			float num2 = NormalizeZombieBehaviorDifficultySelection((ZombieBehaviorDifficulty != null) ? ZombieBehaviorDifficulty.Value : "Easy") switch
			{
				"Easy" => 2.5f, 
				"Hard" => 0f, 
				"Insane" => -1.5f, 
				"Nightmare" => -3f, 
				_ => 1.5f, 
			};
			return Mathf.Clamp(12f + (float)Mathf.Max(num - 5, 0) * 0.45f + num2, 8f, 20f);
		}

		internal static float GetDerivedZombieSpawnRadiusRuntime()
		{
			return GetDerivedZombieSpawnRadius();
		}

		private static float GetDerivedZombieDestroyDistance()
		{
			int num = Mathf.Max((MaxZombies != null) ? MaxZombies.Value : 2, 0);
			float num2 = NormalizeZombieBehaviorDifficultySelection((ZombieBehaviorDifficulty != null) ? ZombieBehaviorDifficulty.Value : "Easy") switch
			{
				"Easy" => 0f, 
				"Hard" => 8f, 
				"Insane" => 12f, 
				"Nightmare" => 16f, 
				_ => 4f, 
			};
			return Mathf.Clamp(72f + (float)Mathf.Max(num - 5, 0) * 1.5f + num2, 72f, 130f);
		}

		internal static float GetDerivedZombieDestroyDistanceRuntime()
		{
			return GetDerivedZombieDestroyDistance();
		}

		private static ZombieBehaviorDifficultyPreset GetCurrentZombieBehaviorDifficultyPresetRuntime()
		{
			return GetZombieBehaviorDifficultyPreset((ZombieBehaviorDifficulty != null) ? ZombieBehaviorDifficulty.Value : "Easy");
		}

		internal static float GetZombieMoveSpeedMultiplierRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().MoveSpeedMultiplier, 0.1f, 5f);
		}

		internal static bool IsVanillaZombieBehaviorDifficultyRuntime()
		{
			return string.Equals(NormalizeZombieBehaviorDifficultySelection((ZombieBehaviorDifficulty != null) ? ZombieBehaviorDifficulty.Value : "Easy"), "Easy", StringComparison.Ordinal);
		}

		internal static float GetZombieKnockbackForceRuntime()
		{
			return Mathf.Clamp((ZombieKnockbackForce != null) ? ZombieKnockbackForce.Value : 200f, 0f, 2000f);
		}

		internal static float GetZombieTargetSearchIntervalRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().TargetSearchInterval, 0.1f, 10f);
		}

		internal static float GetZombieBiteRecoveryTimeRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().BiteRecoveryTime, 0f, 8f);
		}

		internal static float GetZombieSamePlayerBiteCooldownRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().SamePlayerBiteCooldown, 0.1f, 10f);
		}

		internal static float GetZombieSprintDistanceRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().SprintDistance, 1f, 50f);
		}

		internal static float GetZombieChaseTimeBeforeSprintRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().ChaseTimeBeforeSprint, 0f, 20f);
		}

		internal static float GetZombieLungeDistanceRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().LungeDistance, 4f, 20f);
		}

		internal static float GetZombieLungeTimeRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().LungeTime, 0.1f, 5f);
		}

		internal static float GetZombieLungeRecoveryTimeRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().LungeRecoveryTime, 0f, 10f);
		}

		internal static float GetZombieLookAngleBeforeWakeupRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().LookAngleBeforeWakeup, 0f, 180f);
		}

		internal static float GetZombieDistanceBeforeWakeupRuntime()
		{
			return Mathf.Clamp(GetCurrentZombieBehaviorDifficultyPresetRuntime().DistanceBeforeWakeup, 5f, 100f);
		}

		internal static string GetZombieBehaviorDifficultyDisplayNameRuntime(string difficulty)
		{
			bool flag = Instance?.GetCachedChineseLanguageSetting() ?? false;
			switch (NormalizeZombieBehaviorDifficultySelection(difficulty))
			{
			case "Easy":
				if (!flag)
				{
					return "Easy";
				}
				return "简单";
			case "Hard":
				if (!flag)
				{
					return "Hard";
				}
				return "困难";
			case "Insane":
				if (!flag)
				{
					return "Insane";
				}
				return "疯狂";
			case "Nightmare":
				if (!flag)
				{
					return "Nightmare";
				}
				return "噩梦";
			default:
				if (!flag)
				{
					return "Standard";
				}
				return "标准";
			}
		}

		internal static string GetZombieBehaviorDifficultyDetailsRuntime()
		{
			Plugin instance = Instance;
			if (instance == null || !instance.GetCachedChineseLanguageSetting())
			{
				return "Difficulty details:\nEasy: keeps vanilla lunge, bite recovery, and bite cadence, but spawned zombies still wake and pursue promptly so they do not stand idle for long periods.\nStandard: Move 1.05x; Search 6s; Post-bite 2.5s; Sprint 22m/2.25s; Lunge 10m/1.65s/4s.\nHard: Move 1.15x; Search 3s; Post-bite 1.5s; Sprint 26m/1.25s; Lunge 12m/1.85s/2.5s.\nInsane: Move 1.25x; Search 1.5s; Post-bite 0.9s; Sprint 30m/0.85s; Lunge 13m/2s/1.5s.\nNightmare: Move 1.35x; Search 0.75s; Post-bite 0.55s; Sprint 34m/0.65s; Lunge 14m/2.15s/0.85s.";
			}
			return "难度细节：\n简单：保留原版扑击、咬后恢复和咬人节奏，但对刷出的僵尸保持及时唤醒与追击，避免长时间站立。\n标准：移速 1.05x；索敌 6s；咬后 2.5s；冲刺 22m/2.25s；猛扑 10m/1.65s/4s。\n困难：移速 1.15x；索敌 3s；咬后 1.5s；冲刺 26m/1.25s；猛扑 12m/1.85s/2.5s。\n疯狂：移速 1.25x；索敌 1.5s；咬后 0.9s；冲刺 30m/0.85s；猛扑 13m/2s/1.5s。\n噩梦：移速 1.35x；索敌 0.75s；咬后 0.55s；冲刺 34m/0.65s；猛扑 14m/2.15s/0.85s。";
		}

		private static WeaponVariantDefinition GetWeaponVariantDefinition(string selection)
		{
			string b = NormalizeWeaponSelection(selection);
			WeaponVariantDefinition[] weaponVariantDefinitions = WeaponVariantDefinitions;
			foreach (WeaponVariantDefinition weaponVariantDefinition in weaponVariantDefinitions)
			{
				if (weaponVariantDefinition != null && string.Equals(weaponVariantDefinition.SelectionKey, b, StringComparison.OrdinalIgnoreCase))
				{
					return weaponVariantDefinition;
				}
			}
			return WeaponVariantDefinitions[0];
		}

		public static string GetWeaponDisplayName(string selection)
		{
			return GetWeaponVariantDefinition(selection)?.DisplayName ?? "AK47";
		}

		private static string NormalizeLookupToken(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
			}
			return stringBuilder.ToString();
		}

		private static bool MatchesWeaponAliasToken(string value, IEnumerable<string> aliases)
		{
			string text = NormalizeLookupToken(value);
			if (string.IsNullOrEmpty(text) || aliases == null)
			{
				return false;
			}
			foreach (string alias in aliases)
			{
				string text2 = NormalizeLookupToken(alias);
				if (!string.IsNullOrEmpty(text2) && (string.Equals(text, text2, StringComparison.Ordinal) || text.StartsWith(text2, StringComparison.Ordinal) || (text2.Length >= 4 && text.IndexOf(text2, StringComparison.Ordinal) >= 0)))
				{
					return true;
				}
			}
			return false;
		}

		internal static string NormalizeWeaponSelection(string value)
		{
			string text = NormalizeLookupToken(value);
			if (string.IsNullOrEmpty(text))
			{
				return "AK47";
			}
			switch (text)
			{
			case "ak":
			case "ak47":
				return "AK47";
			case "mpx":
				return "MPX";
			case "hk416":
			case "hk417":
				return "HK416";
			default:
			{
				WeaponVariantDefinition[] weaponVariantDefinitions = WeaponVariantDefinitions;
				foreach (WeaponVariantDefinition weaponVariantDefinition in weaponVariantDefinitions)
				{
					if (weaponVariantDefinition != null && (MatchesWeaponAliasToken(text, weaponVariantDefinition.PrefabAliases) || MatchesWeaponAliasToken(text, weaponVariantDefinition.IconAliases) || string.Equals(text, NormalizeLookupToken(weaponVariantDefinition.SelectionKey), StringComparison.Ordinal)))
					{
						return weaponVariantDefinition.SelectionKey;
					}
				}
				return "AK47";
			}
			}
		}

		public static string GetCurrentWeaponSelection()
		{
			return NormalizeWeaponSelection(WeaponSelection?.Value);
		}

		public static string GetCurrentAkSoundSelection()
		{
			return NormalizeAkSoundSelection(AkSoundSelection?.Value);
		}

		public static string GetCurrentWeaponDisplayName()
		{
			return GetWeaponDisplayName(GetCurrentWeaponSelection());
		}

		private static bool TryGetLocalPlayerWeaponSelectionOverride(int actorNr, out string selection)
		{
			selection = null;
			Player localPlayer = PhotonNetwork.LocalPlayer;
			if (actorNr <= 0 || localPlayer == null || localPlayer.ActorNumber != actorNr)
			{
				return false;
			}
			selection = GetCurrentWeaponSelection();
			_playerWeaponSelectionsByActor[actorNr] = selection;
			return true;
		}

		private static bool TryGetLocalPlayerAkSoundSelectionOverride(int actorNr, out string selection)
		{
			selection = null;
			Player localPlayer = PhotonNetwork.LocalPlayer;
			if (actorNr <= 0 || localPlayer == null || localPlayer.ActorNumber != actorNr)
			{
				return false;
			}
			selection = GetCurrentAkSoundSelection();
			_playerAkSoundSelectionsByActor[actorNr] = selection;
			return true;
		}

		internal static string GetWeaponSelectionForActor(int actorNr)
		{
			if (TryGetLocalPlayerWeaponSelectionOverride(actorNr, out var selection))
			{
				return selection;
			}
			if (actorNr > 0 && _playerWeaponSelectionsByActor.TryGetValue(actorNr, out var value))
			{
				return NormalizeWeaponSelection(value);
			}
			if (PhotonNetwork.InRoom)
			{
				Player val = PhotonNetwork.PlayerList?.FirstOrDefault((Func<Player, bool>)((Player candidate) => candidate != null && candidate.ActorNumber == actorNr));
				if (val != null)
				{
					return GetWeaponSelectionForPlayer(val);
				}
			}
			return GetCurrentWeaponSelection();
		}

		internal static string GetAkSoundSelectionForActor(int actorNr)
		{
			if (TryGetLocalPlayerAkSoundSelectionOverride(actorNr, out var selection))
			{
				return selection;
			}
			if (actorNr > 0 && _playerAkSoundSelectionsByActor.TryGetValue(actorNr, out var value))
			{
				return NormalizeAkSoundSelection(value);
			}
			if (PhotonNetwork.InRoom)
			{
				Player val = PhotonNetwork.PlayerList?.FirstOrDefault((Func<Player, bool>)((Player candidate) => candidate != null && candidate.ActorNumber == actorNr));
				if (val != null)
				{
					return GetAkSoundSelectionForPlayer(val);
				}
			}
			return GetCurrentAkSoundSelection();
		}

		internal static string GetWeaponSelectionForPlayer(Player player)
		{
			if (player == null)
			{
				return GetCurrentWeaponSelection();
			}
			if (TryGetLocalPlayerWeaponSelectionOverride(player.ActorNumber, out var selection))
			{
				return selection;
			}
			string text = NormalizeWeaponSelection(((player.CustomProperties != null) ? player.CustomProperties[(object)"sz.weapon"] : null) as string);
			if (player.ActorNumber > 0)
			{
				_playerWeaponSelectionsByActor[player.ActorNumber] = text;
			}
			return text;
		}

		internal static string GetAkSoundSelectionForPlayer(Player player)
		{
			if (player == null)
			{
				return GetCurrentAkSoundSelection();
			}
			if (TryGetLocalPlayerAkSoundSelectionOverride(player.ActorNumber, out var selection))
			{
				return selection;
			}
			string text = NormalizeAkSoundSelection(((player.CustomProperties != null) ? player.CustomProperties[(object)"sz.sound"] : null) as string);
			if (player.ActorNumber > 0)
			{
				_playerAkSoundSelectionsByActor[player.ActorNumber] = text;
			}
			return text;
		}

		internal static string GetWeaponSelectionForCharacter(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return GetCurrentWeaponSelection();
			}
			PhotonView val = character.refs?.view;
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)character).GetComponent<PhotonView>() ?? ((Component)character).GetComponentInParent<PhotonView>();
			}
			if ((Object)(object)val != (Object)null && val.OwnerActorNr > 0)
			{
				return GetWeaponSelectionForActor(val.OwnerActorNr);
			}
			_ = (Object)(object)character == (Object)(object)Character.localCharacter;
			return GetCurrentWeaponSelection();
		}

		internal static string GetWeaponSelectionForItem(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return GetCurrentWeaponSelection();
			}
			Character val = (((Object)(object)item.trueHolderCharacter != (Object)null) ? item.trueHolderCharacter : item.holderCharacter);
			if ((Object)(object)val != (Object)null)
			{
				return GetWeaponSelectionForCharacter(val);
			}
			PhotonView val2 = ((Component)item).GetComponent<PhotonView>() ?? ((Component)item).GetComponentInParent<PhotonView>();
			if ((Object)(object)val2 != (Object)null)
			{
				int num = ((val2.OwnerActorNr > 0) ? val2.OwnerActorNr : val2.CreatorActorNr);
				if (num > 0)
				{
					return GetWeaponSelectionForActor(num);
				}
			}
			return GetCurrentWeaponSelection();
		}

		internal static string GetItemWeaponDisplayName(Item item)
		{
			return GetWeaponDisplayName(GetWeaponSelectionForItem(item));
		}

		private static void ApplySelectedWeaponAssets()
		{
			string currentWeaponSelection = GetCurrentWeaponSelection();
			GameObject prefab = null;
			Texture2D icon = null;
			bool useExplicitSelectedWeaponIcon = false;
			if (!TryGetResolvedWeaponPrefab(currentWeaponSelection, out prefab))
			{
				TryGetResolvedWeaponPrefab("AK47", out prefab);
			}
			if (!HasRenderableGeometry(prefab))
			{
				prefab = (HasRenderableGeometry(_genericResolvedWeaponPrefab) ? _genericResolvedWeaponPrefab : null);
			}
			if (TryGetResolvedWeaponIcon(currentWeaponSelection, out icon) || TryGetResolvedWeaponIcon("AK47", out icon))
			{
				useExplicitSelectedWeaponIcon = (Object)(object)icon != (Object)null;
			}
			if ((Object)(object)icon == (Object)null)
			{
				icon = _genericResolvedWeaponIcon;
			}
			_ak47Prefab = prefab;
			_ak47IconTexture = icon;
			_useExplicitSelectedWeaponIcon = useExplicitSelectedWeaponIcon;
		}

		private static bool TryGetResolvedWeaponPrefab(string selection, out GameObject prefab)
		{
			prefab = null;
			string key = NormalizeWeaponSelection(selection);
			if (_resolvedWeaponPrefabs.TryGetValue(key, out prefab) && HasRenderableGeometry(prefab))
			{
				return true;
			}
			prefab = null;
			return false;
		}

		private static bool TryGetResolvedWeaponIcon(string selection, out Texture2D icon)
		{
			icon = null;
			string key = NormalizeWeaponSelection(selection);
			if (_resolvedWeaponIcons.TryGetValue(key, out icon) && (Object)(object)icon != (Object)null)
			{
				return true;
			}
			icon = null;
			return false;
		}

		private static void CaptureGenericResolvedWeaponAssets()
		{
			_genericResolvedWeaponPrefab = (HasRenderableGeometry(_ak47Prefab) ? _ak47Prefab : null);
			_genericResolvedWeaponIcon = _ak47IconTexture;
		}

		private static void TryResolveSelectableWeaponAssets(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return;
			}
			GameObject[] prefabs = bundle.LoadAllAssets<GameObject>() ?? Array.Empty<GameObject>();
			Texture2D[] textures = bundle.LoadAllAssets<Texture2D>() ?? Array.Empty<Texture2D>();
			WeaponVariantDefinition[] weaponVariantDefinitions = WeaponVariantDefinitions;
			foreach (WeaponVariantDefinition weaponVariantDefinition in weaponVariantDefinitions)
			{
				if (weaponVariantDefinition == null || string.IsNullOrWhiteSpace(weaponVariantDefinition.SelectionKey))
				{
					continue;
				}
				GameObject val = FindMatchingWeaponPrefabCandidate(prefabs, weaponVariantDefinition);
				if ((Object)(object)val != (Object)null)
				{
					GameObject val2 = CreateRuntimeWeaponPrefabClone(val, weaponVariantDefinition.SelectionKey);
					if ((Object)(object)val2 != (Object)null)
					{
						_resolvedWeaponPrefabs[weaponVariantDefinition.SelectionKey] = val2;
					}
				}
				Texture2D val3 = FindBestMatchingWeaponIcon(bundle, textures, weaponVariantDefinition);
				if ((Object)(object)val3 != (Object)null)
				{
					_resolvedWeaponIcons[weaponVariantDefinition.SelectionKey] = val3;
				}
			}
		}

		private static GameObject FindMatchingWeaponPrefabCandidate(IEnumerable<GameObject> prefabs, WeaponVariantDefinition definition)
		{
			if (prefabs == null || definition == null)
			{
				return null;
			}
			foreach (GameObject prefab in prefabs)
			{
				GameObject val = FindMatchingWeaponChildPrefab(prefab, definition.PrefabAliases, directChildrenOnly: true);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			foreach (GameObject prefab2 in prefabs)
			{
				GameObject val2 = FindMatchingWeaponChildPrefab(prefab2, definition.PrefabAliases, directChildrenOnly: false);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			foreach (GameObject prefab3 in prefabs)
			{
				if ((Object)(object)prefab3 != (Object)null && HasRenderableGeometry(prefab3) && MatchesWeaponAliasToken(((Object)prefab3).name, definition.PrefabAliases))
				{
					return prefab3;
				}
			}
			return null;
		}

		private static GameObject FindMatchingWeaponChildPrefab(GameObject root, IEnumerable<string> aliases, bool directChildrenOnly)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			GameObject result = null;
			int bestScore = int.MinValue;
			if (directChildrenOnly)
			{
				for (int i = 0; i < root.transform.childCount; i++)
				{
					Transform child = root.transform.GetChild(i);
					if ((Object)(object)child != (Object)null)
					{
						EvaluateWeaponPrefabCandidate(((Component)child).gameObject, aliases, ref result, ref bestScore);
					}
				}
				return result;
			}
			Transform[] componentsInChildren = root.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)root.transform))
				{
					EvaluateWeaponPrefabCandidate(((Component)val).gameObject, aliases, ref result, ref bestScore);
				}
			}
			return result;
		}

		private static void EvaluateWeaponPrefabCandidate(GameObject candidate, IEnumerable<string> aliases, ref GameObject result, ref int bestScore)
		{
			if (!((Object)(object)candidate == (Object)null) && HasRenderableGeometry(candidate) && MatchesWeaponAliasToken(((Object)candidate).name, aliases))
			{
				int weaponPrefabCandidateScore = GetWeaponPrefabCandidateScore(candidate);
				if (weaponPrefabCandidateScore > bestScore)
				{
					bestScore = weaponPrefabCandidateScore;
					result = candidate;
				}
			}
		}

		private static int GetWeaponPrefabCandidateScore(GameObject candidate)
		{
			if ((Object)(object)candidate == (Object)null)
			{
				return int.MinValue;
			}
			int num = Mathf.Clamp(candidate.transform.childCount * 1200, 0, 12000);
			MeshFilter[] componentsInChildren = candidate.GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sharedMesh == (Object)null))
				{
					num += 1200;
					num += Mathf.Clamp(val.sharedMesh.vertexCount / 2, 0, 24000);
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = candidate.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && (Object)(object)val2.sharedMesh != (Object)null)
				{
					num += 1400;
					num += Mathf.Clamp(val2.sharedMesh.vertexCount / 2, 0, 24000);
				}
			}
			return num;
		}

		private static GameObject CreateRuntimeWeaponPrefabClone(GameObject source, string selectionKey)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			if ((Object)(object)source == (Object)null || !HasRenderableGeometry(source))
			{
				return null;
			}
			GameObject val = null;
			Transform transform = source.transform;
			if ((Object)(object)transform.parent != (Object)null)
			{
				Transform root = transform.root;
				if ((Object)(object)root == (Object)null)
				{
					return null;
				}
				if (!TryBuildRelativeChildIndexPath(root, transform, out var siblingIndexPath))
				{
					return null;
				}
				GameObject val2 = Object.Instantiate<GameObject>(((Component)root).gameObject);
				if ((Object)(object)val2 == (Object)null)
				{
					return null;
				}
				Transform val3 = ResolveChildByIndexPath(val2.transform, siblingIndexPath);
				if ((Object)(object)val3 == (Object)null || !HasRenderableGeometry(((Component)val3).gameObject))
				{
					Object.Destroy((Object)val2);
					return null;
				}
				GameObject val4 = new GameObject(selectionKey + "_RuntimeRoot");
				val3.SetParent(val4.transform, true);
				Object.Destroy((Object)val2);
				val = val4;
			}
			else
			{
				val = Object.Instantiate<GameObject>(source);
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			val.transform.SetParent((Transform)null, false);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			NormalizeRuntimeWeaponPrefabClone(val);
			val.SetActive(false);
			((Object)val).hideFlags = (HideFlags)61;
			((Object)val).name = selectionKey + "_RuntimePrefab";
			Object.DontDestroyOnLoad((Object)(object)val);
			_runtimeWeaponPrefabClones.Add(val);
			return val;
		}

		private static bool TryBuildRelativeChildIndexPath(Transform root, Transform descendant, out List<int> siblingIndexPath)
		{
			siblingIndexPath = null;
			if ((Object)(object)root == (Object)null || (Object)(object)descendant == (Object)null)
			{
				return false;
			}
			List<int> list = new List<int>();
			Transform val = descendant;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Add(val.GetSiblingIndex());
				val = val.parent;
			}
			if ((Object)(object)val != (Object)(object)root)
			{
				return false;
			}
			list.Reverse();
			siblingIndexPath = list;
			return true;
		}

		private static Transform ResolveChildByIndexPath(Transform root, IReadOnlyList<int> siblingIndexPath)
		{
			if ((Object)(object)root == (Object)null || siblingIndexPath == null)
			{
				return null;
			}
			Transform val = root;
			for (int i = 0; i < siblingIndexPath.Count; i++)
			{
				int num = siblingIndexPath[i];
				if (num < 0 || num >= val.childCount)
				{
					return null;
				}
				val = val.GetChild(num);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
			}
			return val;
		}

		private static void NormalizeRuntimeWeaponPrefabClone(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					ItemPatch.NormalizeAkRenderer(val);
				}
			}
		}

		private static Texture2D FindBestMatchingWeaponIcon(AssetBundle bundle, IEnumerable<Texture2D> textures, WeaponVariantDefinition definition)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if (textures == null || definition == null)
			{
				return null;
			}
			Texture2D result = null;
			int num = int.MinValue;
			foreach (Texture2D texture in textures)
			{
				if ((Object)(object)texture == (Object)null)
				{
					continue;
				}
				string name = ((Object)texture).name;
				string value = FindAssetNameForObject(bundle, (Object)texture);
				int num2 = int.MinValue;
				if (MatchesWeaponAliasToken(name, definition.IconAliases))
				{
					num2 = 100000;
				}
				else if (MatchesWeaponAliasToken(value, definition.IconAliases))
				{
					num2 = 96000;
				}
				else if (NormalizeLookupToken(name).IndexOf("icon", StringComparison.Ordinal) >= 0 && MatchesWeaponAliasToken(name, definition.PrefabAliases))
				{
					num2 = 92000;
				}
				else if (NormalizeLookupToken(value).IndexOf("icon", StringComparison.Ordinal) >= 0 && MatchesWeaponAliasToken(value, definition.PrefabAliases))
				{
					num2 = 90000;
				}
				else if (IsLikelyIconTexture(texture) && MatchesWeaponAliasToken(name, definition.PrefabAliases))
				{
					num2 = 86000;
				}
				else if (IsLikelyIconTexture(texture) && MatchesWeaponAliasToken(value, definition.PrefabAliases))
				{
					num2 = 84000;
				}
				if (num2 != int.MinValue)
				{
					if (IsLikelyIconTexture(texture))
					{
						num2 += 2000;
					}
					num2 += Mathf.Clamp(((Texture)texture).width * ((Texture)texture).height / 256, 0, 12000);
					if (num2 > num)
					{
						num = num2;
						result = texture;
					}
				}
			}
			return result;
		}

		private void OnAkSoundSelectionChanged()
		{
			if (AkSoundSelection != null)
			{
				string text = NormalizeAkSoundSelection(AkSoundSelection.Value);
				if (!string.Equals(AkSoundSelection.Value, text, StringComparison.Ordinal))
				{
					AkSoundSelection.Value = text;
					SavePluginConfigQuietly();
				}
				else
				{
					SavePluginConfigQuietly();
					ApplySelectedGunshotSound();
					PublishLocalAkSoundSelectionToPlayerProperties(force: true);
				}
			}
		}

		private void SavePluginConfigQuietly()
		{
			try
			{
				((BaseUnityPlugin)this).Config.Save();
			}
			catch
			{
			}
		}

		internal void SaveOwnedConfigRuntime()
		{
			SavePluginConfigQuietly();
		}

		private void ApplySelectedGunshotSound()
		{
			try
			{
				string text = (_currentGunshotSoundSelection = NormalizeAkSoundSelection(AkSoundSelection?.Value));
				if (_gunshotSoundLoadCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_gunshotSoundLoadCoroutine);
					_gunshotSoundLoadCoroutine = null;
				}
				if (_externalGunshotSounds.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
				{
					SetGunshotSoundClip(value, text, isExternal: true);
					return;
				}
				string externalAkSoundPath = GetExternalAkSoundPath(text);
				if (string.IsNullOrWhiteSpace(externalAkSoundPath) || !File.Exists(externalAkSoundPath))
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)("[ShootZombies] Missing external AK sound for selection '" + text + "'"));
					}
					string text2 = FindFallbackAkSoundSelection(text);
					if (!string.IsNullOrWhiteSpace(text2) && !string.Equals(text2, text, StringComparison.Ordinal))
					{
						if (AkSoundSelection != null && !string.Equals(AkSoundSelection.Value, text2, StringComparison.Ordinal))
						{
							AkSoundSelection.Value = text2;
							return;
						}
						_currentGunshotSoundSelection = text2;
						ApplySelectedGunshotSound();
					}
					else
					{
						_gunshotSound = null;
						if ((Object)(object)_sharedAudioSource != (Object)null)
						{
							_sharedAudioSource.clip = null;
						}
					}
				}
				else
				{
					_gunshotSoundLoadCoroutine = ((MonoBehaviour)this).StartCoroutine(LoadAudioClipFromFile(text, externalAkSoundPath));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[ShootZombies] ApplySelectedGunshotSound failed: " + ex.Message));
				}
			}
		}

		private void SetGunshotSoundClip(AudioClip clip, string selection, bool isExternal)
		{
			if (!((Object)(object)clip == (Object)null))
			{
				_currentGunshotSoundSelection = NormalizeAkSoundSelection(selection);
				_gunshotSound = clip;
				if ((Object)(object)_sharedAudioSource != (Object)null)
				{
					_sharedAudioSource.clip = clip;
				}
				ReplaceBlowgunSoundInternal();
			}
		}

		private static AudioType GetAudioTypeForPath(string filePath)
		{
			return (AudioType)((Path.GetExtension(filePath) ?? string.Empty).ToLowerInvariant() switch
			{
				".wav" => 20, 
				".ogg" => 14, 
				".mp3" => 13, 
				_ => 0, 
			});
		}

		[IteratorStateMachine(typeof(<EnumerateAkSoundDirectories>d__1199))]
		private static IEnumerable<string> EnumerateAkSoundDirectories()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateAkSoundDirectories>d__1199(-2);
		}

		private static string GetExternalAkSoundPath(string selection)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(selection);
			string[] array = new string[3] { ".wav", ".mp3", ".ogg" };
			foreach (string item in EnumerateAkSoundDirectories())
			{
				if (string.IsNullOrWhiteSpace(item))
				{
					continue;
				}
				string[] array2 = array;
				foreach (string text in array2)
				{
					string text2 = Path.Combine(item, fileNameWithoutExtension + text);
					if (File.Exists(text2))
					{
						return text2;
					}
				}
			}
			return null;
		}

		[IteratorStateMachine(typeof(<LoadAudioClipFromFile>d__1201))]
		private IEnumerator LoadAudioClipFromFile(string selection, string filePath)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAudioClipFromFile>d__1201(0)
			{
				<>4__this = this,
				selection = selection,
				filePath = filePath
			};
		}

		private void ReplaceBlowgunSound()
		{
			try
			{
				ApplySelectedGunshotSound();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[ShootZombies] ReplaceBlowgunSound error: " + ex));
			}
		}

		private void ReplaceBlowgunSoundInternal()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			try
			{
				if ((Object)(object)_gunshotSound == (Object)null)
				{
					return;
				}
				if (TryResolveBaseWeaponItem(out var item))
				{
					Type type = ((object)item).GetType();
					FieldInfo field = type.GetField("prefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field == null)
					{
						field = type.GetField("_prefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					}
					if (field != null && (Object)(object)_gunshotSound != (Object)null)
					{
						object value = field.GetValue(item);
						GameObject val = (GameObject)((value is GameObject) ? value : null);
						if ((Object)(object)val != (Object)null)
						{
							AudioSource[] componentsInChildren = val.GetComponentsInChildren<AudioSource>(true);
							foreach (AudioSource val2 in componentsInChildren)
							{
								if ((Object)(object)val2.clip != (Object)null)
								{
									val2.clip = _gunshotSound;
								}
							}
						}
					}
				}
				Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
				foreach (Item val3 in array)
				{
					string name = val3.GetName();
					if (!ItemPatch.IsBlowgunLike(val3, name))
					{
						continue;
					}
					AudioSource[] componentsInChildren = ((Component)val3).GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val4 in componentsInChildren)
					{
						if ((Object)(object)val4.clip != (Object)null && (Object)(object)_gunshotSound != (Object)null)
						{
							val4.clip = _gunshotSound;
						}
					}
					FieldInfo[] fields = ((object)val3).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (FieldInfo fieldInfo in fields)
					{
						if (!(fieldInfo.FieldType == typeof(AudioClip)) && !fieldInfo.Name.ToLower().Contains("sound") && !fieldInfo.Name.ToLower().Contains("audio") && !fieldInfo.Name.ToLower().Contains("sfx"))
						{
							continue;
						}
						try
						{
							if (fieldInfo.GetValue(val3) is AudioClip && (Object)(object)_gunshotSound != (Object)null)
							{
								fieldInfo.SetValue(val3, _gunshotSound);
							}
						}
						catch (Exception)
						{
						}
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static bool TryResolveBaseWeaponItem(out Item item)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			item = null;
			if (TryGetItemById(70, out item))
			{
				return true;
			}
			int num = 0;
			try
			{
				Object[] array = Resources.FindObjectsOfTypeAll(typeof(Object));
				foreach (Object val in array)
				{
					if (val == (Object)null || ((object)val).GetType().Name != "ItemDatabase" || !(((object)val).GetType().GetField("itemLookup", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val) is IDictionary dictionary))
					{
						continue;
					}
					foreach (DictionaryEntry item2 in dictionary)
					{
						object value = item2.Value;
						Item val2 = (Item)((value is Item) ? value : null);
						int num2 = ScoreBaseWeaponItem(val2);
						if (num2 > num)
						{
							num = num2;
							item = val2;
						}
					}
					break;
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TryResolveBaseWeaponItem database scan failed: " + ex.Message));
			}
			if ((Object)(object)item == (Object)null)
			{
				try
				{
					Item[] array2 = Resources.FindObjectsOfTypeAll<Item>();
					foreach (Item val3 in array2)
					{
						int num3 = ScoreBaseWeaponItem(val3);
						if (num3 > num)
						{
							num = num3;
							item = val3;
						}
					}
				}
				catch (Exception ex2)
				{
					Log.LogWarning((object)("[ShootZombies] TryResolveBaseWeaponItem resource scan failed: " + ex2.Message));
				}
			}
			return (Object)(object)item != (Object)null;
		}

		private static bool TryGetItemById(ushort id, out Item item)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			item = null;
			try
			{
				MethodInfo method = typeof(ItemDatabase).GetMethod("TryGetItem", BindingFlags.Static | BindingFlags.Public);
				if (method == null)
				{
					return false;
				}
				object[] array = new object[2] { id, null };
				object obj = method.Invoke(null, array);
				if (!(obj is bool) || !(bool)obj)
				{
					return false;
				}
				object obj2 = array[1];
				item = (Item)((obj2 is Item) ? obj2 : null);
				return (Object)(object)item != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		internal static void CaptureWeaponItemUiDisplayState(ItemUIData uiData)
		{
			if (uiData != null && (!_weaponItemUiInteractionStateByData.TryGetValue(uiData, out var value) || !value.HasDisplayState))
			{
				WeaponItemUiInteractionState weaponItemUiInteractionState2;
				if (!_weaponItemUiInteractionStateByData.TryGetValue(uiData, out value))
				{
					WeaponItemUiInteractionState weaponItemUiInteractionState = default(WeaponItemUiInteractionState);
					weaponItemUiInteractionState.CanDrop = uiData.canDrop;
					weaponItemUiInteractionState.CanThrow = uiData.canThrow;
					weaponItemUiInteractionState.CanBackpack = uiData.canBackpack;
					weaponItemUiInteractionState2 = weaponItemUiInteractionState;
				}
				else
				{
					weaponItemUiInteractionState2 = value;
				}
				value = weaponItemUiInteractionState2;
				value.HasDisplayState = true;
				value.ItemName = uiData.itemName;
				value.Icon = uiData.icon;
				value.AltIcon = uiData.altIcon;
				_weaponItemUiInteractionStateByData[uiData] = value;
			}
		}

		internal static bool TryProtectWeaponItemRuntime(Item item)
		{
			if (!IsWeaponFeatureEnabled() || (Object)(object)item == (Object)null || !ItemPatch.IsBlowgunLike(item))
			{
				return false;
			}
			ApplyWeaponItemInteractionRestrictions(item.UIData);
			if ((Object)(object)item.isSecretlyOtherItemPrefab != (Object)null)
			{
				ApplyWeaponItemInteractionRestrictions(item.isSecretlyOtherItemPrefab.UIData);
			}
			return true;
		}

		internal static void ApplyWeaponItemInteractionRestrictions(ItemUIData uiData)
		{
			if (uiData != null)
			{
				if (!_weaponItemUiInteractionStateByData.ContainsKey(uiData))
				{
					_weaponItemUiInteractionStateByData[uiData] = new WeaponItemUiInteractionState
					{
						CanDrop = uiData.canDrop,
						CanThrow = uiData.canThrow,
						CanBackpack = uiData.canBackpack
					};
				}
				uiData.canDrop = false;
				uiData.canThrow = false;
				uiData.canBackpack = false;
			}
		}

		private static void RestoreWeaponItemInteractionRestrictions(ItemUIData uiData)
		{
			if (uiData == null)
			{
				return;
			}
			if (_weaponItemUiInteractionStateByData.TryGetValue(uiData, out var value))
			{
				if (value.HasDisplayState)
				{
					uiData.itemName = value.ItemName;
					uiData.icon = value.Icon;
					uiData.altIcon = value.AltIcon;
				}
				uiData.canDrop = value.CanDrop;
				uiData.canThrow = value.CanThrow;
				uiData.canBackpack = value.CanBackpack;
			}
			else
			{
				uiData.canDrop = true;
				uiData.canThrow = true;
				uiData.canBackpack = true;
			}
		}

		internal static void RestoreWeaponItemInteractionRestrictionsOnAllBlowguns()
		{
			try
			{
				Item[] array = Resources.FindObjectsOfTypeAll<Item>();
				foreach (Item val in array)
				{
					if (!((Object)(object)val == (Object)null) && BlowgunInfiniteUsePatch.IsBlowgunItem(val))
					{
						RestoreWeaponItemInteractionRestrictions(val.UIData);
						if ((Object)(object)val.isSecretlyOtherItemPrefab != (Object)null)
						{
							RestoreWeaponItemInteractionRestrictions(val.isSecretlyOtherItemPrefab.UIData);
						}
					}
				}
			}
			catch
			{
			}
		}

		internal static bool IsProtectedWeaponItem(Item item)
		{
			if (IsWeaponFeatureEnabled() && (Object)(object)item != (Object)null)
			{
				return ItemPatch.IsBlowgunLike(item);
			}
			return false;
		}

		internal static bool IsProtectedWeaponSlot(ItemSlot slot)
		{
			if (slot == null || slot.IsEmpty())
			{
				return false;
			}
			return IsProtectedWeaponItem(slot.prefab);
		}

		internal static bool CharacterHasShootZombiesWeaponRuntime(Character c)
		{
			return CharacterAlreadyHasShootZombiesWeapon(c);
		}

		private static void NormalizeLocalWeaponOwnership()
		{
			if (IsWeaponFeatureEnabled())
			{
				EnforceSingleWeaponForCharacter(Character.localCharacter ?? _localCharacter, equipIfHandsFree: true);
			}
		}

		internal static bool EnforceSingleWeaponForCharacter(Character c, bool equipIfHandsFree)
		{
			//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)
			if (!IsWeaponFeatureEnabled() || (Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return false;
			}
			Player player = c.player;
			if ((Object)(object)player == (Object)null || player.itemSlots == null)
			{
				return false;
			}
			Item item = null;
			try
			{
				if ((Object)(object)c.data != (Object)null)
				{
					item = c.data.currentItem;
				}
				TryProtectWeaponItemRuntime(item);
			}
			catch
			{
			}
			ItemSlot keptSlot = null;
			bool flag = false;
			bool flag2 = IsProtectedWeaponItem(item);
			if (player.itemSlots.Length != 0 && IsProtectedWeaponSlot(player.itemSlots[0]))
			{
				keptSlot = player.itemSlots[0];
			}
			Optionable<byte> selectedSlot = GetSelectedSlot(c);
			if (keptSlot == null && selectedSlot.IsSome)
			{
				ItemSlot itemSlot = player.GetItemSlot(selectedSlot.Value);
				if (IsProtectedWeaponSlot(itemSlot))
				{
					keptSlot = itemSlot;
				}
			}
			for (byte b = 0; b < player.itemSlots.Length; b++)
			{
				ItemSlot val = player.itemSlots[b];
				if (IsProtectedWeaponSlot(val))
				{
					TryProtectWeaponItemRuntime(val.prefab);
					if (keptSlot == null)
					{
						keptSlot = val;
					}
					else if (val != keptSlot)
					{
						val.EmptyOut();
						flag = true;
					}
				}
			}
			ItemSlot tempFullSlot = player.tempFullSlot;
			if (IsProtectedWeaponSlot(tempFullSlot))
			{
				TryProtectWeaponItemRuntime(tempFullSlot.prefab);
				if (keptSlot == null)
				{
					keptSlot = tempFullSlot;
				}
				else if (tempFullSlot != keptSlot)
				{
					tempFullSlot.EmptyOut();
					flag = true;
				}
			}
			if (TryMoveWeaponToPreferredInventorySlot(player, ref keptSlot))
			{
				flag = true;
			}
			if (flag)
			{
				TrySyncInventoryRpc(c, player, "single-weapon");
			}
			return keptSlot != null || flag2;
		}

		private static bool TryMoveWeaponToPreferredInventorySlot(Player player, ref ItemSlot keptSlot)
		{
			if ((Object)(object)player == (Object)null || player.itemSlots == null || player.itemSlots.Length == 0 || keptSlot == null)
			{
				return false;
			}
			ItemSlot val = player.itemSlots[0];
			if (val == null || val == keptSlot || !IsProtectedWeaponSlot(keptSlot))
			{
				return false;
			}
			if (IsProtectedWeaponSlot(val))
			{
				keptSlot.EmptyOut();
				keptSlot = val;
				return true;
			}
			Item prefab = keptSlot.prefab;
			ItemInstanceData slotDataOrFallback = GetSlotDataOrFallback(keptSlot, 999);
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			bool flag = !val.IsEmpty();
			Item val2 = (flag ? val.prefab : null);
			ItemInstanceData val3 = (flag ? GetSlotDataOrFallback(val, 1) : null);
			ItemSlot val4 = null;
			if (flag)
			{
				val4 = (IsInventorySlot(player, keptSlot) ? keptSlot : FindEmptyInventorySlot(player, 1));
				if (val4 == null)
				{
					return false;
				}
			}
			val.SetItem(prefab, slotDataOrFallback);
			if (flag)
			{
				val4.SetItem(val2, val3);
			}
			else
			{
				keptSlot.EmptyOut();
			}
			keptSlot = val;
			TryProtectWeaponItemRuntime(prefab);
			return true;
		}

		private static bool IsInventorySlot(Player player, ItemSlot slot)
		{
			if ((Object)(object)player == (Object)null || player.itemSlots == null || slot == null)
			{
				return false;
			}
			for (int i = 0; i < player.itemSlots.Length; i++)
			{
				if (player.itemSlots[i] == slot)
				{
					return true;
				}
			}
			return false;
		}

		private static ItemSlot FindEmptyInventorySlot(Player player, int startIndex)
		{
			if ((Object)(object)player == (Object)null || player.itemSlots == null)
			{
				return null;
			}
			for (int i = Mathf.Max(startIndex, 0); i < player.itemSlots.Length; i++)
			{
				if (player.itemSlots[i] != null && player.itemSlots[i].IsEmpty())
				{
					return player.itemSlots[i];
				}
			}
			return null;
		}

		private static ItemInstanceData GetSlotDataOrFallback(ItemSlot slot, int fallbackUses)
		{
			if (slot != null)
			{
				try
				{
					object? obj = ((object)slot).GetType().GetProperty("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(slot);
					ItemInstanceData val = (ItemInstanceData)((obj is ItemInstanceData) ? obj : null);
					if (val != null)
					{
						return val;
					}
					FieldInfo field = ((object)slot).GetType().GetField("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						object? value = field.GetValue(slot);
						ItemInstanceData val2 = (ItemInstanceData)((value is ItemInstanceData) ? value : null);
						if (val2 != null)
						{
							return val2;
						}
					}
				}
				catch
				{
				}
			}
			return CreateItemInstanceData(fallbackUses);
		}

		internal static bool TryEquipExistingWeaponSlot(Character c)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!IsWeaponFeatureEnabled() || (Object)(object)c == (Object)null || c.isBot || c.isZombie)
			{
				return false;
			}
			Player player = c.player;
			if ((Object)(object)player == (Object)null || player.itemSlots == null)
			{
				return false;
			}
			Optionable<byte> selectedSlot = GetSelectedSlot(c);
			if (selectedSlot.IsSome && IsProtectedWeaponSlot(player.GetItemSlot(selectedSlot.Value)))
			{
				return TryEquipWeaponSlot(c, selectedSlot.Value);
			}
			for (byte b = 0; b < player.itemSlots.Length; b++)
			{
				if (IsProtectedWeaponSlot(player.itemSlots[b]))
				{
					return TryEquipWeaponSlot(c, b);
				}
			}
			if (IsProtectedWeaponSlot(player.tempFullSlot))
			{
				return TryEquipWeaponSlot(c, player.tempFullSlot.itemSlotID);
			}
			return false;
		}

		private static Optionable<byte> GetSelectedSlot(Character c)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)c != (Object)null && c.refs != null && (Object)(object)c.refs.items != (Object)null)
				{
					return c.refs.items.currentSelectedSlot;
				}
			}
			catch
			{
			}
			return Optionable<byte>.None;
		}

		private static bool TryEquipWeaponSlot(Character c, byte slotId)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)c == (Object)null || c.refs == null || (Object)(object)c.refs.items == (Object)null)
				{
					return false;
				}
				Player player = c.player;
				if ((Object)(object)player == (Object)null)
				{
					return false;
				}
				if (!IsProtectedWeaponSlot(player.GetItemSlot(slotId)))
				{
					return false;
				}
				Item item = null;
				if ((Object)(object)c.data != (Object)null)
				{
					item = c.data.currentItem;
				}
				if (c.refs.items.currentSelectedSlot.IsSome && c.refs.items.currentSelectedSlot.Value == slotId && IsProtectedWeaponItem(item))
				{
					return true;
				}
				c.refs.items.EquipSlot(Optionable<byte>.Some(slotId));
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[ShootZombies] TryEquipWeaponSlot failed: " + ex.Message));
				return false;
			}
		}
	}
	[HarmonyPatch]
	public static class SuppressOriginalBlowgunFirePatch
	{
		private static MethodBase _targetMethod;

		public static MethodBase TargetMethod()
		{
			if (_targetMethod != null)
			{
				return _targetMethod;
			}
			try
			{
				MethodInfo methodInfo = typeof(Item).Assembly.GetType("Action_RaycastDart")?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => string.Equals(m.Name, "RunAction", StringComparison.Ordinal) && m.GetParameters().Length == 0);
				if (methodInfo != null)
				{
					_targetMethod = methodInfo;
					return _targetMethod;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[SuppressOriginalBlowgunFirePatch] TargetMethod error: " + ex));
			}
			Plugin.Log.LogWarning((object)"[SuppressOriginalBlowgunFirePatch] TargetMethod returning null - RunAction method not found");
			return null;
		}

		[HarmonyPrefix]
		public static bool RunActionPrefix(MonoBehaviour __instance)
		{
			try
			{
				Item componentInParent = ((Component)__instance).GetComponentInParent<Item>();
				if (!Plugin.IsWeaponFeatureEnabled() || (Object)(object)componentInParent == (Object)null)
				{
					return true;
				}
				if (ItemPatch.IsBlowgunLike(componentInParent))
				{
					return false;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[SuppressOriginalBlowgunFirePatch] RunActionPrefix failed: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterItems), "DropItemRpc")]
	public static class WeaponDropRpcGuardPatch
	{
		public static bool Prefix(CharacterItems __instance, byte slotID)
		{
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return true;
				}
				Character component = ((Component)__instance).GetComponent<Character>();
				Item item = null;
				Player val = null;
				if ((Object)(object)component != (Object)null)
				{
					val = component.player;
					if ((Object)(object)component.data != (Object)null)
					{
						item = component.data.currentItem;
					}
				}
				ItemSlot val2 = (((Object)(object)val != (Object)null) ? val.GetItemSlot(slotID) : null);
				if (Plugin.IsProtectedWeaponItem(item) || Plugin.IsProtectedWeaponSlot(val2))
				{
					Plugin.TryProtectWeaponItemRuntime(item);
					Plugin.TryProtectWeaponItemRuntime(val2?.prefab);
					Plugin.EnforceSingleWeaponForCharacter(component, equipIfHandsFree: true);
					return false;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] WeaponDropRpcGuardPatch failed: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterItems), "DropItemFromSlotRPC")]
	public static class WeaponDropFromSlotRpcGuardPatch
	{
		public static bool Prefix(CharacterItems __instance, byte slotID)
		{
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return true;
				}
				Character component = ((Component)__instance).GetComponent<Character>();
				Player val = (((Object)(object)component != (Object)null) ? component.player : null);
				ItemSlot val2 = (((Object)(object)val != (Object)null) ? val.GetItemSlot(slotID) : null);
				if (Plugin.IsProtectedWeaponSlot(val2))
				{
					Plugin.TryProtectWeaponItemRuntime(val2.prefab);
					Plugin.EnforceSingleWeaponForCharacter(component, equipIfHandsFree: true);
					return false;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] WeaponDropFromSlotRpcGuardPatch failed: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterItems), "DestroyHeldItemRpc")]
	public static class WeaponDestroyHeldGuardPatch
	{
		public static bool Prefix(CharacterItems __instance)
		{
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return true;
				}
				Character component = ((Component)__instance).GetComponent<Character>();
				Item item = null;
				if ((Object)(object)component != (Object)null && (Object)(object)component.data != (Object)null)
				{
					item = component.data.currentItem;
				}
				if (Plugin.IsProtectedWeaponItem(item))
				{
					Plugin.TryProtectWeaponItemRuntime(item);
					Plugin.EnforceSingleWeaponForCharacter(component, equipIfHandsFree: true);
					return false;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] WeaponDestroyHeldGuardPatch failed: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "EmptySlot")]
	public static class WeaponEmptySlotGuardPatch
	{
		public static bool Prefix(Player __instance, Optionable<byte> slot)
		{
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled() || slot.IsNone)
				{
					return true;
				}
				ItemSlot itemSlot = __instance.GetItemSlot(slot.Value);
				if (Plugin.IsProtectedWeaponSlot(itemSlot))
				{
					Plugin.TryProtectWeaponItemRuntime(itemSlot.prefab);
					Plugin.EnforceSingleWeaponForCharacter(__instance.character, equipIfHandsFree: true);
					return false;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] WeaponEmptySlotGuardPatch failed: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "RPCRemoveItemFromSlot")]
	public static class WeaponRpcRemoveItemFromSlotGuardPatch
	{
		public static bool Prefix(Player __instance, byte slotID)
		{
			try
			{
				if (!Plugin.IsWeaponFeatureEnabled())
				{
					return true;
				}
				ItemSlot itemSlot = __instance.GetItemSlot(slotID);
				if (Plugin.IsProtectedWeaponSlot(itemSlot))
				{
					Plugin.TryProtectWeaponItemRuntime(itemSlot.prefab);
					Plugin.EnforceSingleWeaponForCharacter(__instance.character, equipIfHandsFree: true);
					return false;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] WeaponRpcRemoveItemFromSlotGuardPatch failed: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Item), "Interact")]
	public static class WeaponPickupDuplicateGuardPatch
	{
		public static bool Prefix(Item __instance, Character interactor)
		{
			try
			{
				if (!Plugin.IsProtectedWeaponItem(__instance) || (Object)(object)interactor == (Object)null)
				{
					return true;
				}
				if (Plugin.CharacterHasShootZombiesWeaponRuntime(interactor))
				{
					Plugin.EnforceSingleWeaponForCharacter(interactor, equipIfHandsFree: true);
					return false;
				}
				Plugin.TryProtectWeaponItemRuntime(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ShootZombies] WeaponPickupDuplicateGuardPatch failed: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(MushroomZombie), "Update")]
	public static class ZombieDeathPatch
	{
		private static readonly HashSet<int> ProcessedZombieIds = new HashSet<int>();

		private static readonly Dictionary<int, Character> ZombieCharacterCache = new Dictionary<int, Character>();

		[HarmonyPostfix]
		public static void Postfix(MushroomZombie __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					return;
				}
				int instanceID = ((Object)__instance).GetInstanceID();
				if (ProcessedZombieIds.Contains(instanceID))
				{
					return;
				}
				if (!ZombieCharacterCache.TryGetValue(instanceID, out var value) || (Object)(object)value == (Object)null)
				{
					value = ((Component)__instance).GetComponent<Character>();
					if ((Object)(object)value == (Object)null)
					{
						ZombieCharacterCache.Remove(instanceID);
						return;
					}
					ZombieCharacterCache[instanceID] = value;
				}
				CharacterData data = value.data;
				if (!((Object)(object)data == (Object)null) && data.dead)
				{
					ProcessedZombieIds.Add(instanceID);
					ZombieCharacterCache.Remove(instanceID);
					if ((Object)(object)gameObject != (Object)null)
					{
						ZombieSpawner.DestroyZombie(gameObject);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		internal static void ClearCaches()
		{
			ProcessedZombieIds.Clear();
			ZombieCharacterCache.Clear();
		}
	}
	[HarmonyPatch(typeof(MushroomZombie), "RPC_SpawnSkelly")]
	public static class ZombieSkeletonSpawnPatch
	{
		[HarmonyPrefix]
		public static bool Prefix()
		{
			return false;
		}
	}
	public sealed class ZombieHealthBar : MonoBehaviour
	{
		private const float BarWidth = 90f;

		private const float BarHeight = 10f;

		private const float HeightOffset = 1.35f;

		private const float VisibleDistance = 70f;

		private const float WorldScale = 0.012f;

		private const float ShowHealthThreshold = 0.999f;

		private const float VisibleAfterHitSeconds = 3f;

		private static readonly Color BackgroundColor = new Color(0.02f, 0.02f, 0.02f, 0.72f);

		private static readonly Color FillColor = new Color(0.95f, 0.05f, 0.04f, 0.95f);

		private static float _nextGlobalRefreshTime;

		private Character _character;

		private Transform _root;

		private Canvas _canvas;

		private RectTransform _rootRect;

		private RectTransform _fillRect;

		private float _health01 = 1f;

		private float _hideAfterUnscaledTime = -1f;

		public static void RefreshAll()
		{
			if (Time.unscaledTime < _nextGlobalRefreshTime)
			{
				return;
			}
			_nextGlobalRefreshTime = Time.unscaledTime + 0.35f;
			try
			{
				ZombieHealthBar[] array = Object.FindObjectsByType<ZombieHealthBar>((FindObjectsSortMode)0);
				foreach (ZombieHealthBar zombieHealthBar in array)
				{
					if (!((Object)(object)zombieHealthBar == (Object)null) && !zombieHealthBar.ShouldStayVisible())
					{
						Object.Destroy((Object)(object)((Component)zombieHealthBar).gameObject);
					}
				}
			}
			catch
			{
			}
		}

		public static void SetHealth(Character character, float health01)
		{
			if (!ShouldShowHealthBar(health01))
			{
				DestroyExisting(character);
			}
			else
			{
				Ensure(character, health01, overwrite: true);
			}
		}

		public static void SetHealth(GameObject zombieObject, float health01)
		{
			if (!((Object)(object)zombieObject == (Object)null))
			{
				SetHealth(zombieObject.GetComponent<Character>() ?? zombieObject.GetComponentInParent<Character>() ?? zombieObject.GetComponentInChildren<Character>(true), health01);
			}
		}

		private static void Ensure(Character character, float health01, bool overwrite)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (IsZombieCharacter(character))
			{
				ZombieHealthBar zombieHealthBar = ((Component)character).GetComponentInChildren<ZombieHealthBar>(true);
				if ((Object)(object)zombieHealthBar == (Object)null)
				{
					GameObject val = new GameObject("ShootZombies_ZombieHealthBar", new Type[1] { typeof(RectTransform) });
					val.transform.SetParent(((Component)character).transform, false);
					zombieHealthBar = val.AddComponent<ZombieHealthBar>();
				}
				((Component)zombieHealthBar).gameObject.SetActive(true);
				if (overwrite)
				{
					zombieHealthBar._health01 = Mathf.Clamp01(health01);
					zombieHealthBar.RefreshVisibilityTimeout();
				}
				zombieHealthBar.Initialize(character, ((Component)zombieHealthBar).transform);
				if (overwrite)
				{
					zombieHealthBar.SetHealth01(health01);
				}
			}
		}

		private static bool ShouldShowHealthBar(float health01)
		{
			float num = Mathf.Clamp01(health01);
			if (num > 0.001f)
			{
				return num < 0.999f;
			}
			return false;
		}

		private static void DestroyExisting(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return;
			}
			try
			{
				ZombieHealthBar componentInChildren = ((Component)character).GetComponentInChildren<ZombieHealthBar>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
				}
			}
			catch
			{
			}
		}

		private static bool IsZombieCharacter(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			try
			{
				if (character.isZombie)
				{
					return true;
				}
				if ((Object)(object)((Component)character).GetComponent<MushroomZombie>() != (Object)null)
				{
					return true;
				}
				return (Object)(object)((Component)character).GetComponentInParent<MushroomZombie>() != (Object)null || (Object)(object)((Component)character).GetComponentInChildren<MushroomZombie>(true) != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		private void Awake()
		{
			_root = ((Component)this).transform;
		}

		private void Initialize(Character character, Transform root)
		{
			_character = character;
			_root = root;
			EnsureInitialized();
			SetHealth01(_health01);
		}

		private bool EnsureInitialized()
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null)
			{
				_root = ((Component)this).transform;
			}
			if ((Object)(object)_character == (Object)null)
			{
				_character = ((Component)this).GetComponentInParent<Character>() ?? ((Component)this).GetComponentInChildren<Character>(true);
			}
			if (!IsZombieCharacter(_character))
			{
				return false;
			}
			if ((Object)(object)_canvas == (Object)null)
			{
				_canvas = ((Component)this).GetComponent<Canvas>() ?? ((Component)this).gameObject.AddComponent<Canvas>();
			}
			_canvas.renderMode = (RenderMode)2;
			_canvas.sortingOrder = 1500;
			(((Component)this).GetComponent<CanvasScaler>() ?? ((Component)this).gameObject.AddComponent<CanvasScaler>()).dynamicPixelsPerUnit = 120f;
			((Behaviour)(((Component)this).GetComponent<GraphicRaycaster>() ?? ((Component)this).gameObject.AddComponent<GraphicRaycaster>())).enabled = false;
			_rootRect = ((Component)this).gameObject.GetComponent<RectTransform>();
			_rootRect.sizeDelta = new Vector2(90f, 10f);
			_rootRect.pivot = new Vector2(0.5f, 0.5f);
			RectTransform val = FindChildRect("Background");
			if ((Object)(object)val == (Object)null)
			{
				val = CreateImage("Background", BackgroundColor).GetComponent<RectTransform>();
			}
			else
			{
				Image component = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = BackgroundColor;
					((Graphic)component).raycastTarget = false;
				}
			}
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			_fillRect = FindChildRect("Fill");
			if ((Object)(object)_fillRect == (Object)null)
			{
				_fillRect = CreateImage("Fill", FillColor).GetComponent<RectTransform>();
			}
			else
			{
				Image component2 = ((Component)_fillRect).GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Graphic)component2).color = FillColor;
					((Graphic)component2).raycastTarget = false;
				}
			}
			_fillRect.anchorMin = new Vector2(0f, 0f);
			_fillRect.anchorMax = new Vector2(_health01, 1f);
			_fillRect.pivot = new Vector2(0f, 0.5f);
			_fillRect.offsetMin = Vector2.zero;
			_fillRect.offsetMax = Vector2.zero;
			((Transform)_fillRect).SetAsLastSibling();
			if ((Object)(object)_root != (Object)null && (Object)(object)_canvas != (Object)null)
			{
				return (Object)(object)_fillRect != (Object)null;
			}
			return false;
		}

		private RectTransform FindChildRect(string childName)
		{
			if ((Object)(object)_root == (Object)null)
			{
				return null;
			}
			Transform val = _root.Find(childName);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return ((Component)val).GetComponent<RectTransform>();
		}

		private GameObject CreateImage(string name, Color color)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(_root, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = color;
			((Graphic)component).raycastTarget = false;
			return val;
		}

		private void SetHealth01(float health01)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			_health01 = Mathf.Clamp01(health01);
			if (!ShouldShowHealthBar(_health01))
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else if ((Object)(object)_fillRect != (Object)null)
			{
				_fillRect.anchorMin = new Vector2(0f, 0f);
				_fillRect.anchorMax = new Vector2(_health01, 1f);
				_fillRect.offsetMin = Vector2.zero;
				_fillRect.offsetMax = Vector2.zero;
				((Component)_fillRect).gameObject.SetActive(_health01 > 0.001f);
			}
		}

		private void LateUpdate()
		{
			try
			{
				LateUpdateSafe();
			}
			catch
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void LateUpdateSafe()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsModFeatureEnabled() || !ShouldStayVisible() || !EnsureInitialized())
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Camera main = Camera.main;
			Character val = Character.observedCharacter ?? Character.localCharacter;
			if ((Object)(object)main == (Object)null || (Object)(object)val == (Object)null)
			{
				((Behaviour)_canvas).enabled = false;
				return;
			}
			Vector3 val2 = _character.Center + Vector3.up * 1.35f;
			float num = Vector3.Distance(val.Center, val2);
			Vector3 val3 = main.WorldToViewportPoint(val2);
			bool flag = num <= 70f && val3.z > 0f && val3.x >= -0.08f && val3.x <= 1.08f && val3.y >= -0.08f && val3.y <= 1.08f;
			((Behaviour)_canvas).enabled = flag;
			if (flag)
			{
				_canvas.worldCamera = main;
				_root.position = val2;
				_root.rotation = ((Component)main).transform.rotation;
				float num2 = 0.012f * Mathf.Lerp(1f, 1.7f, Mathf.Clamp01(num / 70f));
				_root.localScale = new Vector3(num2, num2, num2);
			}
		}

		private bool ShouldStayVisible()
		{
			if (ShouldShowHealthBar(_health01) && !HasVisibilityTimedOut())
			{
				return IsZombieCharacter(_character);
			}
			return false;
		}

		private void RefreshVisibilityTimeout()
		{
			_hideAfterUnscaledTime = Time.unscaledTime + 3f;
		}

		private bool HasVisibilityTimedOut()
		{
			if (_hideAfterUnscaledTime >= 0f)
			{
				return Time.unscaledTime > _hideAfterUnscaledTime;
			}
			return false;
		}
	}
	public static class ZombieSpawner
	{
		private struct VanillaZombieBehaviorDefaults
		{
			public float InitialWakeUpTime;

			public float LookAngleBeforeWakeup;

			public float DistanceBeforeWakeup;

			public float DistanceBeforeChase;

			public float ZombieSprintDistance;

			public float ChaseTimeBeforeSprint;

			public float ZombieLungeDistance;

			public float LungeTime;

			public float LungeRecoveryTime;
		}

		private struct ZombieTimer
		{
			public GameObject zombie;

			public float deathTime;

			public float health01;
		}

		[CompilerGenerated]
		private sealed class <SpawnZombiesAroundPlayers>d__49 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int count;

			private int <spawned>5__2;

			private int <i>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SpawnZombiesAroundPlayers>d__49(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00e2;
				}
				<>1__state = -1;
				if (!Plugin.HasGameplayAuthority() || !IsGameplaySpawnScene())
				{
					return false;
				}
				_waveSpawnPositions.Clear();
				<spawned>5__2 = 0;
				<i>5__3 = 0;
				goto IL_00f2;
				IL_00f2:
				if (<i>5__3 < count)
				{
					if (!Plugin.IsZombieSpawnFeatureEnabledRuntime() || !Plugin.HasGameplayAuthority())
					{
						return false;
					}
					if (!IsGameplaySpawnScene())
					{
						DestroyAllZombies();
						return false;
					}
					int currentZombieCount = GetCurrentZombieCount();
					int maxZombieCount = Mathf.Max(Plugin.MaxZombies.Value, 0);
					if (GetSpawnCountForRemainingCapacity(1, currentZombieCount, maxZombieCount) <= 0 || CollectAlivePlayers(_alivePlayersBuffer) == 0)
					{
						return false;
					}
					if (TrySpawnOneZombieAroundPlayers())
					{
						<spawned>5__2++;
					}
					if (<i>5__3 + 1 < count)
					{
						<>2__current = (object)new WaitForSeconds(GetNextWaveSpawnSpacing(<spawned>5__2));
						<>1__state = 1;
						return true;
					}
					goto IL_00e2;
				}
				_waveSpawnPositions.Clear();
				return false;
				IL_00e2:
				<i>5__3++;
				goto IL_00f2;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <WaitForSpawnReadiness>d__52 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitForSpawnReadiness>d__52(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Plugin.IsZombieSpawnFeatureEnabledRuntime() && IsGameplaySpawnScene())
				{
					if (!Plugin.HasGameplayAuthority())
					{
						return false;
					}
					if (CollectAlivePlayers(_alivePlayersBuffer) > 0)
					{
						return false;
					}
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ZombieSpawnCoroutine>d__48 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ZombieSpawnCoroutine>d__48(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(GetNextSpawnDelay(firstWave: true));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = WaitForSpawnReadiness();
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					if (!IsGameplaySpawnScene())
					{
						return false;
					}
					int nextSpawnCount2 = GetNextSpawnCount();
					<>2__current = SpawnZombiesAroundPlayers(nextSpawnCount2);
					<>1__state = 3;
					return true;
				}
				case 3:
					<>1__state = -1;
					break;
				case 4:
					<>1__state = -1;
					if (!IsGameplaySpawnScene())
					{
						DestroyAllZombies();
						break;
					}
					<>2__current = WaitForSpawnReadiness();
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					if (!IsGameplaySpawnScene())
					{
						DestroyAllZombies();
					}
					else if (Plugin.HasGameplayAuthority())
					{
						int nextSpawnCount = GetNextSpawnCount();
						<>2__current = SpawnZombiesAroundPlayers(nextSpawnCount);
						<>1__state = 6;
						return true;
					}
					break;
				case 6:
					<>1__state = -1;
					break;
				}
				if (Plugin.IsZombieSpawnFeatureEnabledRuntime())
				{
					float nextSpawnDelay = GetNextSpawnDelay();
					<>2__current = (object)new WaitForSeconds(nextSpawnDelay);
					<>1__state = 4;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const float MinSpawnRadiusFraction = 0.45f;

		private const float MinSpawnRadiusFloor = 6.5f;

		private const float MinSpawnRadiusFloorFraction = 0.75f;

		private const int SpawnPositionAttempts = 40;

		private const int SpawnDirectionAttemptsPerTarget = 6;

		private const float FrontSpawnPreferenceFraction = 0.6f;

		private const float RearSpawnDotThreshold = 0.05f;

		private const float FrontSpawnConeHalfAngle = 70f;

		private const float RearSpawnConeHalfAngle = 75f;

		private const float ViewConeRejectAngle = 55f;

		private const float VisibilityTargetHeight = 1.2f;

		private const float VisibilityPadding = 0.2f;

		private const float SpawnGroundProbeHeight = 12f;

		private const float SpawnGroundProbeDistance = 48f;

		private const float MaxSpawnSlopeAngle = 47f;

		private const float MaxSpawnBelowPlayer = 2.75f;

		private const float MaxSpawnAbovePlayer = 6.5f;

		private const float SpawnCapsuleBottomHeight = 0.55f;

		private const float SpawnCapsuleTopHeight = 1.55f;

		private const float SpawnCapsuleRadius = 0.24f;

		private const float SpawnSupportSampleRadius = 0.85f;

		private const int SpawnSupportSampleCount = 6;

		private const float MaxSpawnSupportHeightDelta = 1.1f;

		private const float SpawnGroundLift = 0.08f;

		private const float ZombieLifetimeCheckInterval = 0.25f;

		private const float ZombieDistanceCheckInterval = 0.75f;

		private const float MinWaveSpawnSpacing = 0.25f;

		private const float MaxWaveSpawnSpacing = 0.85f;

		private const float MinWaveSpawnPositionSpacing = 5.5f;

		private const float WaveSpawnPositionSpacingRadiusFraction = 0.42f;

		private const float SpawnReadinessCheckInterval = 0.25f;

		private static Coroutine _spawnCoroutine;

		private static HashSet<GameObject> _liveZombies = new HashSet<GameObject>();

		private static List<ZombieTimer> _zombieTimers = new List<ZombieTimer>();

		private static readonly List<GameObject> _staleZombieBuffer = new List<GameObject>();

		private static readonly List<Character> _alivePlayersBuffer = new List<Character>();

		private static readonly List<Vector3> _waveSpawnPositions = new List<Vector3>();

		private static GameObject _cachedLocalZombiePrefab;

		private static bool _cachedVanillaZombieBehaviorDefaultsResolved;

		private static VanillaZombieBehaviorDefaults _cachedVanillaZombieBehaviorDefaults;

		private static bool _loggedMissingLocalZombiePrefab;

		private static float _nextZombieLifetimeCheckTime;

		private static float _nextZombieDistanceCheckTime;

		private static bool IsGameplaySpawnScene()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (!((Scene)(ref activeScene)).IsValid() || !((Scene)(ref activeScene)).isLoaded)
			{
				return false;
			}
			return Plugin.IsGameplaySceneRuntime(activeScene);
		}

		public static void StartZombieSpawning()
		{
			if (!Plugin.IsZombieSpawnFeatureEnabledRuntime() || !IsGameplaySpawnScene())
			{
				StopZombieSpawning();
				DestroyAllZombies();
			}
			else if (Plugin.IsZombieSpawnFeatureEnabledRuntime())
			{
				if (_spawnCoroutine != null)
				{
					((MonoBehaviour)Plugin.Instance).StopCoroutine(_spawnCoroutine);
				}
				_spawnCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(ZombieSpawnCoroutine());
			}
		}

		public static void StopZombieSpawning()
		{
			if (_spawnCoroutine != null)
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(_spawnCoroutine);
				_spawnCoroutine = null;
			}
		}

		[IteratorStateMachine(typeof(<ZombieSpawnCoroutine>d__48))]
		private static IEnumerator ZombieSpawnCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ZombieSpawnCoroutine>d__48(0);
		}

		[IteratorStateMachine(typeof(<SpawnZombiesAroundPlayers>d__49))]
		private static IEnumerator SpawnZombiesAroundPlayers(int count)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnZombiesAroundPlayers>d__49(0)
			{
				count = count
			};
		}

		private static bool TrySpawnOneZombieAroundPlayers()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!TryGetSpawnPosition(out var position, out var targetPlayer))
				{
					return false;
				}
				Quaternion spawnRotation = GetSpawnRotation(position, targetPlayer);
				GameObject val = TryCreateZombieInstance(position, spawnRotation);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				_liveZombies.Add(val);
				_waveSpawnPositions.Add(position);
				InitializeSpawnedZombieRuntime(val);
				float value = Plugin.ZombieMaxLifetime.Value;
				_zombieTimers.Add(new ZombieTimer
				{
					zombie = val,
					deathTime = Time.time + value,
					health01 = 1f
				});
				ApplyZombieProperties(val);
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		public static bool ContainsZombie(GameObject zombie)
		{
			return _liveZombies.Contains(zombie);
		}

		[IteratorStateMachine(typeof(<WaitForSpawnReadiness>d__52))]
		private static IEnumerator WaitForSpawnReadiness()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForSpawnReadiness>d__52(0);
		}

		public static void RemoveZombie(GameObject zombie)
		{
			_liveZombies.Remove(zombie);
			_zombieTimers.RemoveAll((ZombieTimer t) => (Object)(object)t.zombie == (Object)(object)zombie);
		}

		public static bool TryReduceZombieLifetime(GameObject zombie, float seconds, out bool expired)
		{
			expired = false;
			if ((Object)(object)zombie == (Object)null || seconds <= 0f)
			{
				return false;
			}
			for (int i = 0; i < _zombieTimers.Count; i++)
			{
				ZombieTimer value = _zombieTimers[i];
				if (!((Object)(object)value.zombie != (Object)(object)zombie))
				{
					value.deathTime -= seconds;
					value.health01 = Mathf.Clamp01(value.health01 - seconds / Mathf.Max(Plugin.ZombieMaxLifetime.Value, 1f));
					if (value.health01 <= 0f || value.deathTime <= Time.time)
					{
						expired = true;
						_zombieTimers.RemoveAt(i);
						ExpireZombie(zombie);
					}
					else
					{
						_zombieTimers[i] = value;
					}
					return true;
				}
			}
			return false;
		}

		public static bool TryGetZombieHealth01(GameObject zombie, out float health01)
		{
			health01 = 1f;
			if ((Object)(object)zombie == (Object)null)
			{
				return false;
			}
			for (int i = 0; i < _zombieTimers.Count; i++)
			{
				ZombieTimer zombieTimer = _zombieTimers[i];
				if ((Object)(object)zombieTimer.zombie == (Object)(object)zombie)
				{
					health01 = Mathf.Clamp01(zombieTimer.health01);
					return true;
				}
			}
			return false;
		}

		public static void ExpireZombie(GameObject zombie)
		{
			if (!((Object)(object)zombie == (Object)null))
			{
				_liveZombies.Remove(zombie);
				_zombieTimers.RemoveAll((ZombieTimer t) => (Object)(object)t.zombie == (Object)(object)zombie);
				DestroyZombie(zombie);
			}
		}

		public static void RefreshLiveZombieProperties()
		{
			if (!Plugin.HasGameplayAuthority() || !IsGameplaySpawnScene())
			{
				return;
			}
			CompactLiveZombieSet();
			foreach (GameObject liveZombie in _liveZombies)
			{
				if (!((Object)(object)liveZombie == (Object)null))
				{
					ApplyZombieProperties(liveZombie);
				}
			}
		}

		public static void RebuildLiveZombieRegistryFromScene()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.HasGameplayAuthority() || !IsGameplaySpawnScene())
			{
				return;
			}
			_liveZombies.Clear();
			_zombieTimers.Clear();
			_staleZombieBuffer.Clear();
			_waveSpawnPositions.Clear();
			try
			{
				MushroomZombie[] array = Resources.FindObjectsOfTypeAll<MushroomZombie>();
				float num = Mathf.Max((Plugin.ZombieMaxLifetime != null) ? Plugin.ZombieMaxLifetime.Value : 120f, 1f);
				float deathTime = Time.time + num;
				MushroomZombie[] array2 = array;
				foreach (MushroomZombie val in array2)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					GameObject gameObject = ((Component)val).gameObject;
					if ((Object)(object)gameObject == (Object)null)
					{
						continue;
					}
					Scene scene = gameObject.scene;
					if (!((Scene)(ref scene)).IsValid())
					{
						continue;
					}
					scene = gameObject.scene;
					if (((Scene)(ref scene)).isLoaded)
					{
						Character val2 = gameObject.GetComponent<Character>() ?? gameObject.GetComponentInParent<Character>() ?? gameObject.GetComponentInChildren<Character>(true);
						if ((!((Object)(object)val2 != (Object)null) || val2.isZombie || val2.isBot) && _liveZombies.Add(gameObject))
						{
							_zombieTimers.Add(new ZombieTimer
							{
								zombie = gameObject,
								deathTime = deathTime,
								health01 = 1f
							});
							ApplyZombieProperties(gameObject);
						}
					}
				}
			}
			catch (Exception ex)
			{
				if (Plugin.Log != null)
				{
					Plugin.Log.LogWarning((object)("[ShootZombies] RebuildLiveZombieRegistryFromScene failed: " + ex.Message));
				}
			}
		}

		private static GameObject TryCreateZombieInstance(Vector3 position, Quaternion rotation)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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)
			if (!IsGameplaySpawnScene())
			{
				return null;
			}
			if (PhotonNetwork.InRoom || PhotonNetwork.OfflineMode)
			{
				try
				{
					return PhotonNetwork.Instantiate("MushroomZombie", position, rotation, (byte)0, (object[])null);
				}
				catch (Exception)
				{
				}
			}
			GameObject val = ResolveLocalZombiePrefab();
			if ((Object)(object)val == (Object)null)
			{
				if (!_loggedMissingLocalZombiePrefab && Plugin.Log != null)
				{
					_loggedMissingLocalZombiePrefab = true;
					Plugin.Log.LogWarning((object)"[ShootZombies] Local zombie prefab could not be resolved for non-network gameplay.");
				}
				return null;
			}
			return Object.Instantiate<GameObject>(val, position, rotation);
		}

		internal static void InitializeSpawnedZombieRuntime(GameObject zombieObj)
		{
			if ((Object)(object)zombieObj == (Object)null)
			{
				return;
			}
			try
			{
				Character val = zombieObj.GetComponent<Character>() ?? zombieObj.GetComponentInParent<Character>() ?? zombieObj.GetComponentInChildren<Character>(true);
				if ((Object)(object)val != (Object)null)
				{
					val.isZombie = true;
				}
				CharacterStats componentInChildren = zombieObj.GetComponentInChildren<CharacterStats>(true);
				if ((Object)(object)componentInChildren != (Object)null && !componentInChildren.IsInitialized)
				{
					componentInChildren.Initialize();
				}
			}
			catch (Exception)
			{
			}
		}

		private static GameObject ResolveLocalZombiePrefab()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_cachedLocalZombiePrefab != (Object)null)
			{
				return _cachedLocalZombiePrefab;
			}
			try
			{
				_cachedLocalZombiePrefab = Resources.Load<GameObject>("MushroomZombie");
			}
			catch
			{
				_cachedLocalZombiePrefab = null;
			}
			if ((Object)(object)_cachedLocalZombiePrefab == (Object)null)
			{
				try
				{
					GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
					GameObject val = null;
					GameObject[] array2 = array;
					foreach (GameObject val2 in array2)
					{
						if (!((Object)(object)val2 == (Object)null) && string.Equals(((Object)val2).name, "MushroomZombie", StringComparison.Ordinal))
						{
							Scene scene = val2.scene;
							if (!((Scene)(ref scene)).IsValid())
							{
								_cachedLocalZombiePrefab = val2;
								break;
							}
							if ((Object)(object)val == (Object)null)
							{
								val = val2;
							}
						}
					}
					if ((Object)(object)_cachedLocalZombiePrefab == (Object)null)
					{
						_cachedLocalZombiePrefab = val;
					}
				}
				catch
				{
					_cachedLocalZombiePrefab = null;
				}
			}
			return _cachedLocalZombiePrefab;
		}

		private static bool TryGetVanillaZombieBehaviorDefaults(out VanillaZombieBehaviorDefaults defaults)
		{
			defaults = default(VanillaZombieBehaviorDefaults);
			if (_cachedVanillaZombieBehaviorDefaultsResolved)
			{
				defaults = _cachedVanillaZombieBehaviorDefaults;
				return true;
			}
			GameObject val = ResolveLocalZombiePrefab();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			MushroomZombie component = val.GetComponent<MushroomZombie>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			VanillaZombieBehaviorDefaults cachedVanillaZombieBehaviorDefaults = default(VanillaZombieBehaviorDefaults);
			cachedVanillaZombieBehaviorDefaults.InitialWakeUpTime = component.initialWakeUpTime;
			cachedVanillaZombieBehaviorDefaults.LookAngleBeforeWakeup = component.lookAngleBeforeWakeup;
			cachedVanillaZombieBehaviorDefaults.DistanceBeforeWakeup = component.distanceBeforeWakeup;
			cachedVanillaZombieBehaviorDefaults.DistanceBeforeChase = component.distanceBeforeChase;
			cachedVanillaZombieBehaviorDefaults.ZombieSprintDistance = component.zombieSprintDistance;
			cachedVanillaZombieBehaviorDefaults.ChaseTimeBeforeSprint = component.chaseTimeBeforeSprint;
			cachedVanillaZombieBehaviorDefaults.ZombieLungeDistance = component.zombieLungeDistance;
			cachedVanillaZombieBehaviorDefaults.LungeTime = component.lungeTime;
			cachedVanillaZombieBehaviorDefaults.LungeRecoveryTime = component.lungeRecoveryTime;
			_cachedVanillaZombieBehaviorDefaults = cachedVanillaZombieBehaviorDefaults;
			_cachedVanillaZombieBehaviorDefaultsResolved = true;
			defaults = _cachedVanillaZombieBehaviorDefaults;
			return true;
		}

		public static void DestroyZombie(GameObject zombie)
		{
			if ((Object)(object)zombie == (Object)null)
			{
				return;
			}
			_liveZombies.Remove(zombie);
			_zombieTimers.RemoveAll((ZombieTimer t) => (Object)(object)t.zombie == (Object)(object)zombie);
			if (!Plugin.HasOnlineRoomSession() && !PhotonNetwork.OfflineMode)
			{
				Object.Destroy((Object)(object)zombie);
				return;
			}
			PhotonView component = zombie.GetComponent<PhotonView>();
			if ((Object)(object)component != (Object)null)
			{
				if (component.IsMine || PhotonNetwork.IsMasterClient)
				{
					PhotonNetwork.Destroy(component);
				}
			}
			else if (PhotonNetwork.InRoom || PhotonNetwork.OfflineMode)
			{
				PhotonNetwork.Destroy(zombie);
			}
			else
			{
				Object.Destroy((Object)(object)zombie);
			}
		}

		private static void ApplyZombieProperties(GameObject zombieObj)
		{
			try
			{
				MushroomZombie component = zombieObj.GetComponent<MushroomZombie>();
				if (!((Object)(object)component != (Object)null))
				{
					return;
				}
				if (Plugin.IsVanillaZombieBehaviorDifficultyRuntime())
				{
					if (TryGetVanillaZombieBehaviorDefaults(out var defaults))
					{
						component.initialWakeUpTime = 0f;
						component.lookAngleBeforeWakeup = defaults.LookAngleBeforeWakeup;
						component.distanceBeforeWakeup = defaults.DistanceBeforeWakeup;
						component.distanceBeforeChase = 0f;
						component.zombieSprintDistance = defaults.ZombieSprintDistance;
						component.chaseTimeBeforeSprint = defaults.ChaseTimeBeforeSprint;
						component.zombieLungeDistance = defaults.ZombieLungeDistance;
						component.lungeTime = defaults.LungeTime;
						component.lungeRecoveryTime = defaults.LungeRecoveryTime;
						component.sinceLookForTarget = Mathf.Max(component.sinceLookForTarget, Plugin.GetZombieTargetSearchIntervalRuntime());
					}
					return;
				}
				component.initialWakeUpTime = 0f;
				float zombieLookAngleBeforeWakeupRuntime = Plugin.GetZombieLookAngleBeforeWakeupRuntime();
				float zombieDistanceBeforeWakeupRuntime = Plugin.GetZombieDistanceBeforeWakeupRuntime();
				float zombieSprintDistanceRuntime = Plugin.GetZombieSprintDistanceRuntime();
				component.lookAngleBeforeWakeup = zombieLookAngleBeforeWakeupRuntime;
				if (zombieDistanceBeforeWakeupRuntime > 0f)
				{
					component.distanceBeforeWakeup = zombieDistanceBeforeWakeupRuntime;
				}
				component.distanceBeforeChase = 0f;
				if (zombieSprintDistanceRuntime > 0f)
				{
					component.zombieSprintDistance = Mathf.Max(zombieSprintDistanceRuntime, 3f);
				}
				component.chaseTimeBeforeSprint = Plugin.GetZombieChaseTimeBeforeSprintRuntime();
				component.zombieLungeDistance = Plugin.GetZombieLungeDistanceRuntime();
				component.lungeTime = Plugin.GetZombieLungeTimeRuntime();
				component.lungeRecoveryTime = Plugin.GetZombieLungeRecoveryTimeRuntime();
			}
			catch (Exception)
			{
			}
		}

		public static void ClearZombies()
		{
			_liveZombies.Clear();
			_zombieTimers.Clear();
			_staleZombieBuffer.Clear();
			_alivePlayersBuffer.Clear();
			_waveSpawnPositions.Clear();
			_nextZombieLifetimeCheckTime = 0f;
			_nextZombieDistanceCheckTime = 0f;
		}

		public static void UpdateZombieTimers()
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.HasGameplayAuthority())
			{
				return;
			}
			if (!IsGameplaySpawnScene())
			{
				DestroyAllZombies();
				return;
			}
			float time = Time.time;
			bool flag = time >= _nextZombieLifetimeCheckTime;
			bool flag2 = time >= _nextZombieDistanceCheckTime;
			if (!flag && !flag2)
			{
				return;
			}
			if (flag)
			{
				_nextZombieLifetimeCheckTime = time + 0.25f;
			}
			if (flag2)
			{
				_nextZombieDistanceCheckTime = time + 0.75f;
			}
			CompactLiveZombieSet();
			float num = float.PositiveInfinity;
			if (flag2)
			{
				num = Mathf.Pow(Mathf.Clamp(Plugin.GetDerivedZombieDestroyDistanceRuntime(), 50f, 150f), 2f);
				CollectAlivePlayers(_alivePlayersBuffer);
			}
			for (int num2 = _zombieTimers.Count - 1; num2 >= 0; num2--)
			{
				ZombieTimer zombieTimer = _zombieTimers[num2];
				if ((Object)(object)zombieTimer.zombie == (Object)null)
				{
					_zombieTimers.RemoveAt(num2);
				}
				else if (flag && time >= zombieTimer.deathTime)
				{
					_zombieTimers.RemoveAt(num2);
					ExpireZombie(zombieTimer.zombie);
				}
				else if (flag2 && GetClosestAlivePlayerDistanceSqr(zombieTimer.zombie.transform.position, _alivePlayersBuffer) > num)
				{
					_zombieTimers.RemoveAt(num2);
					DestroyZombie(zombieTimer.zombie);
				}
			}
		}

		private static int GetCurrentZombieCount()
		{
			CompactLiveZombieSet();
			return _liveZombies.Count;
		}

		private static float GetClosestAlivePlayerDistanceSqr(Vector3 position, List<Character> alivePlayers)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (alivePlayers == null || alivePlayers.Count == 0)
			{
				return float.PositiveInfinity;
			}
			float num = float.PositiveInfinity;
			foreach (Character alivePlayer in alivePlayers)
			{
				if (!((Object)(object)alivePlayer == (Object)null))
				{
					Vector3 val = alivePlayer.Center - position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
					}
				}
			}
			return num;
		}

		private static Vector3 GetPlayersCenter()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//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_0047: 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_004e: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (Character.AllCharacters == null || Character.AllCharacters.Count == 0)
			{
				return Vector3.zero;
			}
			Vector3 val = Vector3.zero;
			int num = 0;
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if ((Object)(object)allCharacter != (Object)null && !allCharacter.isBot)
				{
					val += allCharacter.Center;
					num++;
				}
			}
			if (num <= 0)
			{
				return Vector3.zero;
			}
			return val / (float)num;
		}

		private static int CollectAlivePlayers(List<Character> buffer)
		{
			if (buffer == null)
			{
				return 0;
			}
			buffer.Clear();
			if (Character.AllCharacters == null)
			{
				return 0;
			}
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (IsSpawnTargetCandidate(allCharacter))
				{
					buffer.Add(allCharacter);
				}
			}
			return buffer.Count;
		}

		private static bool IsSpawnTargetCandidate(Character character)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || character.isBot || character.isZombie)
			{
				return false;
			}
			if (!((Object)(object)((Component)character).gameObject == (Object)null))
			{
				Scene scene = ((Component)character).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					try
					{
						if ((Object)(object)character.data == (Object)null || character.data.dead || character.data.passedOut || character.data.fullyPassedOut || character.warping)
						{
							return false;
						}
						return IsFiniteVector(character.Center);
					}
					catch (Exception)
					{
						return false;
					}
				}
			}
			return false;
		}

		private static bool IsFiniteVector(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!float.IsNaN(value.x) && !float.IsNaN(value.y) && !float.IsNaN(value.z) && !float.IsInfinity(value.x) && !float.IsInfinity(value.y))
			{
				return !float.IsInfinity(value.z);
			}
			return false;
		}

		private static float GetNextSpawnDelay(bool firstWave = false)
		{
			float num = Mathf.Max(Plugin.ZombieSpawnInterval.Value, 1f);
			float num2 = Mathf.Max(Plugin.GetDerivedZombieSpawnIntervalRandomRangeRuntime(), 0f);
			float num3 = Mathf.Max(num + Random.Range(0f - num2, num2), 1f);
			if (!firstWave)
			{
				return num3;
			}
			return Mathf.Clamp(num3 * 0.75f, 3f, 30f);
		}

		private static float GetNextWaveSpawnSpacing(int spawnedInWave)
		{
			float num = 0.85f;
			if (spawnedInWave <= 0)
			{
				num = Mathf.Min(num, 0.45f);
			}
			return Random.Range(0.25f, num);
		}

		private static int GetNextSpawnCount()
		{
			return GetSpawnCountForRemainingCapacity(Plugin.GetDerivedZombieWaveSpawnCountRuntime(), GetCurrentZombieCount(), Mathf.Max(Plugin.MaxZombies.Value, 0));
		}

		private static int GetSpawnCountForRemainingCapacity(int requestedCount, int currentZombieCount, int maxZombieCount)
		{
			if (requestedCount <= 0 || maxZombieCount <= 0)
			{
				return 0;
			}
			int num = Mathf.Max(maxZombieCount - Mathf.Max(currentZombieCount, 0), 0);
			if (num <= 0)
			{
				return 0;
			}
			return Mathf.Min(requestedCount, num);
		}

		private static bool TryGetSpawnPosition(out Vector3 position, out Character targetPlayer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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)
			position = Vector3.zero;
			targetPlayer = null;
			List<Character> alivePlayersBuffer = _alivePlayersBuffer;
			CollectAlivePlayers(alivePlayersBuffer);
			if (alivePlayersBuffer.Count == 0)
			{
				return false;
			}
			float num = Mathf.Max(Plugin.GetDerivedZombieSpawnRadiusRuntime(), 8f);
			float num2 = Mathf.Max(Mathf.Min(num * 0.45f, num - 1f), Mathf.Min(6.5f, num * 0.75f));
			float wavePositionSpacing = Mathf.Clamp(num * 0.42f, 5.5f, Mathf.Max(num2, 5.5f));
			int num3 = Mathf.CeilToInt(24f);
			int num4 = Random.Range(0, alivePlayersBuffer.Count);
			for (int i = 0; i < 40; i++)
			{
				Character val = alivePlayersBuffer[(num4 + i + Random.Range(0, alivePlayersBuffer.Count)) % alivePlayersBuffer.Count];
				if (!((Object)(object)val == (Object)null) && TryBuildSpawnCandidate(val, alivePlayersBuffer, num2, num, wavePositionSpacing, i < num3, out var position2))
				{
					position = position2;
					targetPlayer = val;
					return true;
				}
			}
			return false;
		}

		private static void CompactLiveZombieSet()
		{
			if (_liveZombies.Count == 0)
			{
				return;
			}
			_staleZombieBuffer.Clear();
			foreach (GameObject liveZombie in _liveZombies)
			{
				if ((Object)(object)liveZombie == (Object)null)
				{
					_staleZombieBuffer.Add(liveZombie);
				}
			}
			for (int i = 0; i < _staleZombieBuffer.Count; i++)
			{
				_liveZombies.Remove(_staleZombieBuffer[i]);
			}
			_staleZombieBuffer.Clear();
		}

		private static void DestroyAllZombies()
		{
			if (_liveZombies.Count != 0)
			{
				_staleZombieBuffer.Clear();
				foreach (GameObject liveZombie in _liveZombies)
				{
					if ((Object)(object)liveZombie != (Object)null)
					{
						_staleZombieBuffer.Add(liveZombie);
					}
				}
				for (int i = 0; i < _staleZombieBuffer.Count; i++)
				{
					DestroyZombie(_staleZombieBuffer[i]);
				}
				_staleZombieBuffer.Clear();
			}
			ClearZombies();
		}

		private static bool TryBuildSpawnCandidate(Character targetPlayer, List<Character> players, float minRadius, float maxRadius, float wavePositionSpacing, bool preferFront, out Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			if ((Object)(object)targetPlayer == (Object)null)
			{
				return false;
			}
			Vector3 playerFacing = GetPlayerFacing(targetPlayer);
			for (int i = 0; i < 6; i++)
			{
				Vector3 candidateSpawnDirection = GetCandidateSpawnDirection(playerFacing, preferFront);
				float num = Random.Range(minRadius, maxRadius);
				Vector3 groundedPosition = targetPlayer.Center + candidateSpawnDirection * num + Vector3.up * 2f;
				if (TryFindSupportedSpawnPosition(groundedPosition, targetPlayer, out groundedPosition) && IsSpawnPositionValid(groundedPosition, players, minRadius * 0.8f, wavePositionSpacing) && IsSpawnPositionStealthy(groundedPosition, players, targetPlayer, preferFront))
				{
					position = groundedPosition;
					return true;
				}
			}
			return false;
		}

		private static bool IsSpawnPositionValid(Vector3 position, List<Character> players, float minDistance, float wavePositionSpacing)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (position == Vector3.zero)
			{
				return false;
			}
			foreach (Character player in players)
			{
				if (!((Object)(object)player == (Object)null))
				{
					Vector3 center = player.Center;
					center.y = position.y;
					if (Vector3.Distance(position, center) < minDistance)
					{
						return false;
					}
				}
			}
			foreach (GameObject liveZombie in _liveZombies)
			{
				if ((Object)(object)liveZombie != (Object)null && Vector3.Distance(position, liveZombie.transform.position) < 3f)
				{
					return false;
				}
			}
			foreach (Vector3 waveSpawnPosition in _waveSpawnPositions)
			{
				Vector3 current3 = waveSpawnPosition;
				current3.y = position.y;
				if (Vector3.Distance(position, current3) < wavePositionSpacing)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsSpawnPositionStealthy(Vector3 position, List<Character> players, Character primaryPlayer, bool preferFront)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)primaryPlayer == (Object)null)
			{
				return false;
			}
			if (preferFront && IsBehindPlayer(primaryPlayer, position))
			{
				return false;
			}
			if (!preferFront && !IsBehindPlayer(primaryPlayer, position))
			{
				return false;
			}
			return !IsPositionVisibleToAnyPlayer(position, players);
		}

		private static Vector3 GetCandidateSpawnDirection(Vector3 playerFacing, bool preferFront)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector3)(ref playerFacing)).sqrMagnitude < 0.0001f)
			{
				playerFacing = Vector3.forward;
			}
			float num = Random.Range(preferFront ? (-70f) : (-75f), preferFront ? 70f : 75f);
			Vector3 val = (preferFront ? playerFacing : (playerFacing * -1f));
			Vector3 val2 = Vector3.ProjectOnPlane(Quaternion.AngleAxis(num, Vector3.up) * val, Vector3.up);
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			if (((Vector3)(ref normalized)).sqrMagnitude >= 0.0001f)
			{
				return normalized;
			}
			if (!preferFront)
			{
				return Vector3.back;
			}
			return Vector3.forward;
		}

		private static bool IsPositionVisibleToAnyPlayer(Vector3 position, List<Character> players)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			foreach (Character player in players)
			{
				if (!((Object)(object)player == (Object)null) && IsPositionVisibleToPlayer(player, position))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsPositionVisibleToPlayer(Character player, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			Vector3 playerViewOrigin = GetPlayerViewOrigin(player);
			Vector3 val = position + Vector3.up * 1.2f;
			Vector3 val2 = val - playerViewOrigin;
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			float num = Vector3.Distance(playerViewOrigin, val);
			if (num <= 0.1f)
			{
				return true;
			}
			if (Vector3.Dot(GetPlayerFacing(player), normalized) < Mathf.Cos(0.9599311f))
			{
				return false;
			}
			RaycastHit val3 = default(RaycastHit);
			if (!Physics.Raycast(playerViewOrigin, normalized, ref val3, Mathf.Max(num - 0.2f, 0.01f), -1, (QueryTriggerInteraction)1))
			{
				return true;
			}
			return IsPartOfCharacter(((RaycastHit)(ref val3)).transform, player);
		}

		private static bool IsPartOfCharacter(Transform hitTransform, Character player)
		{
			if ((Object)(object)hitTransform == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			if (hitTransform.IsChildOf(((Component)player).transform))
			{
				return true;
			}
			return (Object)(object)((Component)hitTransform).GetComponentInParent<Character>() == (Object)(object)player;
		}

		private static bool IsDirectionAccepted(Vector3 playerFacing, Vector3 candidateDirection, bool preferRear)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			float num = Vector3.Dot(playerFacing, ((Vector3)(ref candidateDirection)).normalized);
			if (preferRear)
			{
				return num <= 0.05f;
			}
			return num > 0.05f;
		}

		private static bool IsBehindPlayer(Character player, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			Vector3 playerFacing = GetPlayerFacing(player);
			Vector3 val = Vector3.ProjectOnPlane(position - player.Center, Vector3.up);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if (((Vector3)(ref normalized)).sqrMagnitude < 0.0001f)
			{
				return false;
			}
			return Vector3.Dot(playerFacing, normalized) <= 0.05f;
		}

		private static Vector3 GetPlayerFacing(Character player)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//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_0050: 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_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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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)
			if ((Object)(object)player == (Object)null)
			{
				return Vector3.forward;
			}
			Vector3 val = Vector3.ProjectOnPlane((((Object)(object)player.refs?.view != (Object)null) ? ((Component)player.refs.view).transform : ((Component)player).transform).forward, Vector3.up);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if (((Vector3)(ref normalized)).sqrMagnitude >= 0.0001f)
			{
				return normalized;
			}
			val = Vector3.ProjectOnPlane(((Component)player).transform.forward, Vector3.up);
			normalized = ((Vector3)(ref val)).normalized;
			if (((Vector3)(ref normalized)).sqrMagnitude >= 0.0001f)
			{
				return normalized;
			}
			return Vector3.forward;
		}

		private static Vector3 GetPlayerViewOrigin(Character player)
		{
			//IL_0009: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return Vector3.zero;
			}
			if ((Object)(object)player.refs?.view != (Object)null)
			{
				return ((Component)player.refs.view).transform.position;
			}
			return player.Center + Vector3.up * 0.35f;
		}

		private static bool TryFindSupportedSpawnPosition(Vector3 probePosition, Character targetPlayer, out Vector3 groundedPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			groundedPosition = Vector3.zero;
			if (!TryGetGroundHit(probePosition, out var hit))
			{
				return false;
			}
			if (!IsGroundStandable(((RaycastHit)(ref hit)).normal))
			{
				return false;
			}
			Vector3 val = ((RaycastHit)(ref hit)).point + Vector3.up * 0.08f;
			if (!IsSpawnHeightCompatible(val, targetPlayer))
			{
				return false;
			}
			if (!HasSpawnHeadroom(val))
			{
				return false;
			}
			if (!HasStableGroundSupport(val))
			{
				return false;
			}
			groundedPosition = val;
			return true;
		}

		private static bool TryGetGroundHit(Vector3 probePosition, out RaycastHit hit)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return Physics.Raycast(probePosition + Vector3.up * 12f, Vector3.down, ref hit, 60f, -1, (QueryTriggerInteraction)1);
		}

		private static bool IsGroundStandable(Vector3 normal)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector3)(ref normal)).sqrMagnitude < 0.0001f)
			{
				return false;
			}
			return Vector3.Angle(normal, Vector3.up) <= 47f;
		}

		private static bool IsSpawnHeightCompatible(Vector3 position, Character targetPlayer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetPlayer == (Object)null)
			{
				return true;
			}
			float num = position.y - targetPlayer.Center.y;
			if (num >= -2.75f)
			{
				return num <= 6.5f;
			}
			return false;
		}

		private static bool HasSpawnHeadroom(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = position + Vector3.up * 0.55f;
			Vector3 val2 = position + Vector3.up * 1.55f;
			return !Physics.CheckCapsule(val, val2, 0.24f, -1, (QueryTriggerInteraction)1);
		}

		private static bool HasStableGroundSupport(Vector3 position)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 6; i++)
			{
				float num = (float)i / 6f * (float)Math.PI * 2f;
				if (!TryGetGroundHit(position + new Vector3(Mathf.Cos(num), 0f, Mathf.Sin(num)) * 0.85f, out var hit))
				{
					return false;
				}
				if (!IsGroundStandable(((RaycastHit)(ref hit)).normal))
				{
					return false;
				}
				if (Mathf.Abs(((RaycastHit)(ref hit)).point.y - position.y) > 1.1f)
				{
					return false;
				}
			}
			return true;
		}

		private static Quaternion GetSpawnRotation(Vector3 spawnPosition, Character targetPlayer)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetPlayer == (Object)null)
			{
				return Random.rotation;
			}
			Vector3 val = Vector3.ProjectOnPlane(targetPlayer.Center - spawnPosition, Vector3.up);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if (((Vector3)(ref normalized)).sqrMagnitude < 0.0001f)
			{
				return Random.rotation;
			}
			return Quaternion.LookRotation(normalized, Vector3.up);
		}
	}
}