using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ToggleFace")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ToggleFace")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f7c43861-2ec1-408f-94da-b4eadde3bd45")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.2.0")]
namespace ToggleFace
{
	internal static class PluginInfo
	{
		public const string PLUGIN_GUILD = "it.pippopad.toggleface";

		public const string PLUGIN_NAME = "ToggleFace";

		public const string PLUGIN_VERSION = "1.0.2";
	}
	[BepInPlugin("it.pippopad.toggleface", "ToggleFace", "1.0.2")]
	internal class ToggleFaceMod : BaseUnityPlugin
	{
		public static ToggleFaceMod instance;

		public bool[] activeExpression = new bool[6];

		public bool[] isStillDown = new bool[6];

		private Canvas hudCanvas;

		private GameObject facesText;

		private TMP_Text facesTextTMP;

		public ConfigEntry<bool> showActiveExpr;

		public ConfigEntry<float> fontSize;

		private void Awake()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)instance))
			{
				instance = this;
				BindConfigs();
				new Harmony("it.pippopad.toggleface").PatchAll();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"ToggleFace has started!");
			}
		}

		public void Update()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_00af: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			if (!showActiveExpr.Value)
			{
				return;
			}
			if (!SemiFunc.MenuLevel() && !SemiFunc.RunIsLobbyMenu())
			{
				if ((Object)(object)facesText == (Object)null || (Object)(object)hudCanvas == (Object)null)
				{
					hudCanvas = GameObject.Find("HUD Canvas").GetComponent<Canvas>();
					facesText = new GameObject("FacesText");
					facesText.transform.SetParent(((Component)hudCanvas).transform, false);
					facesTextTMP = (TMP_Text)(object)facesText.AddComponent<TextMeshProUGUI>();
					facesTextTMP.fontSize = fontSize.Value;
					((Graphic)facesTextTMP).color = Color.white;
					RectTransform component = facesText.GetComponent<RectTransform>();
					component.anchorMin = new Vector2(1f, 0.5f);
					component.anchorMax = new Vector2(1f, 0.5f);
					component.anchoredPosition = new Vector2(-40f, -50f);
					component.sizeDelta = new Vector2(100f, 50f);
				}
				facesTextTMP.text = "";
				for (int i = 0; i < activeExpression.Count(); i++)
				{
					if (activeExpression[i])
					{
						TMP_Text obj = facesTextTMP;
						obj.text += $"Face {i + 1}\n";
					}
				}
			}
			else
			{
				Object.Destroy((Object)(object)facesText);
				facesText = null;
			}
		}

		private void BindConfigs()
		{
			showActiveExpr = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowActiveExpressions", true, "Show a list of active expressions");
			fontSize = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ListTextFontSize", 20f, "Set the font size of list (if active)");
		}

		public static ManualLogSource GetLogger()
		{
			return ((BaseUnityPlugin)instance).Logger;
		}
	}
	internal static class Utils
	{
		public static void CallMethod<T>(T __instance, string methodName, object[] args)
		{
			MethodInfo method = typeof(T).GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic);
			if (method != null)
			{
				method.Invoke(__instance, args);
			}
		}

		public static U CallMethod<T, U>(T __instance, string methodName, object[] args)
		{
			MethodInfo method = typeof(T).GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic);
			if (method != null)
			{
				return (U)method.Invoke(__instance, args);
			}
			return default(U);
		}

		public static U GetField<T, U>(T __instance, string fieldName)
		{
			FieldInfo field = typeof(T).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				return (U)field.GetValue(__instance);
			}
			return default(U);
		}

		public static void SetField<T, U>(T __instance, string fieldName, U value)
		{
			FieldInfo field = typeof(T).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
			if (field != null)
			{
				field.SetValue(__instance, value);
			}
		}
	}
}
namespace ToggleFace.Patches
{
	[HarmonyPatch(typeof(PlayerExpression), "Update")]
	internal class PlayerExpressionPatch
	{
		public static bool Prefix(PlayerExpression __instance)
		{
			//IL_0d14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ee8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fd4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fe9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c89: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc6: Unknown result type (might be due to invalid IL or missing references)
			//IL_079d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0828: Unknown result type (might be due to invalid IL or missing references)
			//IL_0876: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0912: Unknown result type (might be due to invalid IL or missing references)
			//IL_0960: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4a: Unknown result type (might be due to invalid IL or missing references)
			ToggleFaceMod.instance.Update();
			PlayerAvatarVisuals component = ((Component)__instance).GetComponent<PlayerAvatarVisuals>();
			if (!LevelGenerator.Instance.Generated && !SemiFunc.MenuLevel())
			{
				Utils.CallMethod<PlayerExpression>(__instance, "DoExpression", new object[2] { 1, 100f });
			}
			if (!Object.op_Implicit((Object)(object)__instance.playerAvatar))
			{
				if (Utils.GetField<PlayerAvatarVisuals, bool>(component, "expressionAvatar"))
				{
					Utils.GetField<PlayerAvatarVisuals, Animator>(component, "animator").Play("Crouch", 0, 0f);
				}
				Utils.SetField<PlayerExpression, PlayerAvatar>(__instance, "playerAvatar", PlayerAvatar.instance);
				Utils.SetField<PlayerExpression, bool>(__instance, "isLocal", value: true);
			}
			List<int> list = new List<int>();
			foreach (int item in Utils.GetField<PlayerExpression, List<int>>(__instance, "activeExpressions"))
			{
				list.Add(item);
			}
			Utils.GetField<PlayerExpression, List<int>>(__instance, "activeExpressions").Clear();
			if (Utils.GetField<PlayerExpression, bool>(__instance, "isLocal"))
			{
				if (!Object.op_Implicit((Object)(object)Utils.GetField<MenuManager, MenuPage>(MenuManager.instance, "currentMenuPage")))
				{
					if (SemiFunc.InputDown((InputKey)26) && !ToggleFaceMod.instance.isStillDown[0])
					{
						ToggleFaceMod.instance.activeExpression[0] = !ToggleFaceMod.instance.activeExpression[0];
						ToggleFaceMod.instance.isStillDown[0] = true;
					}
					else if (SemiFunc.InputUp((InputKey)26))
					{
						ToggleFaceMod.instance.isStillDown[0] = false;
					}
					if (SemiFunc.InputDown((InputKey)27) && !ToggleFaceMod.instance.isStillDown[1])
					{
						ToggleFaceMod.instance.activeExpression[1] = !ToggleFaceMod.instance.activeExpression[1];
						ToggleFaceMod.instance.isStillDown[1] = true;
					}
					else if (SemiFunc.InputUp((InputKey)27))
					{
						ToggleFaceMod.instance.isStillDown[1] = false;
					}
					if (SemiFunc.InputDown((InputKey)28) && !ToggleFaceMod.instance.isStillDown[2])
					{
						ToggleFaceMod.instance.activeExpression[2] = !ToggleFaceMod.instance.activeExpression[2];
						ToggleFaceMod.instance.isStillDown[2] = true;
					}
					else if (SemiFunc.InputUp((InputKey)28))
					{
						ToggleFaceMod.instance.isStillDown[2] = false;
					}
					if (SemiFunc.InputDown((InputKey)29) && !ToggleFaceMod.instance.isStillDown[3])
					{
						ToggleFaceMod.instance.activeExpression[3] = !ToggleFaceMod.instance.activeExpression[3];
						ToggleFaceMod.instance.isStillDown[3] = true;
					}
					else if (SemiFunc.InputUp((InputKey)29))
					{
						ToggleFaceMod.instance.isStillDown[3] = false;
					}
					if (SemiFunc.InputDown((InputKey)30) && !ToggleFaceMod.instance.isStillDown[4])
					{
						ToggleFaceMod.instance.activeExpression[4] = !ToggleFaceMod.instance.activeExpression[4];
						ToggleFaceMod.instance.isStillDown[4] = true;
					}
					else if (SemiFunc.InputUp((InputKey)30))
					{
						ToggleFaceMod.instance.isStillDown[4] = false;
					}
					if (SemiFunc.InputDown((InputKey)31) && !ToggleFaceMod.instance.isStillDown[5])
					{
						ToggleFaceMod.instance.activeExpression[5] = !ToggleFaceMod.instance.activeExpression[5];
						ToggleFaceMod.instance.isStillDown[5] = true;
					}
					else if (SemiFunc.InputUp((InputKey)31))
					{
						ToggleFaceMod.instance.isStillDown[5] = false;
					}
					if (ToggleFaceMod.instance.activeExpression[0])
					{
						Utils.CallMethod<PlayerExpression>(__instance, "DoExpression", new object[2] { 1, 100f });
					}
					if (ToggleFaceMod.instance.activeExpression[1])
					{
						Utils.CallMethod<PlayerExpression>(__instance, "DoExpression", new object[2] { 2, 100f });
					}
					if (ToggleFaceMod.instance.activeExpression[2])
					{
						Utils.CallMethod<PlayerExpression>(__instance, "DoExpression", new object[2] { 3, 100f });
					}
					if (ToggleFaceMod.instance.activeExpression[3])
					{
						Utils.CallMethod<PlayerExpression>(__instance, "DoExpression", new object[2] { 4, 100f });
					}
					if (ToggleFaceMod.instance.activeExpression[4])
					{
						Utils.CallMethod<PlayerExpression>(__instance, "DoExpression", new object[2] { 5, 100f });
					}
					if (ToggleFaceMod.instance.activeExpression[5])
					{
						Utils.CallMethod<PlayerExpression>(__instance, "DoExpression", new object[2] { 6, 100f });
					}
				}
			}
			else
			{
				foreach (KeyValuePair<int, float> item2 in Utils.GetField<PlayerAvatar, Dictionary<int, float>>(__instance.playerAvatar, "playerExpressions"))
				{
					ExpressionSettings val = Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[item2.Key];
					val.weight = Mathf.Lerp(val.weight, item2.Value, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime") * 5f);
					if (!Utils.GetField<ExpressionSettings, bool>(val, "stopExpressing"))
					{
						Utils.SetField<ExpressionSettings, bool>(val, "isExpressing", value: true);
						Utils.SetField<ExpressionSettings, float>(val, "timer", 0.2f);
						Utils.GetField<PlayerExpression, List<int>>(__instance, "activeExpressions").Add(item2.Key);
					}
				}
			}
			bool flag = false;
			foreach (int item3 in Utils.GetField<PlayerExpression, List<int>>(__instance, "activeExpressions"))
			{
				if (!list.Contains(item3))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				foreach (int item4 in list)
				{
					if (!Utils.GetField<PlayerExpression, List<int>>(__instance, "activeExpressions").Contains(item4))
					{
						flag = true;
						break;
					}
				}
			}
			if (flag)
			{
				component.HeadTiltImpulse(50f);
			}
			if (Utils.GetField<PlayerExpression, bool>(__instance, "isExpressing"))
			{
				if (Utils.GetField<PlayerAvatarVisuals, bool>(component, "expressionAvatar"))
				{
					Utils.GetField<PlayerAvatarVisuals, Animator>(component, "animator").SetBool("Crouching", false);
				}
				Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[0].weight = Mathf.Lerp(Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[0].weight, 0f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime") * 5f);
				Utils.SetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye", Utils.CallMethod<PlayerExpression, EyeSettings>(__instance, "BlendEyeSettings", new object[1] { true }));
				Utils.SetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye", Utils.CallMethod<PlayerExpression, EyeSettings>(__instance, "BlendEyeSettings", new object[1] { false }));
				Utils.GetField<PlayerExpression, GameObject>(__instance, "eyelidLeft").SetActive(true);
				Utils.GetField<PlayerExpression, GameObject>(__instance, "eyelidRight").SetActive(true);
				Utils.SetField<PlayerExpression, float>(__instance, "blendedHeadTilt", 0f);
				float num = 0f;
				foreach (ExpressionSettings item5 in Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions"))
				{
					if (Utils.GetField<ExpressionSettings, bool>(item5, "isExpressing"))
					{
						Utils.SetField<PlayerExpression, float>(__instance, "blendedHeadTilt", Utils.GetField<PlayerExpression, float>(__instance, "blendedHeadTilt") + Utils.GetField<ExpressionSettings, float>(item5, "headTiltAmount"));
						num += 1f;
					}
				}
				if (num > 0f)
				{
					Utils.SetField<PlayerExpression, float>(__instance, "blendedHeadTilt", Utils.GetField<PlayerExpression, float>(__instance, "blendedHeadTilt") / num);
				}
				component.HeadTiltOverride(Utils.GetField<PlayerExpression, float>(__instance, "blendedHeadTilt"));
				float num2 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftLidsScale"), 1f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "eyelidLeftScale").localScale = new Vector3(num2, num2, num2);
				num2 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightLidsScale"), 1f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "eyelidRightScale").localScale = new Vector3(num2, num2, num2);
				float num3 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftUpperLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").upperLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftUpperEyelidRotationX").localRotation = Quaternion.Euler(num3, 0f, 0f);
				float num4 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftLowerLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").lowerLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftLowerEyelidRotationX").localRotation = Quaternion.Euler(num4, 0f, 0f);
				num3 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightUpperLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").upperLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightUpperEyelidRotationX").localRotation = Quaternion.Euler(num3, 0f, 0f);
				num4 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightLowerLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").lowerLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightLowerEyelidRotationX").localRotation = Quaternion.Euler(num4, 0f, 0f);
				float num5 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftUpperLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").upperLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftUpperEyeLidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num5);
				num5 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightUpperLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").upperLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightUpperEyelidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num5);
				float num6 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftLowerLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").lowerLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftLowerEyelidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num6);
				num6 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightLowerLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").lowerLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightLowerEyelidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num6);
				Utils.SetField<PlayerExpression, float>(__instance, "pupilLeftScaleAmount", SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftPupilSizeSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").pupilSize, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime")));
				Utils.SetField<PlayerExpression, float>(__instance, "pupilRightScaleAmount", SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightPupilSizeSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").pupilSize, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime")));
				if (Utils.GetField<PlayerExpression, bool>(__instance, "isLocal"))
				{
					((SemiUI)PlayerExpressionsUI.instance).Show();
				}
			}
			else if (Utils.GetField<PlayerExpression, GameObject>(__instance, "eyelidLeft").activeSelf)
			{
				Utils.SetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye", Utils.CallMethod<PlayerExpression, EyeSettings>(__instance, "BlendEyeSettings", new object[1] { true }));
				Utils.SetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye", Utils.CallMethod<PlayerExpression, EyeSettings>(__instance, "BlendEyeSettings", new object[1] { false }));
				Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[0].weight = Mathf.Lerp(Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[0].weight, 100f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime") * 20f);
				Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[1].weight = Mathf.Lerp(Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[1].weight, 0f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime") * 20f);
				Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[2].weight = Mathf.Lerp(Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[2].weight, 0f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime") * 20f);
				if (Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[0].weight > 50f)
				{
					if (Utils.GetField<PlayerAvatarVisuals, bool>(component, "expressionAvatar"))
					{
						Utils.GetField<PlayerAvatarVisuals, Animator>(component, "animator").SetBool("Crouching", true);
					}
					float num7 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftLidsScale"), 0.8f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
					Utils.GetField<PlayerExpression, Transform>(__instance, "eyelidLeftScale").localScale = new Vector3(num7, num7, num7);
					num7 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightLidsScale"), 0.8f, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
					Utils.GetField<PlayerExpression, Transform>(__instance, "eyelidRightScale").localScale = new Vector3(num7, num7, num7);
				}
				float num8 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftUpperLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").upperLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftUpperEyelidRotationX").localRotation = Quaternion.Euler(num8, 0f, 0f);
				float num9 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftLowerLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").lowerLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftLowerEyelidRotationX").localRotation = Quaternion.Euler(num9, 0f, 0f);
				num8 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightUpperLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").upperLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightUpperEyelidRotationX").localRotation = Quaternion.Euler(num8, 0f, 0f);
				num9 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightLowerLidClosedAngle"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").lowerLidClosedPercent, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightLowerEyelidRotationX").localRotation = Quaternion.Euler(num9, 0f, 0f);
				float num10 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftUpperLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").upperLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftUpperEyeLidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num10);
				num10 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightUpperLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").upperLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightUpperEyelidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num10);
				float num11 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftLowerLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").lowerLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "leftLowerEyelidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num11);
				num11 = SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightLowerLidRotationZSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").lowerLidAngle, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime"));
				Utils.GetField<PlayerExpression, Transform>(__instance, "rightLowerEyelidRotationZ").localRotation = Quaternion.Euler(0f, 0f, num11);
				Utils.SetField<PlayerExpression, float>(__instance, "pupilLeftScaleAmount", SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "leftPupilSizeSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedLeftEye").pupilSize, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime")));
				Utils.SetField<PlayerExpression, float>(__instance, "pupilRightScaleAmount", SemiFunc.SpringFloatGet(Utils.GetField<PlayerExpression, SpringFloat>(__instance, "rightPupilSizeSpring"), Utils.GetField<PlayerExpression, EyeSettings>(__instance, "blendedRightEye").pupilSize, Utils.GetField<PlayerAvatarVisuals, float>(component, "deltaTime")));
				if (Utils.GetField<PlayerExpression, List<ExpressionSettings>>(__instance, "expressions")[0].weight > 82f)
				{
					Utils.GetField<PlayerExpression, Transform>(__instance, "pupilRightScale").localScale = Vector3.one;
					Utils.GetField<PlayerExpression, Transform>(__instance, "pupilLeftScale").localScale = Vector3.one;
					Utils.GetField<PlayerExpression, GameObject>(__instance, "eyelidLeft").SetActive(false);
					Utils.GetField<PlayerExpression, GameObject>(__instance, "eyelidRight").SetActive(false);
				}
			}
			Utils.CallMethod<PlayerExpression>(__instance, "ExpressionTimerTick", null);
			return false;
		}
	}
}