using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
using ZoomyEyes.Config;
using ZoomyEyes.Controllers;
using ZoomyEyes.Patches;
using ZoomyEyes.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("REPOZoomyEyes")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("REPOZoomyEyes")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("ca40feb7-1f42-46cf-818f-e3cd22d1b372")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ZoomyEyes
{
	[BepInPlugin("ZoomyEyes", "ZoomyEyes", "1.1.0")]
	public class ZoomyEyesPlugin : BaseUnityPlugin
	{
		public enum ZoomState
		{
			Default,
			ZoomedIn,
			ZoomedOut
		}

		public class SoundTransition
		{
			public AudioClip Clip;

			public float Pitch;
		}

		public const string PLUGIN_GUID = "ZoomyEyes";

		public const string PLUGIN_NAME = "ZoomyEyes";

		public const string PLUGIN_VERSION = "1.1.0";

		public static ZoomyEyesPlugin Instance;

		private readonly Harmony harmony = new Harmony("ZoomyEyes");

		internal static ManualLogSource Log;

		public const float TRANSITION_SPEED = 5f;

		public const float EASING_DURATION = 0.3f;

		public const float ZOOM_IN_PITCH = 1.2f;

		public const float ZOOM_OUT_PITCH = 0.8f;

		public const bool ENABLE_SCROLL_WHEEL = true;

		public const float SCROLL_NETWORK_THROTTLE = 0.1f;

		public const float SCROLL_SMOOTHING_FACTOR = 0.3f;

		public static Dictionary<string, float> lastKnownFieldValues = new Dictionary<string, float>();

		public static ConfigEntry<KeyCode> ZoomKey;

		public static ConfigEntry<bool> EnableDebugLogging;

		public static ConfigEntry<bool> InvertPupilZoom;

		public static ConfigEntry<bool> EnableSounds;

		public static ConfigEntry<float> SoundVolume;

		public static ConfigEntry<float> DefaultNormalPupilSize;

		public static AudioClip DefaultZoomSound;

		public static AudioClip DefaultUnZoomSound;

		public static ConfigEntry<float> DefaultPupilSize;

		public static ConfigEntry<float> ZoomedInPupilSize;

		public static ConfigEntry<float> ZoomedOutPupilSize;

		public static ConfigEntry<float> DefaultZoomFOVMultiplier;

		public static ConfigEntry<float> ZoomedInFOVMultiplier;

		public static ConfigEntry<float> ZoomedOutFOVMultiplier;

		internal static List<Camera> playerCameras = new List<Camera>();

		public static Dictionary<(ZoomState from, ZoomState to), SoundTransition> SoundTransitions = new Dictionary<(ZoomState, ZoomState), SoundTransition>();

		public static float NORMAL_PUPIL_SIZE => DefaultNormalPupilSize.Value;

		private void Awake()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Log = ((BaseUnityPlugin)this).Logger;
			ZoomKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "ZoomKey", (KeyCode)122, "Key to zoom eyes and FOV");
			InvertPupilZoom = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "InvertPupilZoom", true, "If disabled, pupils will grow larger when zoomed out and smaller when zoomed in");
			DefaultNormalPupilSize = ((BaseUnityPlugin)this).Config.Bind<float>("General", "NormalPupilSize", 1f, new ConfigDescription("Default pupil size when not zooming (1.0 is game default)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 3f), Array.Empty<object>()));
			EnableSounds = ((BaseUnityPlugin)this).Config.Bind<bool>("Sound", "EnableSounds", true, "Enable zoom sound effects");
			SoundVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Sound", "SoundVolume", 0.5f, new ConfigDescription("Volume for zoom sound effects (0.0-1.0)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			DefaultPupilSize = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom Levels", "DefaultPupilSize", 2f, new ConfigDescription("Default pupil size when the zoom key is pressed", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1.6f, 2.4f), Array.Empty<object>()));
			ZoomedInPupilSize = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom Levels", "ZoomedInPupilSize", 0.2f, new ConfigDescription("Pupil size when zoomed in (scroll up)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.5f), Array.Empty<object>()));
			ZoomedOutPupilSize = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom Levels", "ZoomedOutPupilSize", 3f, new ConfigDescription("Pupil size when zoomed out (scroll down)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2.5f, 4f), Array.Empty<object>()));
			DefaultZoomFOVMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom Levels", "DefaultZoomFOVMultiplier", 0.8f, new ConfigDescription("Default FOV multiplier when the zoom key is pressed", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.6f, 1f), Array.Empty<object>()));
			ZoomedInFOVMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom Levels", "ZoomedInFOVMultiplier", 0.5f, new ConfigDescription("FOV multiplier when zoomed in", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 0.7f), Array.Empty<object>()));
			ZoomedOutFOVMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Zoom Levels", "ZoomedOutFOVMultiplier", 1.4f, new ConfigDescription("FOV multiplier when zoomed out", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1.2f, 1.8f), Array.Empty<object>()));
			EnableDebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableDebugLogging", false, "Enable additional debug logging");
			Log.LogInfo((object)"Plugin ZoomyEyes is loading...");
			InitializeSoundTransitions();
			LoadAudioFiles();
			harmony.PatchAll();
			Log.LogInfo((object)"Plugin ZoomyEyes is loaded!");
			if (InvertPupilZoom.Value)
			{
				Log.LogInfo((object)"Pupil zoom inversion is enabled - pupils will dilate when zoomed in and contract when zoomed out");
			}
			Log.LogInfo((object)$"Default normal pupil size set to: {DefaultNormalPupilSize.Value}");
			DefaultNormalPupilSize.SettingChanged += delegate
			{
				ApplyNormalPupilSizeToAll();
				Log.LogInfo((object)$"Normal pupil size changed to: {DefaultNormalPupilSize.Value}");
			};
		}

		private void InitializeSoundTransitions()
		{
			SoundTransitions[(ZoomState.Default, ZoomState.ZoomedIn)] = new SoundTransition
			{
				Clip = DefaultZoomSound,
				Pitch = 1.4f
			};
			SoundTransitions[(ZoomState.ZoomedIn, ZoomState.Default)] = new SoundTransition
			{
				Clip = DefaultUnZoomSound,
				Pitch = 0.8f
			};
			SoundTransitions[(ZoomState.Default, ZoomState.ZoomedOut)] = new SoundTransition
			{
				Clip = DefaultUnZoomSound,
				Pitch = 0.6f
			};
			SoundTransitions[(ZoomState.ZoomedOut, ZoomState.Default)] = new SoundTransition
			{
				Clip = DefaultZoomSound,
				Pitch = 1.2f
			};
		}

		public static void LogMenuPageColorText(MenuPageColor menuPage)
		{
			//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_00cf: 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_00ed: 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_013f: 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_0229: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				TextMeshProUGUI[] componentsInChildren = ((Component)menuPage).GetComponentsInChildren<TextMeshProUGUI>(true);
				Log.LogInfo((object)$"Found {componentsInChildren.Length} TextMeshProUGUI components in MenuPageColor menu");
				TextMeshProUGUI[] array = componentsInChildren;
				foreach (TextMeshProUGUI val in array)
				{
					if ((Object)(object)val != (Object)null)
					{
						string gameObjectPath = GetGameObjectPath(((TMP_Text)val).transform);
						Color color = ((Graphic)val).color;
						Log.LogInfo((object)("Text '" + ((Object)((Component)val).gameObject).name + "' at path '" + gameObjectPath + "':"));
						Log.LogInfo((object)("  Content: \"" + ((TMP_Text)val).text + "\""));
						Log.LogInfo((object)$"  Color: R={color.r:F2}, G={color.g:F2}, B={color.b:F2}, A={color.a:F2}");
						Log.LogInfo((object)$"  Font Size: {((TMP_Text)val).fontSize}");
						Log.LogInfo((object)$"  Font Style: {((TMP_Text)val).fontStyle}");
						Log.LogInfo((object)$"  Alignment: {((TMP_Text)val).alignment}");
						ManualLogSource log = Log;
						TMP_FontAsset font = ((TMP_Text)val).font;
						log.LogInfo((object)("  Font: " + (((font != null) ? ((Object)font).name : null) ?? "null")));
						Log.LogInfo((object)$"  Enable Auto Sizing: {((TMP_Text)val).enableAutoSizing}");
						if (((TMP_Text)val).text.Contains("Color"))
						{
							Log.LogInfo((object)"  ** This appears to be the 'Select Color' text **");
							ManualLogSource log2 = Log;
							Material material = ((Graphic)val).material;
							log2.LogInfo((object)("  Material: " + (((material != null) ? ((Object)material).name : null) ?? "null")));
							Log.LogInfo((object)$"  Margin: {((TMP_Text)val).margin}");
							Log.LogInfo((object)$"  Character Spacing: {((TMP_Text)val).characterSpacing}");
							Log.LogInfo((object)$"  Word Spacing: {((TMP_Text)val).wordSpacing}");
							Log.LogInfo((object)$"  Line Spacing: {((TMP_Text)val).lineSpacing}");
							Log.LogInfo((object)$"  Paragraph Spacing: {((TMP_Text)val).paragraphSpacing}");
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error inspecting menu text: " + ex.Message));
			}
		}

		private static string GetGameObjectPath(Transform transform)
		{
			string text = ((Object)transform).name;
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private void LoadAudioFiles()
		{
			try
			{
				string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				string text = Path.Combine(directoryName, "DefaultZoomSound.wav");
				if (File.Exists(text))
				{
					DefaultZoomSound = LoadWavFileAsAudioClip(text, "DefaultZoomSound");
					Log.LogInfo((object)"Loaded DefaultZoomSound.wav successfully");
				}
				else
				{
					Log.LogWarning((object)("Could not find DefaultZoomSound.wav at path: " + text));
					Log.LogWarning((object)"Place the sound file in your BepInEx/plugins/ZoomyEyes folder");
				}
				string text2 = Path.Combine(directoryName, "DefaultUnZoomSound.wav");
				if (File.Exists(text2))
				{
					DefaultUnZoomSound = LoadWavFileAsAudioClip(text2, "DefaultUnZoomSound");
					Log.LogInfo((object)"Loaded DefaultUnZoomSound.wav successfully");
				}
				else
				{
					Log.LogWarning((object)("Could not find DefaultUnZoomSound.wav at path: " + text2));
					Log.LogWarning((object)"Place the sound file in your BepInEx/plugins/ZoomyEyes folder");
					if ((Object)(object)DefaultZoomSound != (Object)null)
					{
						Log.LogInfo((object)"Using DefaultZoomSound.wav as a fallback for unzoom sound");
						DefaultUnZoomSound = DefaultZoomSound;
					}
				}
				InitializeSoundTransitions();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error loading audio files: " + ex.Message));
			}
		}

		private AudioClip LoadWavFileAsAudioClip(string filePath, string clipName)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			try
			{
				string text = "file://" + filePath;
				UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip(text, (AudioType)20);
				UnityWebRequestAsyncOperation val = audioClip.SendWebRequest();
				while (!((AsyncOperation)val).isDone)
				{
					Thread.Sleep(10);
				}
				if ((int)audioClip.result != 1)
				{
					Log.LogError((object)("Error loading audio file: " + audioClip.error));
					return null;
				}
				AudioClip content = DownloadHandlerAudioClip.GetContent(audioClip);
				((Object)content).name = clipName;
				return content;
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error loading WAV file " + filePath + ": " + ex.Message));
				return null;
			}
		}

		public static bool IsInMainMenu()
		{
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return true;
			}
			return (Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelMainMenu;
		}

		public static void DebugLog(string message)
		{
			if (EnableDebugLogging.Value)
			{
				Log.LogInfo((object)("[DEBUG] " + message));
			}
		}

		public static SoundTransition GetSoundTransition(ZoomState fromState, ZoomState toState)
		{
			if (SoundTransitions.TryGetValue((fromState, toState), out var value))
			{
				return value;
			}
			bool flag = IsZoomingIn(fromState, toState);
			return new SoundTransition
			{
				Clip = (flag ? DefaultZoomSound : DefaultUnZoomSound),
				Pitch = (flag ? 1.2f : 0.8f)
			};
		}

		public static bool IsZoomingIn(ZoomState fromState, ZoomState toState)
		{
			if (fromState == ZoomState.ZoomedOut && toState == ZoomState.Default)
			{
				return true;
			}
			if (fromState == ZoomState.Default && toState == ZoomState.ZoomedIn)
			{
				return true;
			}
			return false;
		}

		public static void PlaySoundAtPosition(AudioClip clip, Vector3 position, float pitch = 1f, float volume = 1f)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0033: 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)
			if (!EnableSounds.Value || (Object)(object)clip == (Object)null)
			{
				return;
			}
			try
			{
				GameObject val = new GameObject("TempAudio");
				val.transform.position = position;
				AudioSource val2 = val.AddComponent<AudioSource>();
				val2.clip = clip;
				val2.volume = volume * SoundVolume.Value;
				val2.pitch = pitch;
				val2.spatialBlend = 1f;
				val2.minDistance = 1f;
				val2.maxDistance = 15f;
				val2.rolloffMode = (AudioRolloffMode)1;
				val2.Play();
				Object.Destroy((Object)(object)val, clip.length / pitch + 0.1f);
				DebugLog($"Playing sound {((Object)clip).name} at position {position} with pitch {pitch}");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error playing sound: " + ex.Message));
			}
		}

		public static void ApplyNormalPupilSizeToAll()
		{
			try
			{
				if (IsInMainMenu())
				{
					return;
				}
				List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
				foreach (PlayerAvatar item in list)
				{
					if ((Object)(object)item.photonView != (Object)null)
					{
						int viewID = item.photonView.ViewID;
						if (item.photonView.IsMine)
						{
							PupilStateManager.SetDefaultSize(viewID, DefaultNormalPupilSize.Value);
						}
					}
				}
				PupilStateManager.UpdateMenuAvatarPupils();
				DebugLog($"Applied normal pupil size to all players: {DefaultNormalPupilSize.Value}");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error applying normal pupil size: " + ex.Message));
			}
		}
	}
}
namespace ZoomyEyes.UI
{
	public class SliderValueHandler : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayedDiagnostics>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public SliderValueHandler <>4__this;

			private float <configValue>5__1;

			private float <normalizedValue>5__2;

			private Transform <barText>5__3;

			private TextMeshProUGUI <textComponent>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<barText>5__3 = null;
				<textComponent>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)<>4__this.slider != (Object)null)
					{
						<configValue>5__1 = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
						<normalizedValue>5__2 = <>4__this.NormalizedPupilSizeToSliderValue(<configValue>5__1);
						ZoomyEyesPlugin.DebugLog($"DEBUG: After delay - Original slider value would be {PupilSliderConfig.PupilSizeToSliderValue(<configValue>5__1):F1}");
						ZoomyEyesPlugin.DebugLog($"DEBUG: After delay - Trying normalized value (0-1): {<normalizedValue>5__2:F3}");
						<>4__this.slider.SetBar(<normalizedValue>5__2);
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					<barText>5__3 = ((Component)<>4__this.slider).transform.Find("Bar Text");
					if ((Object)(object)<barText>5__3 != (Object)null)
					{
						<textComponent>5__4 = ((Component)<barText>5__3).GetComponent<TextMeshProUGUI>();
						if ((Object)(object)<textComponent>5__4 != (Object)null)
						{
							ZoomyEyesPlugin.DebugLog("DEBUG: After setting normalized value - Text shows: " + ((TMP_Text)<textComponent>5__4).text);
						}
						<textComponent>5__4 = null;
					}
					<barText>5__3 = null;
					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 MenuSlider slider;

		private bool initialized = false;

		private float lastSetValue = -1f;

		public void Initialize(MenuSlider slider)
		{
			this.slider = slider;
			initialized = true;
			RefreshSliderPosition();
			((MonoBehaviour)this).StartCoroutine(DelayedDiagnostics());
		}

		[IteratorStateMachine(typeof(<DelayedDiagnostics>d__4))]
		private IEnumerator DelayedDiagnostics()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedDiagnostics>d__4(0)
			{
				<>4__this = this
			};
		}

		private float NormalizedPupilSizeToSliderValue(float pupilSize)
		{
			float num = PupilSliderConfig.MaxPupilSize - PupilSliderConfig.MinPupilSize;
			return (pupilSize - PupilSliderConfig.MinPupilSize) / num;
		}

		public void RefreshSliderPosition()
		{
			if (initialized && !((Object)(object)slider == (Object)null))
			{
				float value = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
				float num = NormalizedPupilSizeToSliderValue(value);
				if (Mathf.Abs(num - lastSetValue) > 0.01f)
				{
					slider.SetBar(num);
					lastSetValue = num;
					ZoomyEyesPlugin.DebugLog($"Updated slider position to normalized value: {num:F3} (pupil size: {value:F2})");
				}
			}
		}

		private void OnEnable()
		{
			RefreshSliderPosition();
		}
	}
	public class SliderReinitializer : MonoBehaviour
	{
		public string elementName = "";

		public MenuSlider menuSlider;

		public float startValue;

		public void Start()
		{
			try
			{
				if (!((Object)(object)menuSlider != (Object)null))
				{
					return;
				}
				menuSlider.elementName = elementName;
				Transform val = ((Component)this).transform.Find("Element Name");
				if ((Object)(object)val != (Object)null)
				{
					TextMeshProUGUI component = ((Component)val).GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component != (Object)null)
					{
						((TMP_Text)component).SetText(elementName, true);
					}
				}
				((Object)((Component)this).gameObject).name = "Slider - " + elementName;
				if (elementName == "Pupil Size")
				{
					float value = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
					float num = PupilSliderConfig.MaxPupilSize - PupilSliderConfig.MinPupilSize;
					startValue = (value - PupilSliderConfig.MinPupilSize) / num;
					ZoomyEyesPlugin.DebugLog($"Initializing slider with config value {value:F2} -> normalized position {startValue:F3}");
					float num2 = PupilSliderConfig.SliderValueToPupilSize(startValue);
					ZoomyEyesPlugin.DefaultNormalPupilSize.Value = num2;
					ZoomyEyesPlugin.DebugLog($"Updated pupil size config during initialization: {num2:F2}");
				}
				menuSlider.SetBar(startValue);
				if (!(elementName == "Pupil Size"))
				{
					return;
				}
				Transform val2 = ((Component)this).transform.Find("Bar Text");
				if ((Object)(object)val2 != (Object)null)
				{
					TextMeshProUGUI component2 = ((Component)val2).GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component2 != (Object)null)
					{
						PupilSizeTextUpdater pupilSizeTextUpdater = ((Component)this).gameObject.AddComponent<PupilSizeTextUpdater>();
						pupilSizeTextUpdater.Initialize(component2);
						ZoomyEyesPlugin.Log.LogInfo((object)"Added text updater in SliderReinitializer");
					}
				}
				PupilStateManager.UpdateMenuAvatarPupils();
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in SliderReinitializer.Start: " + ex.Message));
			}
		}
	}
	public class PupilSizeTextUpdater : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ApplyInitialValueWithDelay>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PupilSizeTextUpdater <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: 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;
					PupilStateManager.UpdateMenuAvatarPupils();
					ZoomyEyesPlugin.DebugLog("Applied initial pupil size after delay");
					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 <ApplyPendingUpdate>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PupilSizeTextUpdater <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(<>4__this.dragEndDelay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (<>4__this.pendingPupilSize >= 0f)
					{
						<>4__this.RequestPupilSizeUpdate(<>4__this.pendingPupilSize);
						<>4__this.pendingPupilSize = -1f;
					}
					<>4__this.pendingUpdateCoroutine = 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 TextMeshProUGUI mainTextComponent;

		private TextMeshProUGUI maskedTextComponent;

		private string lastSetText = "";

		private float lastUpdateTime = 0f;

		private float updateDelay = 0.1f;

		private float dragEndDelay = 0.3f;

		private float pendingPupilSize = -1f;

		private Coroutine pendingUpdateCoroutine = null;

		public void Initialize(TextMeshProUGUI mainText)
		{
			mainTextComponent = mainText;
			Transform val = ((Component)this).transform.Find("MaskedText");
			if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf)
			{
				Transform val2 = val.Find("Bar Text (1)");
				if ((Object)(object)val2 != (Object)null)
				{
					maskedTextComponent = ((Component)val2).GetComponent<TextMeshProUGUI>();
				}
			}
			((MonoBehaviour)this).StartCoroutine(ApplyInitialValueWithDelay());
		}

		[IteratorStateMachine(typeof(<ApplyInitialValueWithDelay>d__9))]
		private IEnumerator ApplyInitialValueWithDelay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyInitialValueWithDelay>d__9(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			try
			{
				UpdateTextIfPercentage(mainTextComponent);
				UpdateTextIfPercentage(maskedTextComponent);
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in PupilSizeTextUpdater: " + ex.Message));
				Object.Destroy((Object)(object)this);
			}
		}

		private void UpdateTextIfPercentage(TextMeshProUGUI textComponent)
		{
			if ((Object)(object)textComponent == (Object)null)
			{
				return;
			}
			string text = ((TMP_Text)textComponent).text;
			if (!text.EndsWith("%") || !float.TryParse(text.TrimEnd(new char[1] { '%' }), out var result))
			{
				return;
			}
			float sliderValue = result / 100f;
			float num = PupilSliderConfig.SliderValueToPupilSize(sliderValue);
			string text3 = (((TMP_Text)textComponent).text = PupilSliderConfig.FormatPupilSizeText(num));
			if (text3 != lastSetText)
			{
				lastSetText = text3;
				ZoomyEyesPlugin.DefaultNormalPupilSize.Value = num;
				pendingPupilSize = num;
				float time = Time.time;
				if (time - lastUpdateTime >= updateDelay)
				{
					lastUpdateTime = time;
					RequestPupilSizeUpdate(num);
				}
				if (pendingUpdateCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(pendingUpdateCoroutine);
				}
				pendingUpdateCoroutine = ((MonoBehaviour)this).StartCoroutine(ApplyPendingUpdate());
				ZoomyEyesPlugin.DebugLog("Updated slider text in Update: " + text3);
			}
		}

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

		private void RequestPupilSizeUpdate(float pupilSize)
		{
			ZoomyEyesPlugin.DefaultNormalPupilSize.Value = pupilSize;
			PupilStateManager.ApplyNormalPupilSizeToAll();
			PupilStateManager.UpdateMenuAvatarPupils();
		}
	}
}
namespace ZoomyEyes.Patches
{
	[HarmonyPatch(typeof(CameraZoom))]
	internal class CameraZoomPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void CapturePlayerCameras(CameraZoom __instance)
		{
			try
			{
				if (__instance.cams == null)
				{
					return;
				}
				ZoomyEyesPlugin.Log.LogInfo((object)$"Found {__instance.cams.Count} cameras in CameraZoom");
				foreach (Camera cam in __instance.cams)
				{
					if ((Object)(object)cam != (Object)null && !ZoomyEyesPlugin.playerCameras.Contains(cam))
					{
						ZoomyEyesPlugin.playerCameras.Add(cam);
						ZoomyEyesPlugin.Log.LogInfo((object)("Added camera: " + ((Object)cam).name + " to tracking list"));
					}
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error capturing cameras: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(MenuPageColor))]
	internal class MenuPageColorPatch
	{
		public static MenuSlider PupilSizeSlider;

		private static bool sliderAdded;

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void AddPupilSizeSlider(MenuPageColor __instance)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = null;
				foreach (MenuPages menuPage2 in MenuManager.instance.menuPages)
				{
					GameObject menuPage = menuPage2.menuPage;
					if (((Object)menuPage).name == "Menu Page Settings Audio")
					{
						Transform val2 = menuPage.transform.Find("Menu Scroll Box");
						Transform val3 = ((val2 != null) ? val2.Find("Mask") : null);
						Transform val4 = ((val3 != null) ? val3.Find("Scroller") : null);
						Transform val5 = ((val4 != null) ? val4.Find("Slider - Master volume") : null);
						if ((Object)(object)val5 != (Object)null)
						{
							val = ((Component)val5).gameObject;
							break;
						}
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					PupilSizeSlider = CreatePupilSizeSlider(val, ((Component)__instance).transform, PupilSliderConfig.SliderPosition, PupilSliderConfig.SliderName);
					((Object)((Component)PupilSizeSlider).gameObject).name = "Slider - Pupil Size";
					AddCustomSliderListener(PupilSizeSlider);
					sliderAdded = true;
					ZoomyEyesPlugin.Log.LogInfo((object)"Added pupil size slider to color menu");
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error adding pupil size slider to color menu: " + ex.Message));
			}
		}

		private static void AddCustomSliderListener(MenuSlider slider)
		{
			try
			{
				SliderValueHandler sliderValueHandler = ((Component)slider).gameObject.AddComponent<SliderValueHandler>();
				sliderValueHandler.Initialize(slider);
				ZoomyEyesPlugin.DebugLog("Added custom slider value handler");
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error adding slider value handler: " + ex.Message));
			}
		}

		private static MenuSlider CreatePupilSizeSlider(GameObject sliderPrefab, Transform parentTransform, Vector3 position, string elementName)
		{
			//IL_000f: 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_0106: 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)
			GameObject val = Object.Instantiate<GameObject>(sliderPrefab, parentTransform);
			val.transform.position = position;
			Transform val2 = val.transform.Find("MaskedText");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(true);
				Transform val3 = val2.Find("Bar Text (1)");
				if ((Object)(object)val3 != (Object)null)
				{
					TextMeshProUGUI component = ((Component)val3).GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component != (Object)null)
					{
						((Graphic)component).color = new Color(0f, 0f, 0f);
					}
				}
			}
			Transform obj = val.transform.Find("SliderBG");
			Transform val4 = ((obj != null) ? obj.Find("RawImage (2)") : null);
			if ((Object)(object)val4 != (Object)null)
			{
				((Component)val4).gameObject.SetActive(false);
			}
			Transform obj2 = val.transform.Find("SliderBG");
			Transform val5 = ((obj2 != null) ? obj2.Find("RawImage (3)") : null);
			if ((Object)(object)val5 != (Object)null)
			{
				((Graphic)((Component)val5).GetComponent<RawImage>()).color = PupilSliderConfig.SliderBackgroundColor;
			}
			Transform val6 = val.transform.Find("Bar");
			if ((Object)(object)val6 != (Object)null)
			{
				Transform val7 = val6.Find("RawImage");
				if ((Object)(object)val7 != (Object)null)
				{
					((Graphic)((Component)val7).GetComponent<RawImage>()).color = PupilSliderConfig.SliderBarColor;
				}
			}
			MenuSlider component2 = val.GetComponent<MenuSlider>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.pointerSegmentJump = 1;
				component2.buttonSegmentJump = 1;
			}
			MenuSetting component3 = val.GetComponent<MenuSetting>();
			if ((Object)(object)component3 != (Object)null)
			{
				Object.Destroy((Object)(object)component3);
			}
			MenuSettingElement component4 = val.GetComponent<MenuSettingElement>();
			if ((Object)(object)component4 != (Object)null)
			{
				Object.Destroy((Object)(object)component4);
			}
			SliderReinitializer sliderReinitializer = val.AddComponent<SliderReinitializer>();
			sliderReinitializer.menuSlider = component2;
			sliderReinitializer.elementName = elementName;
			float value = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
			ZoomyEyesPlugin.DebugLog(string.Format(arg1: sliderReinitializer.startValue = PupilSliderConfig.PupilSizeToSliderValue(value), format: "Created slider with initial value {0:F2} -> slider position {1:F1}", arg0: value));
			return component2;
		}
	}
	[HarmonyPatch(typeof(MenuSlider), "SetBar")]
	internal class MenuSliderSetBarPatch
	{
		[HarmonyPostfix]
		private static void UpdatePupilSizeText(MenuSlider __instance, float value)
		{
			try
			{
				if (!(__instance.elementName == "Pupil Size"))
				{
					return;
				}
				float num = PupilSliderConfig.SliderValueToPupilSize(value);
				string text = PupilSliderConfig.FormatPupilSizeText(num);
				Transform val = ((Component)__instance).transform.Find("Bar Text");
				if ((Object)(object)val != (Object)null)
				{
					TextMeshProUGUI component = ((Component)val).GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component != (Object)null)
					{
						((TMP_Text)component).text = text;
					}
				}
				Transform val2 = ((Component)__instance).transform.Find("MaskedText");
				if ((Object)(object)val2 != (Object)null && ((Component)val2).gameObject.activeSelf)
				{
					Transform val3 = val2.Find("Bar Text (1)");
					if ((Object)(object)val3 != (Object)null)
					{
						TextMeshProUGUI component2 = ((Component)val3).GetComponent<TextMeshProUGUI>();
						if ((Object)(object)component2 != (Object)null)
						{
							((TMP_Text)component2).text = text;
						}
					}
				}
				if (value > 0.01f && Mathf.Abs(num - ZoomyEyesPlugin.DefaultNormalPupilSize.Value) > 0.01f)
				{
					ZoomyEyesPlugin.DefaultNormalPupilSize.Value = num;
					PlayerAvatar val4 = FindLocalPlayer();
					if ((Object)(object)val4 != (Object)null && (Object)(object)val4.photonView != (Object)null)
					{
						int viewID = val4.photonView.ViewID;
						PupilStateManager.SetDefaultSize(viewID, num);
					}
					ZoomyEyesPlugin.DebugLog($"Pupil size updated from slider SetBar: {value:F1}% -> {num:F2}");
				}
				ZoomyEyesPlugin.DebugLog("Updated slider text to: " + text);
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error updating slider text: " + ex.Message));
			}
		}

		private static PlayerAvatar FindLocalPlayer()
		{
			PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>();
			PlayerAvatar[] array2 = array;
			foreach (PlayerAvatar val in array2)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.photonView != (Object)null && val.photonView.IsMine)
				{
					return val;
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(MenuPageColor), "ConfirmButton")]
	internal class MenuPageConfirmButtonPatch
	{
		[HarmonyPostfix]
		private static void SavePupilSizeToConfig(MenuPageColor __instance)
		{
			try
			{
				float value = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
				ZoomyEyesPlugin.Log.LogInfo((object)$"Current pupil size before saving: {value}");
				if ((Object)(object)MenuPageColorPatch.PupilSizeSlider != (Object)null)
				{
					Transform val = ((Component)MenuPageColorPatch.PupilSizeSlider).transform.Find("Bar Text");
					if ((Object)(object)val != (Object)null)
					{
						TextMeshProUGUI component = ((Component)val).GetComponent<TextMeshProUGUI>();
						if ((Object)(object)component != (Object)null)
						{
							ZoomyEyesPlugin.Log.LogInfo((object)("Displayed slider text: " + ((TMP_Text)component).text));
						}
					}
				}
				((BaseUnityPlugin)ZoomyEyesPlugin.Instance).Config.Save();
				ZoomyEyesPlugin.Log.LogInfo((object)$"Saved pupil size configuration: {ZoomyEyesPlugin.DefaultNormalPupilSize.Value}");
				PlayerAvatar val2 = FindLocalPlayer();
				if ((Object)(object)val2 != (Object)null)
				{
					int viewID = val2.photonView.ViewID;
					PupilStateManager.SetDefaultSize(viewID, ZoomyEyesPlugin.DefaultNormalPupilSize.Value);
				}
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.photonView != (Object)null && PhotonNetwork.IsConnected && PhotonNetwork.InRoom)
				{
					val2.photonView.RPC("SyncDefaultPupilSize", (RpcTarget)1, new object[1] { ZoomyEyesPlugin.DefaultNormalPupilSize.Value });
					PlayerAvatarPatch.lastSentDefaultPupilSize = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
					ZoomyEyesPlugin.Log.LogInfo((object)"Sent pupil size update after save");
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error saving pupil size config: " + ex.Message));
			}
		}

		private static PlayerAvatar FindLocalPlayer()
		{
			PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>();
			PlayerAvatar[] array2 = array;
			foreach (PlayerAvatar val in array2)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.photonView != (Object)null && val.photonView.IsMine)
				{
					return val;
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	[HarmonyPatch("Start")]
	internal class MenuStartPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			try
			{
				ZoomyEyesPlugin.DebugLog("Menu manager started, updating menu avatar pupils");
				EyeZoomController.UpdateMenuAvatarPupils();
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error updating menu pupils on menu manager start: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar))]
	internal class PlayerAvatarPatch
	{
		[HarmonyPatch(typeof(TruckScreenText))]
		[HarmonyPatch("ArrowPointAtGoalLogic")]
		internal class DefaultPupilSizeMaintainer
		{
			private static PlayerAvatar cachedLocalPlayer = null;

			private static float lastNetworkUpdateTime = 0f;

			private static float networkUpdateInterval = 0.5f;

			[HarmonyPostfix]
			private static void MaintainDefaultPupilSizes()
			{
				if (ZoomyEyesPlugin.IsInMainMenu())
				{
					return;
				}
				if ((Object)(object)cachedLocalPlayer == (Object)null || (Object)(object)cachedLocalPlayer.photonView == (Object)null || !cachedLocalPlayer.photonView.IsMine)
				{
					List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
					foreach (PlayerAvatar item in list)
					{
						if ((Object)(object)item.photonView != (Object)null && item.photonView.IsMine)
						{
							cachedLocalPlayer = item;
							break;
						}
					}
					if ((Object)(object)cachedLocalPlayer == (Object)null)
					{
						return;
					}
				}
				int viewID = cachedLocalPlayer.photonView.ViewID;
				float value = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
				PupilStateManager.SetDefaultSize(viewID, value);
				if (Time.time - lastNetworkUpdateTime >= networkUpdateInterval)
				{
					if (Mathf.Abs(value - lastSentDefaultPupilSize) > 0.01f && PhotonNetwork.IsConnected && PhotonNetwork.InRoom)
					{
						cachedLocalPlayer.photonView.RPC("SyncDefaultPupilSize", (RpcTarget)1, new object[1] { value });
						lastSentDefaultPupilSize = value;
						ZoomyEyesPlugin.DebugLog($"Sent updated default pupil size: {value:F2}");
					}
					lastNetworkUpdateTime = Time.time;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "Update")]
		private class PupilSizeMonitorPatch
		{
			private static FieldInfo multiplierTargetField = AccessTools.Field(typeof(PlayerAvatar), "overridePupilSizeMultiplierTarget");

			private static FieldInfo timerField = AccessTools.Field(typeof(PlayerAvatar), "overridePupilSizeTimer");

			[HarmonyPostfix]
			private static void Postfix(PlayerAvatar __instance)
			{
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.playerAvatarVisuals == (Object)null || (Object)(object)__instance.playerAvatarVisuals.playerEyes == (Object)null)
				{
					return;
				}
				try
				{
					int playerID = -1;
					if ((Object)(object)__instance.photonView != (Object)null)
					{
						playerID = __instance.photonView.ViewID;
					}
					if (!(multiplierTargetField == null) && !(timerField == null))
					{
						float multiplier = (float)multiplierTargetField.GetValue(__instance);
						float num = (float)timerField.GetValue(__instance);
						PupilStateManager.SetOverrideState(playerID, num > 0f, multiplier);
					}
				}
				catch (Exception ex)
				{
					ZoomyEyesPlugin.Log.LogError((object)("Error in pupil size monitor: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(TruckScreenText), "ArrowPointAtGoalLogic")]
		internal class CentralPupilController
		{
			[HarmonyPostfix]
			private static void ApplyPupilSizes()
			{
				if (ZoomyEyesPlugin.IsInMainMenu())
				{
					return;
				}
				try
				{
					PupilStateManager.ApplyPupilSizesToAllPlayers();
				}
				catch (Exception ex)
				{
					ZoomyEyesPlugin.Log.LogError((object)("Error in centralized pupil controller: " + ex.Message));
				}
			}
		}

		private static bool wasZKeyPressed = false;

		private static float lastLogTime = 0f;

		private static readonly float LOG_INTERVAL = 0.5f;

		public static float lastSentDefaultPupilSize = 0f;

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AddEyeZoomController(PlayerAvatar __instance)
		{
			try
			{
				if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.playerAvatarVisuals == (Object)null) && !((Object)(object)__instance.playerAvatarVisuals.playerEyes == (Object)null))
				{
					if ((Object)(object)((Component)__instance).GetComponent<EyeZoomController>() == (Object)null)
					{
						((Component)__instance).gameObject.AddComponent<EyeZoomController>();
						ZoomyEyesPlugin.Log.LogInfo((object)("Added EyeZoomController to player: " + ((Object)__instance).name));
					}
					if ((Object)(object)__instance.photonView != (Object)null)
					{
						int viewID = __instance.photonView.ViewID;
						bool isMine = __instance.photonView.IsMine;
						PupilStateManager.SetPlayerEyes(viewID, __instance.playerAvatarVisuals.playerEyes, isMine);
					}
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in AddEyeZoomController: " + ex.Message));
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void HandleEyeZoom(PlayerAvatar __instance)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (ZoomyEyesPlugin.IsInMainMenu() || (Object)(object)__instance == (Object)null)
				{
					return;
				}
				PhotonView component = ((Component)__instance).GetComponent<PhotonView>();
				if ((Object)(object)component == (Object)null || !component.IsMine)
				{
					return;
				}
				EyeZoomController component2 = ((Component)__instance).GetComponent<EyeZoomController>();
				if ((Object)(object)component2 == (Object)null)
				{
					return;
				}
				bool key = Input.GetKey(ZoomyEyesPlugin.ZoomKey.Value);
				if (key != wasZKeyPressed)
				{
					float currentFOV = component2.GetCurrentFOV();
					wasZKeyPressed = key;
					component2.SetZooming(key, currentFOV);
					if (PhotonNetwork.IsConnected && PhotonNetwork.InRoom)
					{
						try
						{
							component.RPC("SyncEyeZoom", (RpcTarget)1, new object[7]
							{
								key,
								(int)component2.CurrentZoomState,
								ZoomyEyesPlugin.InvertPupilZoom.Value,
								ZoomyEyesPlugin.DefaultPupilSize.Value,
								ZoomyEyesPlugin.ZoomedInPupilSize.Value,
								ZoomyEyesPlugin.ZoomedOutPupilSize.Value,
								ZoomyEyesPlugin.DefaultNormalPupilSize.Value
							});
						}
						catch (Exception ex)
						{
							ZoomyEyesPlugin.Log.LogError((object)("Error sending RPC: " + ex.Message));
						}
					}
				}
				if (key)
				{
					component2.HandleScrollInput();
				}
			}
			catch (Exception ex2)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in HandleEyeZoom: " + ex2.Message));
			}
		}
	}
}
namespace ZoomyEyes.Controllers
{
	public class EyeZoomController : MonoBehaviour
	{
		private PlayerEyes playerEyes;

		private PhotonView photonView;

		private float originalPupilSize = 1f;

		private bool isInFOVTransition = false;

		private float fovStartValue;

		private float fovEndValue;

		private float fovTransitionStartTime;

		private float fovTransitionDuration;

		private float currentFOVValue;

		private float trueCurrentFOV = 70f;

		private bool hasZoomedOnce = false;

		private ZoomyEyesPlugin.ZoomState currentZoomState = ZoomyEyesPlugin.ZoomState.Default;

		private ZoomyEyesPlugin.ZoomState targetZoomState = ZoomyEyesPlugin.ZoomState.Default;

		private ZoomyEyesPlugin.ZoomState previousZoomState = ZoomyEyesPlugin.ZoomState.Default;

		private float lastScrollNetworkUpdate = 0f;

		private bool zoomStateChanged = false;

		private float lastFOVChangeTime = 0f;

		private float minimumFOVChangeInterval = 0.1f;

		private float lastFOVLogTime = 0f;

		private const float FOV_LOG_INTERVAL = 5f;

		private float lastFOVCheckTime = 0f;

		private const float FOV_CHECK_INTERVAL = 0.5f;

		public bool isZooming { get; private set; } = false;


		public ZoomyEyesPlugin.ZoomState CurrentZoomState => currentZoomState;

		private void Awake()
		{
			try
			{
				PlayerAvatar component = ((Component)this).GetComponent<PlayerAvatar>();
				if ((Object)(object)component != (Object)null && (Object)(object)component.playerAvatarVisuals != (Object)null)
				{
					playerEyes = component.playerAvatarVisuals.playerEyes;
					photonView = ((Component)this).GetComponent<PhotonView>();
					originalPupilSize = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
					if ((Object)(object)photonView != (Object)null)
					{
						int viewID = photonView.ViewID;
						bool isMine = photonView.IsMine;
						PupilStateManager.SetPlayerEyes(viewID, playerEyes, isMine);
					}
					string text = "unknown";
					if ((Object)(object)photonView != (Object)null && photonView.Owner != null)
					{
						text = photonView.Owner.NickName ?? photonView.Owner.ActorNumber.ToString();
					}
					ZoomyEyesPlugin.Log.LogInfo((object)("EyeZoomController initialized for player: " + ((Object)component).name + " (ID: " + text + ")"));
					ZoomyEyesPlugin.DebugLog($"Original pupil size captured: {originalPupilSize}");
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in EyeZoomController.Awake: " + ex.Message));
			}
		}

		private void Update()
		{
			try
			{
				if (ZoomyEyesPlugin.IsInMainMenu())
				{
					return;
				}
				if (Time.time - lastFOVCheckTime > 0.5f)
				{
					if (!isZooming && !isInFOVTransition && (Object)(object)photonView != (Object)null && photonView.IsMine)
					{
						float actualDefaultFOV = GetActualDefaultFOV();
						if (Mathf.Abs(trueCurrentFOV - actualDefaultFOV) > 0.5f)
						{
							trueCurrentFOV = actualDefaultFOV;
							ZoomyEyesPlugin.DebugLog($"Detected FOV change: updated tracked FOV to {actualDefaultFOV:F1}");
						}
					}
					lastFOVCheckTime = Time.time;
				}
				if (isZooming && currentZoomState != targetZoomState)
				{
					previousZoomState = currentZoomState;
					currentZoomState = targetZoomState;
					if ((Object)(object)photonView != (Object)null && photonView.IsMine)
					{
						float targetFOV = CalculateFOVFromZoomState(currentZoomState);
						StartFOVTransition(targetFOV);
						PlayZoomStateChangeSound(previousZoomState, currentZoomState);
					}
					if ((Object)(object)photonView != (Object)null)
					{
						int viewID = photonView.ViewID;
						PupilStateManager.SetZoomState(viewID, zooming: true, currentZoomState, photonView.IsMine);
					}
					ZoomyEyesPlugin.DebugLog($"Transitioned to zoom state: {currentZoomState}");
				}
				if (zoomStateChanged && Time.time - lastScrollNetworkUpdate >= 0.1f)
				{
					if ((Object)(object)photonView != (Object)null && photonView.IsMine && isZooming)
					{
						SyncZoomState();
					}
					zoomStateChanged = false;
				}
				if ((Object)(object)photonView != (Object)null && photonView.IsMine)
				{
					if (isInFOVTransition)
					{
						float num = Time.time - fovTransitionStartTime;
						float num2 = Mathf.Clamp01(num / fovTransitionDuration);
						float num3 = Mathf.SmoothStep(0f, 1f, num2);
						currentFOVValue = Mathf.Lerp(fovStartValue, fovEndValue, num3);
						trueCurrentFOV = currentFOVValue;
						ApplyFOVToAllCameras(currentFOVValue);
						if (num2 >= 1f)
						{
							isInFOVTransition = false;
							currentFOVValue = fovEndValue;
							trueCurrentFOV = fovEndValue;
							ZoomyEyesPlugin.DebugLog($"FOV transition completed: {fovEndValue:F1}");
						}
					}
					else if (isZooming)
					{
						MaintainFOV();
					}
				}
				if (Time.time - lastFOVLogTime > 5f && isZooming && (Object)(object)photonView != (Object)null && photonView.IsMine)
				{
					float cameraDirectFOV = GetCameraDirectFOV();
					ZoomyEyesPlugin.DebugLog($"Current FOV: {cameraDirectFOV:F1}, Target FOV: {trueCurrentFOV:F1}");
					lastFOVLogTime = Time.time;
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in EyeZoomController.Update: " + ex.Message));
			}
		}

		public void OnExternalFovChange(float newDefaultFov)
		{
			if (!isZooming)
			{
				trueCurrentFOV = newDefaultFov;
				ApplyFOVToAllCameras(newDefaultFov);
				ZoomyEyesPlugin.DebugLog($"Updated FOV to match external change: {newDefaultFov}");
				return;
			}
			float num = CalculateFOVFromZoomState(currentZoomState);
			if (isInFOVTransition)
			{
				fovEndValue = num;
				ZoomyEyesPlugin.DebugLog($"Updated FOV transition target to: {num}");
			}
			else
			{
				StartFOVTransition(num);
				ZoomyEyesPlugin.DebugLog($"Starting new FOV transition due to external FOV change: {num}");
			}
		}

		public static void UpdateMenuAvatarPupils()
		{
			PupilStateManager.UpdateMenuAvatarPupils();
		}

		private void MaintainFOV()
		{
			if (!(trueCurrentFOV <= 0f))
			{
				ApplyFOVToAllCameras(trueCurrentFOV);
			}
		}

		private void ApplyFOVToAllCameras(float fov)
		{
			foreach (Camera playerCamera in ZoomyEyesPlugin.playerCameras)
			{
				if ((Object)(object)playerCamera != (Object)null)
				{
					playerCamera.fieldOfView = fov;
				}
			}
			if ((Object)(object)Camera.main != (Object)null && !ZoomyEyesPlugin.playerCameras.Contains(Camera.main))
			{
				Camera.main.fieldOfView = fov;
			}
		}

		private float GetActualDefaultFOV()
		{
			if ((Object)(object)CameraZoom.Instance != (Object)null)
			{
				return CameraZoom.Instance.playerZoomDefault;
			}
			foreach (Camera playerCamera in ZoomyEyesPlugin.playerCameras)
			{
				if ((Object)(object)playerCamera != (Object)null && ((Behaviour)playerCamera).enabled)
				{
					return playerCamera.fieldOfView;
				}
			}
			if ((Object)(object)Camera.main != (Object)null)
			{
				return Camera.main.fieldOfView;
			}
			return 70f;
		}

		private void StartFOVTransition(float targetFOV)
		{
			if (Time.time - lastFOVChangeTime < minimumFOVChangeInterval)
			{
				ZoomyEyesPlugin.DebugLog("Ignoring FOV change request - too soon after previous change");
			}
			else
			{
				if (Mathf.Approximately(targetFOV, fovEndValue) && isInFOVTransition)
				{
					return;
				}
				float num = (isInFOVTransition ? currentFOVValue : trueCurrentFOV);
				float cameraDirectFOV = GetCameraDirectFOV();
				if (Mathf.Abs(num - cameraDirectFOV) > 1f)
				{
					ZoomyEyesPlugin.DebugLog($"FOV discrepancy - tracked: {num:F1}, camera: {cameraDirectFOV:F1}");
				}
				if (Mathf.Abs(num - targetFOV) < 0.5f)
				{
					trueCurrentFOV = targetFOV;
					currentFOVValue = targetFOV;
					return;
				}
				if (isInFOVTransition)
				{
					float num2 = Time.time - fovTransitionStartTime;
					float num3 = Mathf.Clamp01(num2 / fovTransitionDuration);
					ZoomyEyesPlugin.DebugLog($"Interrupting FOV transition at progress {num3:P0}, current FOV: {num:F1}");
				}
				fovStartValue = num;
				fovEndValue = targetFOV;
				fovTransitionStartTime = Time.time;
				fovTransitionDuration = 0.3f;
				isInFOVTransition = true;
				lastFOVChangeTime = Time.time;
				trueCurrentFOV = num;
				currentFOVValue = num;
				ZoomyEyesPlugin.DebugLog($"Starting FOV transition: {fovStartValue:F1} -> {fovEndValue:F1} over {fovTransitionDuration:F2}s");
			}
		}

		private float GetCameraDirectFOV()
		{
			foreach (Camera playerCamera in ZoomyEyesPlugin.playerCameras)
			{
				if ((Object)(object)playerCamera != (Object)null && ((Behaviour)playerCamera).enabled)
				{
					return playerCamera.fieldOfView;
				}
			}
			if ((Object)(object)Camera.main != (Object)null)
			{
				return Camera.main.fieldOfView;
			}
			return GetActualDefaultFOV();
		}

		public float GetCurrentFOV()
		{
			if (isInFOVTransition || isZooming)
			{
				return trueCurrentFOV;
			}
			return GetActualDefaultFOV();
		}

		private void PlayZoomStateChangeSound(ZoomyEyesPlugin.ZoomState fromState, ZoomyEyesPlugin.ZoomState toState)
		{
			//IL_003c: 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_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_0120: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			if (!ZoomyEyesPlugin.EnableSounds.Value)
			{
				return;
			}
			try
			{
				ZoomyEyesPlugin.SoundTransition soundTransition = ZoomyEyesPlugin.GetSoundTransition(fromState, toState);
				if ((Object)(object)soundTransition.Clip == (Object)null)
				{
					return;
				}
				Vector3 position = ((Component)this).transform.position + new Vector3(0f, 1.7f, 0f);
				if ((Object)(object)photonView != (Object)null && photonView.IsMine)
				{
					if ((Object)(object)Camera.main != (Object)null)
					{
						position = ((Component)Camera.main).transform.position;
					}
					else if (ZoomyEyesPlugin.playerCameras.Count > 0)
					{
						foreach (Camera playerCamera in ZoomyEyesPlugin.playerCameras)
						{
							if ((Object)(object)playerCamera != (Object)null && ((Behaviour)playerCamera).enabled)
							{
								position = ((Component)playerCamera).transform.position;
								break;
							}
						}
					}
				}
				ZoomyEyesPlugin.PlaySoundAtPosition(soundTransition.Clip, position, soundTransition.Pitch, ZoomyEyesPlugin.SoundVolume.Value);
				ZoomyEyesPlugin.DebugLog($"Playing transition sound from {fromState} to {toState} with pitch {soundTransition.Pitch:F1}");
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error playing zoom sound: " + ex.Message));
			}
		}

		public void SetZoomingWithState(bool zooming, ZoomyEyesPlugin.ZoomState state, bool inverted)
		{
			if (ZoomyEyesPlugin.IsInMainMenu() || ((Object)(object)photonView != (Object)null && photonView.IsMine))
			{
				return;
			}
			previousZoomState = currentZoomState;
			if (zooming && !isZooming)
			{
				if (!hasZoomedOnce)
				{
					originalPupilSize = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
					trueCurrentFOV = GetActualDefaultFOV();
					hasZoomedOnce = true;
					ZoomyEyesPlugin.DebugLog($"Remote player inversion preference: {inverted}");
					PlaySoundForRemotePlayer(activating: true);
				}
			}
			else if (!zooming && isZooming)
			{
				PlaySoundForRemotePlayer(activating: false);
				state = ZoomyEyesPlugin.ZoomState.Default;
			}
			isZooming = zooming;
			if (zooming)
			{
				if (currentZoomState != state)
				{
					PlayZoomStateChangeSound(currentZoomState, state);
				}
				currentZoomState = state;
				targetZoomState = state;
			}
			if ((Object)(object)photonView != (Object)null)
			{
				int viewID = photonView.ViewID;
				PupilStateManager.SetZoomState(viewID, isZooming, currentZoomState);
			}
			ZoomyEyesPlugin.DebugLog($"Remote player zoom state changed: {isZooming}, state: {currentZoomState}, inversion: {inverted}");
		}

		private void PlaySoundForRemotePlayer(bool activating)
		{
			//IL_0041: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			if (!ZoomyEyesPlugin.EnableSounds.Value)
			{
				return;
			}
			try
			{
				AudioClip val = (activating ? ZoomyEyesPlugin.DefaultZoomSound : ZoomyEyesPlugin.DefaultUnZoomSound);
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 position = ((Component)this).transform.position + new Vector3(0f, 1.7f, 0f);
					float pitch = (activating ? 1f : 1.1f);
					float volume = (activating ? 1f : 0.4f);
					ZoomyEyesPlugin.PlaySoundAtPosition(val, position, pitch, volume);
					ZoomyEyesPlugin.DebugLog("Playing remote player " + (activating ? "activation" : "deactivation") + " sound");
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error playing remote player sound: " + ex.Message));
			}
		}

		public void HandleScrollInput()
		{
			if (ZoomyEyesPlugin.IsInMainMenu())
			{
				return;
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (Mathf.Approximately(axis, 0f))
			{
				return;
			}
			if (Time.time - lastFOVChangeTime < minimumFOVChangeInterval)
			{
				ZoomyEyesPlugin.DebugLog("Ignoring scroll input - too soon after previous change");
				return;
			}
			ZoomyEyesPlugin.ZoomState zoomState = ((axis > 0f) ? ((targetZoomState == ZoomyEyesPlugin.ZoomState.Default) ? ZoomyEyesPlugin.ZoomState.ZoomedIn : ((targetZoomState != ZoomyEyesPlugin.ZoomState.ZoomedOut) ? targetZoomState : ZoomyEyesPlugin.ZoomState.Default)) : ((targetZoomState == ZoomyEyesPlugin.ZoomState.Default) ? ZoomyEyesPlugin.ZoomState.ZoomedOut : ((targetZoomState != ZoomyEyesPlugin.ZoomState.ZoomedIn) ? targetZoomState : ZoomyEyesPlugin.ZoomState.Default)));
			if (zoomState != targetZoomState)
			{
				targetZoomState = zoomState;
				zoomStateChanged = true;
				ZoomyEyesPlugin.DebugLog($"Switching to zoom state: {targetZoomState}");
				if ((Object)(object)photonView != (Object)null && photonView.IsMine)
				{
					int viewID = photonView.ViewID;
					PupilStateManager.SetZoomState(viewID, zooming: true, zoomState, isLocalPlayer: true);
				}
				UpdateMenuAvatarPupils();
			}
		}

		private float CalculateFOVFromZoomState(ZoomyEyesPlugin.ZoomState state)
		{
			float actualDefaultFOV = GetActualDefaultFOV();
			return state switch
			{
				ZoomyEyesPlugin.ZoomState.ZoomedIn => actualDefaultFOV * ZoomyEyesPlugin.ZoomedInFOVMultiplier.Value, 
				ZoomyEyesPlugin.ZoomState.ZoomedOut => actualDefaultFOV * ZoomyEyesPlugin.ZoomedOutFOVMultiplier.Value, 
				_ => actualDefaultFOV * ZoomyEyesPlugin.DefaultZoomFOVMultiplier.Value, 
			};
		}

		private void SyncZoomState()
		{
			if (!isZooming || (Object)(object)photonView == (Object)null || !photonView.IsMine || !PhotonNetwork.IsConnected || !PhotonNetwork.InRoom)
			{
				return;
			}
			try
			{
				bool value = ZoomyEyesPlugin.InvertPupilZoom.Value;
				photonView.RPC("SyncEyeZoom", (RpcTarget)1, new object[7]
				{
					true,
					(int)currentZoomState,
					value,
					ZoomyEyesPlugin.DefaultPupilSize.Value,
					ZoomyEyesPlugin.ZoomedInPupilSize.Value,
					ZoomyEyesPlugin.ZoomedOutPupilSize.Value,
					ZoomyEyesPlugin.DefaultNormalPupilSize.Value
				});
				ZoomyEyesPlugin.DebugLog($"Sent zoom state {currentZoomState} with inversion {value} to other players");
				lastScrollNetworkUpdate = Time.time;
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error sending zoom state: " + ex.Message));
			}
		}

		public void SetZooming(bool zooming, float currentFOV)
		{
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: 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)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			if (ZoomyEyesPlugin.IsInMainMenu())
			{
				return;
			}
			if (zooming && !isZooming)
			{
				bool value = ZoomyEyesPlugin.InvertPupilZoom.Value;
				if (!hasZoomedOnce)
				{
					originalPupilSize = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
					trueCurrentFOV = currentFOV;
					hasZoomedOnce = true;
					ZoomyEyesPlugin.DebugLog("**** DEBUG: ZOOM ACTIVATED ****");
					ZoomyEyesPlugin.DebugLog($"Using configured pupil size: {originalPupilSize}");
					ZoomyEyesPlugin.DebugLog($"Current default FOV: {GetActualDefaultFOV()}");
					ZoomyEyesPlugin.DebugLog($"Pupil inversion setting: {value}");
					ZoomyEyesPlugin.DebugLog("--- Camera Details ---");
					foreach (Camera playerCamera in ZoomyEyesPlugin.playerCameras)
					{
						if ((Object)(object)playerCamera != (Object)null)
						{
							ZoomyEyesPlugin.DebugLog($"Camera '{((Object)playerCamera).name}': FOV = {playerCamera.fieldOfView}, Enabled = {((Behaviour)playerCamera).enabled}");
						}
					}
					ZoomyEyesPlugin.DebugLog("---------------------");
				}
				bool flag = Input.GetAxis("Mouse ScrollWheel") > 0f;
				bool flag2 = Input.GetAxis("Mouse ScrollWheel") < 0f;
				if (flag)
				{
					previousZoomState = currentZoomState;
					currentZoomState = ZoomyEyesPlugin.ZoomState.ZoomedIn;
					targetZoomState = ZoomyEyesPlugin.ZoomState.ZoomedIn;
				}
				else if (flag2)
				{
					previousZoomState = currentZoomState;
					currentZoomState = ZoomyEyesPlugin.ZoomState.ZoomedOut;
					targetZoomState = ZoomyEyesPlugin.ZoomState.ZoomedOut;
				}
				else
				{
					previousZoomState = currentZoomState;
					currentZoomState = ZoomyEyesPlugin.ZoomState.Default;
					targetZoomState = ZoomyEyesPlugin.ZoomState.Default;
				}
				if ((Object)(object)photonView != (Object)null && photonView.IsMine && (Object)(object)ZoomyEyesPlugin.DefaultZoomSound != (Object)null)
				{
					Vector3 position = (((Object)(object)Camera.main != (Object)null) ? ((Component)Camera.main).transform.position : (((Component)this).transform.position + Vector3.up * 1.7f));
					ZoomyEyesPlugin.PlaySoundAtPosition(ZoomyEyesPlugin.DefaultZoomSound, position);
				}
			}
			else if (!zooming && isZooming)
			{
				if ((Object)(object)photonView != (Object)null && photonView.IsMine && (Object)(object)ZoomyEyesPlugin.DefaultUnZoomSound != (Object)null)
				{
					Vector3 position2 = (((Object)(object)Camera.main != (Object)null) ? ((Component)Camera.main).transform.position : (((Component)this).transform.position + Vector3.up * 1.7f));
					ZoomyEyesPlugin.PlaySoundAtPosition(ZoomyEyesPlugin.DefaultUnZoomSound, position2, 1.1f, 0.4f);
				}
				ZoomyEyesPlugin.DebugLog($"Returning to normal pupil size: {originalPupilSize}");
			}
			isZooming = zooming;
			if ((Object)(object)photonView != (Object)null)
			{
				int viewID = photonView.ViewID;
				PupilStateManager.SetZoomState(viewID, isZooming, currentZoomState, photonView.IsMine);
			}
			if (!((Object)(object)photonView != (Object)null) || !photonView.IsMine)
			{
				return;
			}
			float num;
			if (zooming)
			{
				num = CalculateFOVFromZoomState(currentZoomState);
			}
			else
			{
				num = GetActualDefaultFOV();
				float num2 = trueCurrentFOV;
				if (!isInFOVTransition || !Mathf.Approximately(fovEndValue, num))
				{
					fovStartValue = num2;
					fovEndValue = num;
					fovTransitionStartTime = Time.time;
					fovTransitionDuration = 0.3f;
					isInFOVTransition = true;
					lastFOVChangeTime = Time.time;
					currentFOVValue = num2;
					ZoomyEyesPlugin.DebugLog($"Z released - Starting FOV transition to current default: {fovStartValue:F1} -> {fovEndValue:F1}");
					UpdateMenuAvatarPupils();
					return;
				}
			}
			StartFOVTransition(num);
			UpdateMenuAvatarPupils();
		}

		[PunRPC]
		public void SyncEyeZoom(bool zooming, int stateValue, bool inverted, float defaultPupilSize, float zoomedInPupilSize, float zoomedOutPupilSize, float normalPupilSize)
		{
			try
			{
				if (!ZoomyEyesPlugin.IsInMainMenu())
				{
					string text = "unknown";
					if ((Object)(object)photonView != (Object)null && photonView.Owner != null)
					{
						text = photonView.Owner.NickName ?? photonView.Owner.ActorNumber.ToString();
					}
					ZoomyEyesPlugin.DebugLog($"Received zoom state: {zooming}, state: {(ZoomyEyesPlugin.ZoomState)stateValue}, inversion: {inverted} from player: {text}");
					ZoomyEyesPlugin.DebugLog($"Received pupil sizes: default={defaultPupilSize:F2}, in={zoomedInPupilSize:F2}, out={zoomedOutPupilSize:F2}");
					if ((Object)(object)photonView != (Object)null)
					{
						int viewID = photonView.ViewID;
						PupilStateManager.SetRemotePupilSizes(viewID, defaultPupilSize, zoomedInPupilSize, zoomedOutPupilSize, normalPupilSize, inverted);
					}
					SetZoomingWithState(zooming, (ZoomyEyesPlugin.ZoomState)stateValue, inverted);
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in SyncEyeZoom: " + ex.Message));
			}
		}

		[PunRPC]
		public void SyncDefaultPupilSize(float newSize)
		{
			try
			{
				if (!ZoomyEyesPlugin.IsInMainMenu())
				{
					ZoomyEyesPlugin.DebugLog($"Received default pupil size update: {newSize:F2}");
					if ((Object)(object)photonView != (Object)null)
					{
						int viewID = photonView.ViewID;
						PupilStateManager.SetDefaultSize(viewID, newSize);
					}
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error in SyncDefaultPupilSize: " + ex.Message));
			}
		}
	}
	public static class PupilStateManager
	{
		public class PlayerPupilState
		{
			public float DefaultPupilSize = 1f;

			public bool HasActiveOverride = false;

			public float OverrideMultiplier = 1f;

			public float OverrideStartTime = 0f;

			public bool IsZooming = false;

			public ZoomyEyesPlugin.ZoomState CurrentZoomState = ZoomyEyesPlugin.ZoomState.Default;

			public bool IsLocalPlayer = false;

			public bool UseInvertedPupils = false;

			public bool IsTransitioning = false;

			public float TransitionStartTime = 0f;

			public float TransitionStartSize = 1f;

			public float TransitionTargetSize = 1f;

			public TransitionType CurrentTransition = TransitionType.None;

			public float TransitionDuration = 0.3f;

			public float CurrentPupilSize = 1f;

			public PlayerEyes PlayerEyes;

			public int TransitionsStarted = 0;

			public int TransitionsCompleted = 0;

			public float LongestTransitionTime = 0f;
		}

		public enum TransitionType
		{
			None,
			ToOverride,
			FromOverride,
			ToZoom,
			FromZoom,
			DefaultSizeChange
		}

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

			private object <>2__current;

			public MonoBehaviour menuBehavior;

			public PlayerEyes menuEyes;

			public FieldInfo pupilSizeField;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					menuTransitionCoroutine = menuBehavior.StartCoroutine(TransitionMenuPupils(menuEyes, pupilSizeField));
					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 <TransitionMenuPupils>d__33 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerEyes menuEyes;

			public FieldInfo pupilSizeField;

			private float <startSize>5__1;

			private float <targetSize>5__2;

			private float <startTime>5__3;

			private float <duration>5__4;

			private float <initialProgress>5__5;

			private float <beforeValue>5__6;

			private float <afterValue>5__7;

			private float <progress>5__8;

			private float <easedProgress>5__9;

			private float <lastSize>5__10;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					isMenuTransitioning = true;
					<startSize>5__1 = menuCurrentPupilSize;
					<targetSize>5__2 = menuTargetPupilSize;
					<startTime>5__3 = Time.time;
					<duration>5__4 = 0.3f;
					<initialProgress>5__5 = 0.1f;
					menuCurrentPupilSize = Mathf.Lerp(<startSize>5__1, <targetSize>5__2, <initialProgress>5__5);
					if ((Object)(object)menuEyes != (Object)null && pupilSizeField != null)
					{
						<beforeValue>5__6 = (float)pupilSizeField.GetValue(menuEyes);
						pupilSizeField.SetValue(menuEyes, menuCurrentPupilSize);
						<afterValue>5__7 = (float)pupilSizeField.GetValue(menuEyes);
						ZoomyEyesPlugin.DebugLog($"Transition INITIAL step: {<beforeValue>5__6:F2} → {<afterValue>5__7:F2} (target: {<targetSize>5__2:F2})");
						if (Mathf.Abs(<afterValue>5__7 - menuCurrentPupilSize) > 0.01f)
						{
							ZoomyEyesPlugin.Log.LogError((object)$"Initial step didn't apply correctly! Expected: {menuCurrentPupilSize:F2}, Got: {<afterValue>5__7:F2}");
							pupilSizeField.SetValue(menuEyes, menuCurrentPupilSize);
						}
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (Time.time - <startTime>5__3 < <duration>5__4)
				{
					if ((Object)(object)menuEyes == (Object)null || (Object)(object)PlayerAvatarMenu.instance == (Object)null)
					{
						isMenuTransitioning = false;
						menuTransitionCoroutine = null;
						return false;
					}
					<progress>5__8 = (Time.time - <startTime>5__3) / <duration>5__4;
					<easedProgress>5__9 = Mathf.SmoothStep(0f, 1f, <progress>5__8);
					<lastSize>5__10 = menuCurrentPupilSize;
					menuCurrentPupilSize = Mathf.Lerp(<startSize>5__1, <targetSize>5__2, <easedProgress>5__9);
					if (Mathf.Abs(<lastSize>5__10 - menuCurrentPupilSize) > 0.01f)
					{
						ZoomyEyesPlugin.DebugLog($"Transition progress {<progress>5__8:P0}: {<lastSize>5__10:F2} → {menuCurrentPupilSize:F2}");
					}
					pupilSizeField.SetValue(menuEyes, menuCurrentPupilSize);
					if (Mathf.Abs(<targetSize>5__2 - menuTargetPupilSize) > 0.01f)
					{
						ZoomyEyesPlugin.DebugLog($"Transition target changed during transition: {<targetSize>5__2:F2} → {menuTargetPupilSize:F2}");
						<startSize>5__1 = menuCurrentPupilSize;
						<targetSize>5__2 = menuTargetPupilSize;
						<startTime>5__3 = Time.time;
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				if ((Object)(object)menuEyes != (Object)null)
				{
					menuCurrentPupilSize = menuTargetPupilSize;
					pupilSizeField.SetValue(menuEyes, menuCurrentPupilSize);
					ZoomyEyesPlugin.DebugLog($"Transition COMPLETE: final size = {menuCurrentPupilSize:F2}");
				}
				isMenuTransitioning = false;
				menuTransitionCoroutine = 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 static Dictionary<int, PlayerPupilState> playerStates;

		private static FieldInfo pupilSizeMultiplierField;

		private static PlayerAvatarVisuals menuAvatarVisuals;

		private static Coroutine menuTransitionCoroutine;

		private static bool isMenuTransitioning;

		private static float menuCurrentPupilSize;

		private static float menuTargetPupilSize;

		public const float MENU_TRANSITION_DURATION = 0.3f;

		public const float ZOOM_TRANSITION_DURATION = 0.3f;

		public const float OVERRIDE_TRANSITION_DURATION = 3f;

		private const float LOG_THROTTLE_PERIOD = 0.5f;

		private static Dictionary<int, float> lastTransitionLogTime;

		private static Dictionary<int, string> playerNames;

		static PupilStateManager()
		{
			playerStates = new Dictionary<int, PlayerPupilState>();
			isMenuTransitioning = false;
			menuCurrentPupilSize = 1f;
			menuTargetPupilSize = 1f;
			lastTransitionLogTime = new Dictionary<int, float>();
			playerNames = new Dictionary<int, string>();
			pupilSizeMultiplierField = AccessTools.Field(typeof(PlayerEyes), "pupilSizeMultiplier");
			if (pupilSizeMultiplierField == null)
			{
				ZoomyEyesPlugin.Log.LogError((object)"Failed to access pupilSizeMultiplier field via reflection!");
			}
		}

		private static void LogDebug(int playerID, string message, bool forceLog = false)
		{
			if (ZoomyEyesPlugin.EnableDebugLogging.Value || forceLog)
			{
				string text = "";
				text = ((!playerNames.TryGetValue(playerID, out var value)) ? $"[Player {playerID}] " : ("[" + value + "] "));
				ZoomyEyesPlugin.Log.LogInfo((object)(text + message));
			}
		}

		public static PlayerPupilState GetPlayerState(int playerID)
		{
			if (!playerStates.ContainsKey(playerID))
			{
				playerStates[playerID] = new PlayerPupilState();
				playerStates[playerID].DefaultPupilSize = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
				playerStates[playerID].CurrentPupilSize = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
				LogDebug(playerID, $"Created new pupil state tracker with size {playerStates[playerID].DefaultPupilSize:F2}", forceLog: true);
			}
			return playerStates[playerID];
		}

		public static void SetOverrideState(int playerID, bool active, float multiplier)
		{
			PlayerPupilState playerState = GetPlayerState(playerID);
			if (active != playerState.HasActiveOverride)
			{
				if (active)
				{
					playerState.HasActiveOverride = true;
					playerState.OverrideMultiplier = multiplier;
					playerState.OverrideStartTime = Time.time;
					LogDebug(playerID, $"OVERRIDE ACTIVATED: multiplier={multiplier:F2}");
					StartTransition(playerID, TransitionType.ToOverride);
				}
				else
				{
					LogDebug(playerID, $"OVERRIDE DEACTIVATED (after {Time.time - playerState.OverrideStartTime:F1}s)");
					playerState.HasActiveOverride = false;
					StartTransition(playerID, TransitionType.FromOverride);
				}
			}
			else if (active && Math.Abs(multiplier - playerState.OverrideMultiplier) > 0.01f)
			{
				LogDebug(playerID, $"Override multiplier changed: {playerState.OverrideMultiplier:F2} → {multiplier:F2}");
				playerState.OverrideMultiplier = multiplier;
				float num = CalculateTargetSize(playerID);
				if (playerState.IsTransitioning)
				{
					LogDebug(playerID, $"  - Updating ongoing transition target: {playerState.TransitionTargetSize:F2} → {num:F2}");
					playerState.TransitionTargetSize = num;
				}
				else
				{
					StartTransition(playerID, TransitionType.ToOverride);
				}
			}
		}

		public static void SetPlayerEyes(int playerID, PlayerEyes eyes, bool isLocalPlayer = false)
		{
			if (!((Object)(object)eyes == (Object)null))
			{
				PlayerPupilState playerState = GetPlayerState(playerID);
				playerState.PlayerEyes = eyes;
				playerState.IsLocalPlayer = isLocalPlayer;
				if (isLocalPlayer)
				{
					playerState.UseInvertedPupils = ZoomyEyesPlugin.InvertPupilZoom.Value;
				}
				if (pupilSizeMultiplierField != null)
				{
					float num = (float)pupilSizeMultiplierField.GetValue(eyes);
					LogDebug(playerID, $"Set player eyes reference with current size: {num:F2}");
				}
				ApplyPupilSize(playerID);
			}
		}

		public static void SetRemotePupilSizes(int playerID, float defaultSize, float zoomedInSize, float zoomedOutSize, float normalSize, bool invertedPupils)
		{
			LogDebug(playerID, $"Setting remote pupil sizes: default={defaultSize:F2}, in={zoomedInSize:F2}, out={zoomedOutSize:F2}, normal={normalSize:F2}");
			ZoomyEyesPlugin.lastKnownFieldValues[$"player_{playerID}_defaultPupilSize"] = defaultSize;
			ZoomyEyesPlugin.lastKnownFieldValues[$"player_{playerID}_zoomedInPupilSize"] = zoomedInSize;
			ZoomyEyesPlugin.lastKnownFieldValues[$"player_{playerID}_zoomedOutPupilSize"] = zoomedOutSize;
			ZoomyEyesPlugin.lastKnownFieldValues[$"player_{playerID}_normalPupilSize"] = normalSize;
			PlayerPupilState playerState = GetPlayerState(playerID);
			playerState.UseInvertedPupils = invertedPupils;
			SetDefaultSize(playerID, normalSize);
		}

		private static float GetRemotePlayerSize(int playerID, string key, float defaultValue)
		{
			string key2 = $"player_{playerID}_{key}";
			if (ZoomyEyesPlugin.lastKnownFieldValues.TryGetValue(key2, out var value))
			{
				return value;
			}
			return defaultValue;
		}

		public static void SetZoomState(int playerID, bool zooming, ZoomyEyesPlugin.ZoomState zoomState, bool isLocalPlayer = false)
		{
			PlayerPupilState playerState = GetPlayerState(playerID);
			playerState.IsLocalPlayer = isLocalPlayer;
			if (zooming != playerState.IsZooming || (zooming && zoomState != playerState.CurrentZoomState))
			{
				bool isZooming = playerState.IsZooming;
				ZoomyEyesPlugin.ZoomState currentZoomState = playerState.CurrentZoomState;
				playerState.IsZooming = zooming;
				playerState.CurrentZoomState = zoomState;
				if (!isZooming && zooming)
				{
					LogDebug(playerID, $"ZOOM ACTIVATED: state={zoomState}");
					StartTransition(playerID, TransitionType.ToZoom);
					UpdateMenuAvatarPupils();
				}
				else if (isZooming && !zooming)
				{
					LogDebug(playerID, "ZOOM DEACTIVATED");
					StartTransition(playerID, TransitionType.FromZoom);
					UpdateMenuAvatarPupils();
				}
				else if (isZooming && zooming && currentZoomState != zoomState)
				{
					LogDebug(playerID, $"Zoom state changed: {currentZoomState} → {zoomState}");
					StartTransition(playerID, TransitionType.ToZoom);
					UpdateMenuAvatarPupils();
				}
			}
		}

		public static void SetDefaultSize(int playerID, float size)
		{
			PlayerPupilState playerState = GetPlayerState(playerID);
			if (Math.Abs(size - playerState.DefaultPupilSize) > 0.01f)
			{
				float defaultPupilSize = playerState.DefaultPupilSize;
				playerState.DefaultPupilSize = size;
				if (!playerState.HasActiveOverride && !playerState.IsZooming)
				{
					StartTransition(playerID, TransitionType.DefaultSizeChange);
					LogDebug(playerID, "  - Starting transition to new default size");
				}
				else
				{
					LogDebug(playerID, $"  - Not transitioning (override={playerState.HasActiveOverride}, zooming={playerState.IsZooming})");
				}
				UpdateMenuAvatarPupils();
			}
		}

		private static void StartTransition(int playerID, TransitionType transitionType)
		{
			PlayerPupilState playerState = GetPlayerState(playerID);
			float num = CalculateTargetSize(playerID);
			if (Math.Abs(num - playerState.CurrentPupilSize) < 0.01f)
			{
				LogDebug(playerID, $"  - Skipping transition (already at target size: {num:F2})");
				return;
			}
			float num2;
			switch (transitionType)
			{
			case TransitionType.ToOverride:
			case TransitionType.FromOverride:
				num2 = 3f;
				break;
			case TransitionType.ToZoom:
			case TransitionType.FromZoom:
				num2 = 0.3f;
				break;
			default:
				num2 = 0.3f;
				break;
			}
			playerState.IsTransitioning = true;
			playerState.TransitionStartTime = Time.time;
			playerState.TransitionStartSize = playerState.CurrentPupilSize;
			playerState.TransitionTargetSize = num;
			playerState.CurrentTransition = transitionType;
			playerState.TransitionDuration = num2;
			playerState.TransitionsStarted++;
			LogDebug(playerID, $"TRANSITION STARTED: {transitionType} | {playerState.TransitionStartSize:F2} → {num:F2} (duration: {num2:F1}s)");
			LogDebug(playerID, $"  - Current state: override={playerState.HasActiveOverride}, zooming={playerState.IsZooming}, zoom state={playerState.CurrentZoomState}");
			string text = "";
			text = (playerState.HasActiveOverride ? $"override active (multiplier={playerState.OverrideMultiplier:F2})" : ((!playerState.IsZooming) ? "default size" : $"zooming (state={playerState.CurrentZoomState})"));
			LogDebug(playerID, "  - Target determination: " + text);
		}

		private static float CalculateTargetSize(int playerID)
		{
			PlayerPupilState playerState = GetPlayerState(playerID);
			if (playerState.HasActiveOverride)
			{
				return 1f * playerState.OverrideMultiplier;
			}
			if (playerState.IsZooming)
			{
				if (playerState.UseInvertedPupils)
				{
					switch (playerState.CurrentZoomState)
					{
					case ZoomyEyesPlugin.ZoomState.ZoomedIn:
						if (!playerState.IsLocalPlayer)
						{
							return GetRemotePlayerSize(playerID, "zoomedOutPupilSize", ZoomyEyesPlugin.ZoomedOutPupilSize.Value);
						}
						return ZoomyEyesPlugin.ZoomedOutPupilSize.Value;
					case ZoomyEyesPlugin.ZoomState.ZoomedOut:
						if (!playerState.IsLocalPlayer)
						{
							return GetRemotePlayerSize(playerID, "zoomedInPupilSize", ZoomyEyesPlugin.ZoomedInPupilSize.Value);
						}
						return ZoomyEyesPlugin.ZoomedInPupilSize.Value;
					default:
						if (!playerState.IsLocalPlayer)
						{
							return GetRemotePlayerSize(playerID, "defaultPupilSize", ZoomyEyesPlugin.DefaultPupilSize.Value);
						}
						return ZoomyEyesPlugin.DefaultPupilSize.Value;
					}
				}
				switch (playerState.CurrentZoomState)
				{
				case ZoomyEyesPlugin.ZoomState.ZoomedIn:
					if (!playerState.IsLocalPlayer)
					{
						return GetRemotePlayerSize(playerID, "zoomedInPupilSize", ZoomyEyesPlugin.ZoomedInPupilSize.Value);
					}
					return ZoomyEyesPlugin.ZoomedInPupilSize.Value;
				case ZoomyEyesPlugin.ZoomState.ZoomedOut:
					if (!playerState.IsLocalPlayer)
					{
						return GetRemotePlayerSize(playerID, "zoomedOutPupilSize", ZoomyEyesPlugin.ZoomedOutPupilSize.Value);
					}
					return ZoomyEyesPlugin.ZoomedOutPupilSize.Value;
				default:
					if (!playerState.IsLocalPlayer)
					{
						return GetRemotePlayerSize(playerID, "defaultPupilSize", ZoomyEyesPlugin.DefaultPupilSize.Value);
					}
					return ZoomyEyesPlugin.DefaultPupilSize.Value;
				}
			}
			return playerState.DefaultPupilSize;
		}

		public static float CalculatePupilSize(int playerID)
		{
			PlayerPupilState playerState = GetPlayerState(playerID);
			if (playerState.IsTransitioning)
			{
				float num = Time.time - playerState.TransitionStartTime;
				float num2 = Mathf.Clamp01(num / playerState.TransitionDuration);
				float num3 = Mathf.SmoothStep(0f, 1f, num2);
				float num4 = (playerState.CurrentPupilSize = Mathf.Lerp(playerState.TransitionStartSize, playerState.TransitionTargetSize, num3));
				if (ZoomyEyesPlugin.EnableDebugLogging.Value)
				{
					if (!lastTransitionLogTime.ContainsKey(playerID))
					{
						lastTransitionLogTime[playerID] = 0f;
					}
					if (Time.time - lastTransitionLogTime[playerID] > 0.5f)
					{
						LogDebug(playerID, $"  Transition progress: {num2:P0} | Current size: {num4:F2}");
						lastTransitionLogTime[playerID] = Time.time;
					}
				}
				if (num2 >= 1f)
				{
					playerState.IsTransitioning = false;
					playerState.CurrentTransition = TransitionType.None;
					playerState.TransitionsCompleted++;
					float num5 = Time.time - playerState.TransitionStartTime;
					if (num5 > playerState.LongestTransitionTime)
					{
						playerState.LongestTransitionTime = num5;
					}
					LogDebug(playerID, $"TRANSITION COMPLETE: {playerState.TransitionStartSize:F2} → {playerState.TransitionTargetSize:F2} in {num5:F2}s");
				}
			}
			else if (!playerState.IsTransitioning)
			{
				float num6 = CalculateTargetSize(playerID);
				if (Math.Abs(num6 - playerState.CurrentPupilSize) > 0.01f)
				{
					LogDebug(playerID, $"Pupil size drift detected: {playerState.CurrentPupilSize:F2} vs target {num6:F2}", forceLog: true);
					StartTransition(playerID, TransitionType.None);
				}
			}
			return playerState.CurrentPupilSize;
		}

		public static bool IsPlayerInTransition(int playerID)
		{
			return playerStates.ContainsKey(playerID) && playerStates[playerID].IsTransitioning;
		}

		public static void ApplyPupilSize(int playerID)
		{
			PlayerPupilState playerState = GetPlayerState(playerID);
			if (!((Object)(object)playerState.PlayerEyes == (Object)null) && !(pupilSizeMultiplierField == null))
			{
				float num = CalculatePupilSize(playerID);
				pupilSizeMultiplierField.SetValue(playerState.PlayerEyes, num);
			}
		}

		public static void ApplyPupilSizesToAllPlayers()
		{
			if (ZoomyEyesPlugin.IsInMainMenu())
			{
				return;
			}
			try
			{
				foreach (KeyValuePair<int, PlayerPupilState> playerState in playerStates)
				{
					int key = playerState.Key;
					ApplyPupilSize(key);
				}
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error applying pupil sizes to all players: " + ex.Message));
			}
		}

		public static void UpdateMenuAvatarPupils()
		{
			try
			{
				if ((Object)(object)MenuManager.instance == (Object)null)
				{
					return;
				}
				if ((Object)(object)menuAvatarVisuals == (Object)null || (Object)(object)menuAvatarVisuals.playerEyes == (Object)null)
				{
					if (!((Object)(object)PlayerAvatarMenu.instance != (Object)null))
					{
						ZoomyEyesPlugin.DebugLog("PlayerAvatarMenu.instance is null, cannot find menu avatar visuals");
						return;
					}
					menuAvatarVisuals = ((Component)PlayerAvatarMenu.instance).GetComponentInChildren<PlayerAvatarVisuals>();
					ZoomyEyesPlugin.Log.LogInfo((object)("Found menu avatar visuals: " + (((Object)(object)menuAvatarVisuals != (Object)null) ? "yes" : "no")));
				}
				if ((Object)(object)menuAvatarVisuals == (Object)null || (Object)(object)menuAvatarVisuals.playerEyes == (Object)null || pupilSizeMultiplierField == null)
				{
					ZoomyEyesPlugin.DebugLog("Cannot update menu avatar pupils: missing references");
					return;
				}
				float num = (float)pupilSizeMultiplierField.GetValue(menuAvatarVisuals.playerEyes);
				float currentPupilSizeForMenu = GetCurrentPupilSizeForMenu();
				if (ZoomyEyesPlugin.EnableDebugLogging.Value)
				{
					FieldInfo field = typeof(PlayerAvatarPatch).GetField("wasZKeyPressed", BindingFlags.Static | BindingFlags.NonPublic);
					bool flag = false;
					if (field != null)
					{
						flag = (bool)field.GetValue(null);
					}
					ZoomyEyesPlugin.DebugLog($"Menu pupil update: wasZKeyPressed={flag}, realSize={num:F2}, targetSize={currentPupilSizeForMenu:F2}, currentMenuTarget={menuTargetPupilSize:F2}");
					PlayerAvatar val = FindLocalPlayer();
					if ((Object)(object)val != (Object)null)
					{
						PhotonView photonView = val.photonView;
						int num2 = ((photonView != null) ? photonView.ViewID : (-1));
						if (num2 >= 0 && playerStates.ContainsKey(num2))
						{
							PlayerPupilState playerPupilState = playerStates[num2];
							ZoomyEyesPlugin.DebugLog($"  Player state: IsZooming={playerPupilState.IsZooming}, ZoomState={playerPupilState.CurrentZoomState}, CurrentSize={playerPupilState.CurrentPupilSize:F2}");
						}
					}
				}
				if (Mathf.Abs(menuTargetPupilSize - currentPupilSizeForMenu) < 0.01f)
				{
					if (Mathf.Abs(num - menuTargetPupilSize) > 0.05f && !isMenuTransitioning)
					{
						ZoomyEyesPlugin.DebugLog($"Menu avatar pupil was changed externally: {num:F2}, forcing initial step toward {menuTargetPupilSize:F2}");
						float num3 = Mathf.Lerp(num, menuTargetPupilSize, 0.2f);
						pupilSizeMultiplierField.SetValue(menuAvatarVisuals.playerEyes, num3);
						menuCurrentPupilSize = num3;
						float num4 = (float)pupilSizeMultiplierField.GetValue(menuAvatarVisuals.playerEyes);
						if (Mathf.Abs(num4 - num3) > 0.01f)
						{
							ZoomyEyesPlugin.Log.LogError((object)$"Initial correction didn't apply! Expected: {num3:F2}, Got: {num4:F2}");
						}
					}
					return;
				}
				float num5 = menuTargetPupilSize;
				menuTargetPupilSize = currentPupilSizeForMenu;
				menuCurrentPupilSize = num;
				if (isMenuTransitioning)
				{
					ZoomyEyesPlugin.DebugLog($"Transition already in progress, target updated: {num5:F2} -> {menuTargetPupilSize:F2}");
					return;
				}
				if ((Object)(object)PlayerAvatarMenu.instance != (Object)null)
				{
					MonoBehaviour instance = (MonoBehaviour)(object)PlayerAvatarMenu.instance;
					if ((Object)(object)instance != (Object)null)
					{
						if (menuTransitionCoroutine != null)
						{
							instance.StopCoroutine(menuTransitionCoroutine);
							menuTransitionCoroutine = null;
						}
						float num6 = Mathf.Lerp(menuCurrentPupilSize, menuTargetPupilSize, 0.15f);
						pupilSizeMultiplierField.SetValue(menuAvatarVisuals.playerEyes, num6);
						menuCurrentPupilSize = num6;
						instance.StartCoroutine(DelayedStartTransition(instance, menuAvatarVisuals.playerEyes, pupilSizeMultiplierField));
					}
					else
					{
						float num7 = Mathf.Lerp(menuCurrentPupilSize, menuTargetPupilSize, 0.2f);
						pupilSizeMultiplierField.SetValue(menuAvatarVisuals.playerEyes, num7);
						menuCurrentPupilSize = num7;
						ZoomyEyesPlugin.DebugLog($"Applied initial step: {menuCurrentPupilSize:F2} (no coroutine available)");
					}
				}
				else
				{
					ZoomyEyesPlugin.DebugLog("Cannot start transition: PlayerAvatarMenu.instance is null");
				}
				ZoomyEyesPlugin.DebugLog($"Updated menu avatar pupil target to: {menuTargetPupilSize:F2}");
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error updating menu avatar pupils: " + ex.Message));
			}
		}

		[IteratorStateMachine(typeof(<DelayedStartTransition>d__31))]
		private static IEnumerator DelayedStartTransition(MonoBehaviour menuBehavior, PlayerEyes menuEyes, FieldInfo pupilSizeField)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedStartTransition>d__31(0)
			{
				menuBehavior = menuBehavior,
				menuEyes = menuEyes,
				pupilSizeField = pupilSizeField
			};
		}

		private static float GetCurrentPupilSizeForMenu()
		{
			try
			{
				FieldInfo field = typeof(PlayerAvatarPatch).GetField("wasZKeyPressed", BindingFlags.Static | BindingFlags.NonPublic);
				bool flag = false;
				if (field != null)
				{
					flag = (bool)field.GetValue(null);
				}
				if (!flag)
				{
					ZoomyEyesPlugin.DebugLog($"Menu avatar: not zooming, using normal size: {ZoomyEyesPlugin.DefaultNormalPupilSize.Value:F2}");
					return ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
				}
				PlayerAvatar val = FindLocalPlayer();
				if ((Object)(object)val != (Object)null)
				{
					PhotonView photonView = val.photonView;
					int num = ((photonView != null) ? photonView.ViewID : (-1));
					if (num >= 0 && playerStates.ContainsKey(num))
					{
						PlayerPupilState playerPupilState = playerStates[num];
						float num2 = (playerPupilState.UseInvertedPupils ? (playerPupilState.CurrentZoomState switch
						{
							ZoomyEyesPlugin.ZoomState.ZoomedIn => ZoomyEyesPlugin.ZoomedOutPupilSize.Value, 
							ZoomyEyesPlugin.ZoomState.ZoomedOut => ZoomyEyesPlugin.ZoomedInPupilSize.Value, 
							_ => ZoomyEyesPlugin.DefaultPupilSize.Value, 
						}) : (playerPupilState.CurrentZoomState switch
						{
							ZoomyEyesPlugin.ZoomState.ZoomedIn => ZoomyEyesPlugin.ZoomedInPupilSize.Value, 
							ZoomyEyesPlugin.ZoomState.ZoomedOut => ZoomyEyesPlugin.ZoomedOutPupilSize.Value, 
							_ => ZoomyEyesPlugin.DefaultPupilSize.Value, 
						}));
						ZoomyEyesPlugin.DebugLog($"Menu avatar: zooming with state {playerPupilState.CurrentZoomState}, using size: {num2:F2}");
						return num2;
					}
				}
				ZoomyEyesPlugin.DebugLog($"Menu avatar: using default zoom size: {ZoomyEyesPlugin.DefaultPupilSize.Value:F2}");
				return ZoomyEyesPlugin.DefaultPupilSize.Value;
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error getting menu pupil size: " + ex.Message));
				return ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
			}
		}

		[IteratorStateMachine(typeof(<TransitionMenuPupils>d__33))]
		private static IEnumerator TransitionMenuPupils(PlayerEyes menuEyes, FieldInfo pupilSizeField)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TransitionMenuPupils>d__33(0)
			{
				menuEyes = menuEyes,
				pupilSizeField = pupilSizeField
			};
		}

		private static PlayerAvatar FindLocalPlayer()
		{
			PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>();
			PlayerAvatar[] array2 = array;
			foreach (PlayerAvatar val in array2)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.photonView != (Object)null && val.photonView.IsMine)
				{
					return val;
				}
			}
			return null;
		}

		public static void ApplyNormalPupilSizeToAll()
		{
			try
			{
				if (ZoomyEyesPlugin.IsInMainMenu())
				{
					return;
				}
				float value = ZoomyEyesPlugin.DefaultNormalPupilSize.Value;
				List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
				foreach (PlayerAvatar item in list)
				{
					if ((Object)(object)item.photonView != (Object)null)
					{
						int viewID = item.photonView.ViewID;
						SetDefaultSize(viewID, value);
					}
				}
				UpdateMenuAvatarPupils();
				ZoomyEyesPlugin.DebugLog($"Applied normal pupil size to all players: {value}");
			}
			catch (Exception ex)
			{
				ZoomyEyesPlugin.Log.LogError((object)("Error applying normal pupil size: " + ex.Message));
			}
		}

		public static void LogAllPlayerStates()
		{
			ZoomyEyesPlugin.Log.LogInfo((object)"=== PUPIL STATE MANAGER - ALL PLAYER STATES ===");
			foreach (KeyValuePair<int, PlayerPupilState> playerState in playerStates)
			{
				int key = playerState.Key;
				PlayerPupilState value = playerState.Value;
				string text = (playerNames.ContainsKey(key) ? playerNames[key] : $"Player {key}");
				ZoomyEyesPlugin.Log.LogInfo((object)(text + ":"));
				ZoomyEyesPlugin.Log.LogInfo((object)$"  Default Size: {value.DefaultPupilSize:F2}");
				ZoomyEyesPlugin.Log.LogInfo((object)$"  Override: {value.HasActiveOverride} (multiplier: {value.OverrideMultiplier:F2})");
				ZoomyEyesPlugin.Log.LogInfo((object)$"  Zoom: {value.IsZooming} (state: {value.CurrentZoomState})");
				ZoomyEyesPlugin.Log.LogInfo((object)$"  Transition: {value.IsTransitioning} (type: {value.CurrentTransition})");
				ZoomyEyesPlugin.Log.LogInfo((object)$"  Current Size: {value.CurrentPupilSize:F2}");
				ZoomyEyesPlugin.Log.LogInfo((object)$"  Stats: {value.TransitionsStarted} started, {value.TransitionsCompleted} completed");
				ZoomyEyesPlugin.Log.LogInfo((object)$"  Longest transition: {value.LongestTransitionTime:F2}s");
			}
			ZoomyEyesPlugin.Log.LogInfo((object)"=================================================");
		}

		private static void LogDetailedState(int playerID)
		{
			if (!playerStates.ContainsKey(playerID))
			{
				ZoomyEyesPlugin.Log.LogInfo((object)$"[PUPIL DIAGNOSTICS] No state exists for player {playerID}");
				return;
			}
			PlayerPupilState playerPupilState = playerStates[playerID];
			string text = (playerNames.ContainsKey(playerID) ? playerNames[playerID] : $"Player {playerID}");
			ZoomyEyesPlugin.Log.LogInfo((object)("=== PUPIL DIAGNOSTICS FOR " + text + " ==="));
			ZoomyEyesPlugin.Log.LogInfo((object)$"Current pupil size: {playerPupilState.CurrentPupilSize:F2}");
			ZoomyEyesPlugin.Log.LogInfo((object)$"Default pupil size: {playerPupilState.DefaultPupilSize:F2}");
			ZoomyEyesPlugin.Log.LogInfo((object)$"Is zooming: {playerPupilState.IsZooming}");
			ZoomyEyesPlugin.Log.LogInfo((object)$"Zoom state: {playerPupilState.CurrentZoomState}");
			ZoomyEyesPlugin.Log.LogInfo((object)$"Has override: {playerPupilState.HasActiveOverride}");
			ZoomyEyesPlugin.Log.LogInfo((object)$"Override multiplier: {playerPupilState.OverrideMultiplier:F2}");
			ZoomyEyesPlugin.Log.LogInfo((object)$"Is transitioning: {playerPupilState.IsTransitioning}");
			if (playerPupilState.IsTransitioning)
			{
				float num = Time.time - playerPupilState.TransitionStartTime;
				float num2 = Mathf.Clamp01(num / playerPupilState.TransitionDuration);
				ZoomyEyesPlugin.Log.LogInfo((object)$"Transition type: {playerPupilState.CurrentTransition}");
				ZoomyEyesPlugin.Log.LogInfo((object)$"Transition start size: {playerPupilState.TransitionStartSize:F2}");
				ZoomyEyesPlugin.Log.LogInfo((object)$"Transition target size: {playerPupilState.TransitionTargetSize:F2}");
				ZoomyEyesPlugin.Log.LogInfo((object)$"Transition progress: {num2:P0} ({num:F2}s elapsed)");
				ZoomyEyesPlugin.Log.LogInfo((object)$"Transition start time: {playerPupilState.TransitionStartTime:F2}");
				ZoomyEyesPlugin.Log.LogInfo((object)$"Current time: {Time.time:F2}");
			}
			ZoomyEyesPlugin.Log.LogInfo((object)$"Target calculated size (current priority): {CalculateTargetSize(playerID):F2}");
			ZoomyEyesPlugin.Log.LogInfo((object)"===========================================");
		}
	}
}
namespace ZoomyEyes.Config
{
	public static class PupilSliderConfig
	{
		public static Vector3 SliderPosition = new Vector3(445f, 745f, 0f);

		public static Color SliderBackgroundColor = new Color(0f, 0f, 0f, 0.63f);

		public static Color SliderBarColor = Color.grey;

		public static string SliderName = "Pupil Size";

		public static float MinPupilSize = 0.2f;

		public