using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using HarmonyLib;
using UniGLTF;
using UniVRM10;
using UnityEngine;
using UnityEngine.SceneManagement;
using VRM;
using VRMShaders;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("ValheimVRM")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.10.0")]
[assembly: AssemblyInformationalVersion("1.3.10+a304cbd6f74e97de44b3874682edc27f4209119b")]
[assembly: AssemblyProduct("ValheimVRM")]
[assembly: AssemblyTitle("ValheimVRM")]
[assembly: AssemblyVersion("1.3.10.0")]
namespace ValheimVRM;

public static class Commands
{
	public static readonly ConsoleCommand ReloadSettings = new ConsoleCommand("reload_settings", "reload VRM settings for your character", (ConsoleEvent)delegate(ConsoleEventArgs args)
	{
		string text = VrmManager.PlayerToName[Player.m_localPlayer];
		if (VrmManager.VrmDic.ContainsKey(text))
		{
			Settings.AddSettingsFromFile(text, VrmManager.VrmDic[text].Source == VRM.SourceType.Shared);
			VrmManager.VrmDic[text].RecalculateSettingsHash();
			args.Context.AddString("Settings for " + text + " were reloaded");
			((Component)Player.m_localPlayer).GetComponent<VrmController>().ShareVrm(delay: false);
		}
	}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);

	public static readonly ConsoleCommand ReloadGlobalSettings = new ConsoleCommand("reload_global_settings", "reload global VRM settings", (ConsoleEvent)delegate(ConsoleEventArgs args)
	{
		Settings.ReloadGlobalSettings();
		args.Context.AddString("Global settings were reloaded");
	}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);

	public static int Trigger()
	{
		return 1;
	}
}
public class CoroutineHelper : MonoBehaviour
{
	private static CoroutineHelper _instance;

	public static CoroutineHelper Instance
	{
		get
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_instance == (Object)null)
			{
				_instance = new GameObject("CoroutineHelper").AddComponent<CoroutineHelper>();
			}
			return _instance;
		}
	}

	private void Awake()
	{
		if ((Object)(object)_instance == (Object)null)
		{
			_instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}
		else if ((Object)(object)_instance != (Object)(object)this)
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
}
[BepInPlugin("com.yoship1639.plugins.valheimvrm", "ValheimVRM", "1.3.10.0")]
[BepInProcess("valheim.exe")]
public class MainPlugin : BaseUnityPlugin
{
	public const string PluginGuid = "com.yoship1639.plugins.valheimvrm";

	public const string PluginName = "ValheimVRM";

	public const string PluginVersion = "1.3.10.0";

	private static Harmony _harmony = new Harmony("com.yoship1639.plugins.valheimvrm.patch");

	private void Awake()
	{
		CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
		Settings.ReloadGlobalSettings();
		Settings.AddSettingsFromFile("___Default", shared: false);
		PatchFejdStartup.Apply(_harmony);
	}

	internal static void PatchAll()
	{
		if (Settings.globalSettings.EnableProfileCode)
		{
			PatchAllUpdateMethods.ApplyPatches(_harmony);
		}
		_harmony.PatchAll();
		VRMShaders.Initialize();
	}
}
public class MToonColorSync : MonoBehaviour
{
	private class MatColor
	{
		public Material mat;

		public Color color;

		public Color shadeColor;

		public Color emission;

		public bool hasColor;

		public bool hasShadeColor;

		public bool hasEmission;
	}

	private int _SunColor;

	private int _AmbientColor;

	private List<MatColor> matColors = new List<MatColor>();

	private void Awake()
	{
		_SunColor = Shader.PropertyToID("_SunColor");
		_AmbientColor = Shader.PropertyToID("_AmbientColor");
	}

	public void Setup(GameObject vrm)
	{
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		matColors.Clear();
		SkinnedMeshRenderer[] componentsInChildren = vrm.GetComponentsInChildren<SkinnedMeshRenderer>();
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Material[] materials = ((Renderer)componentsInChildren[i]).materials;
			foreach (Material mat in materials)
			{
				if (!matColors.Exists((MatColor m) => (Object)(object)m.mat == (Object)(object)mat))
				{
					matColors.Add(new MatColor
					{
						mat = mat,
						color = (mat.HasProperty("_Color") ? mat.GetColor("_Color") : Color.white),
						shadeColor = (mat.HasProperty("_ShadeColor") ? mat.GetColor("_ShadeColor") : Color.white),
						emission = (mat.HasProperty("_EmissionColor") ? mat.GetColor("_EmissionColor") : Color.black),
						hasColor = mat.HasProperty("_Color"),
						hasShadeColor = mat.HasProperty("_ShadeColor"),
						hasEmission = mat.HasProperty("_EmissionColor")
					});
				}
			}
		}
	}

	private void Update()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		Color globalColor = Shader.GetGlobalColor(_SunColor);
		Color globalColor2 = Shader.GetGlobalColor(_AmbientColor);
		Color val = globalColor + globalColor2;
		if (((Color)(ref val)).maxColorComponent > 0.7f)
		{
			val /= 0.3f + ((Color)(ref val)).maxColorComponent;
		}
		foreach (MatColor matColor in matColors)
		{
			Color val2 = matColor.color * val;
			val2.a = matColor.color.a;
			if (((Color)(ref val2)).maxColorComponent > 1f)
			{
				val2 /= ((Color)(ref val2)).maxColorComponent;
			}
			Color val3 = matColor.shadeColor * val;
			val3.a = matColor.shadeColor.a;
			if (((Color)(ref val3)).maxColorComponent > 1f)
			{
				val3 /= ((Color)(ref val3)).maxColorComponent;
			}
			Color val4 = matColor.emission * ((Color)(ref val)).grayscale;
			if (matColor.hasColor)
			{
				matColor.mat.SetColor("_Color", val2);
			}
			if (matColor.hasShadeColor)
			{
				matColor.mat.SetColor("_ShadeColor", val3);
			}
			if (matColor.hasEmission)
			{
				matColor.mat.SetColor("_EmissionColor", val4);
			}
		}
	}
}
internal static class PatchFejdStartup
{
	public static void Apply(Harmony harmony)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Expected O, but got Unknown
		MethodInfo method = typeof(FejdStartup).GetMethod("Awake", BindingFlags.Instance | BindingFlags.NonPublic);
		if (method == null)
		{
			Debug.LogError((object)"Failed to find Awake method in FejdStartup.");
			return;
		}
		HarmonyMethod val = new HarmonyMethod(typeof(PatchFejdStartup), "Postfix", (Type[])null);
		harmony.Patch((MethodBase)method, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
	}

	private static void Postfix()
	{
		MainPlugin.PatchAll();
	}
}
public static class PatchAllUpdateMethods
{
	public class GenericPState
	{
		public Stopwatch Stopwatch { get; set; }

		public MethodBase CallingMethod { get; set; }
	}

	private static Dictionary<string, List<long>> methodCallTimestamps = new Dictionary<string, List<long>>();

	public static void ApplyPatches(Harmony harmony)
	{
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		string[] assemblyFilesInPath = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll", SearchOption.AllDirectories);
		foreach (Assembly item in assemblies.Where((Assembly a) => IsAssemblyInDirectory(a, assemblyFilesInPath)).ToList())
		{
			try
			{
				if (item.FullName.StartsWith("UnityEngine") || item.FullName.StartsWith("System") || item.FullName.StartsWith("mscorlib") || item.FullName.StartsWith("netstandard") || item.FullName.StartsWith("Microsoft") || item.FullName.StartsWith("Editor") || item.FullName.StartsWith("LuxParticles") || item.FullName.StartsWith("DemoScript"))
				{
					continue;
				}
				Type[] types = item.GetTypes();
				foreach (Type type in types)
				{
					try
					{
						PatchMethod(harmony, type, "Update");
						PatchMethod(harmony, type, "FixedUpdate");
						PatchMethod(harmony, type, "LateUpdate");
					}
					catch (Exception ex)
					{
						Debug.Log((object)("Error patching type " + type.FullName + ": " + ex.Message));
					}
				}
			}
			catch (ReflectionTypeLoadException ex2)
			{
				Debug.Log((object)("Error loading types from " + item.FullName + ": " + ex2.LoaderExceptions[0].Message));
			}
		}
	}

	private static bool IsAssemblyInDirectory(Assembly assembly, string[] assemblyFiles)
	{
		string assemblyLocation = assembly.Location;
		return assemblyFiles.Any((string file) => file.Equals(assemblyLocation, StringComparison.OrdinalIgnoreCase));
	}

	private static void PatchMethod(Harmony harmony, Type type, string methodName)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Expected O, but got Unknown
		//IL_0047: Expected O, but got Unknown
		MethodInfo method = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (method != null)
		{
			try
			{
				harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(PatchAllUpdateMethods), "GenericPrefix", (Type[])null), new HarmonyMethod(typeof(PatchAllUpdateMethods), "GenericPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Debug.Log((object)("Failed to patch method " + methodName + " in " + type.FullName + ": " + ex.Message));
			}
		}
	}

	public static void GenericPrefix(out GenericPState __state)
	{
		MethodBase method = new StackTrace().GetFrame(1).GetMethod();
		__state = new GenericPState
		{
			Stopwatch = new Stopwatch(),
			CallingMethod = method
		};
		__state.Stopwatch.Start();
	}

	public static void GenericPostfix(GenericPState __state)
	{
		__state.Stopwatch.Stop();
		int num = (int)__state.Stopwatch.Elapsed.TotalMilliseconds;
		string text = __state.CallingMethod.DeclaringType.FullName + "." + __state.CallingMethod.Name;
		if (!methodCallTimestamps.ContainsKey(text))
		{
			methodCallTimestamps[text] = new List<long>();
		}
		long currentTimestamp = Stopwatch.GetTimestamp();
		methodCallTimestamps[text].Add(currentTimestamp);
		methodCallTimestamps[text].RemoveAll((long timestamp) => (currentTimestamp - timestamp) / (Stopwatch.Frequency / 1000) > Settings.globalSettings.TimeWindowMs);
		if (methodCallTimestamps[text].Count > Settings.globalSettings.CallThreshold)
		{
			Debug.Log((object)$"{text} called {methodCallTimestamps[text].Count} times in the last {Settings.globalSettings.TimeWindowMs} ms");
		}
		if (num > Settings.globalSettings.ProfileLogThresholdMs)
		{
			Debug.Log((object)$"{text} | Runtime -> {num} ms | Call Count -> {methodCallTimestamps[text].Count}");
		}
	}
}
public static class Settings
{
	public abstract class Container
	{
		public override string ToString()
		{
			return string.Join("\n", from field in GetType().GetFields()
				where field.GetCustomAttribute(typeof(NonSerializedAttribute)) == null
				select field.Name + "=" + field.GetValue(this));
		}

		public string ToStringDiffOnly()
		{
			object defaults = Activator.CreateInstance(GetType());
			return string.Join("\n", from field in GetType().GetFields()
				where !field.GetValue(this).Equals(field.GetValue(defaults)) && field.GetCustomAttribute(typeof(NonSerializedAttribute)) == null
				select field.Name + "=" + field.GetValue(this));
		}

		public void LoadFrom(Dictionary<string, string> data)
		{
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			object obj = Activator.CreateInstance(GetType());
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			List<string> list = data.Keys.ToList();
			FieldInfo[] fields = GetType().GetFields();
			foreach (FieldInfo fieldInfo in fields)
			{
				if (fieldInfo.GetCustomAttribute(typeof(NonSerializedAttribute)) != null)
				{
					continue;
				}
				object value = fieldInfo.GetValue(this);
				object obj2 = fieldInfo.GetValue(obj);
				if (data.TryGetValue(fieldInfo.Name, out var value2))
				{
					try
					{
						if (fieldInfo.FieldType == typeof(float))
						{
							obj2 = float.Parse(value2);
						}
						else if (fieldInfo.FieldType == typeof(bool))
						{
							obj2 = bool.Parse(value2);
						}
						else if (fieldInfo.FieldType == typeof(int))
						{
							obj2 = int.Parse(value2);
						}
						else if (fieldInfo.FieldType == typeof(string))
						{
							obj2 = value2;
						}
						else if (fieldInfo.FieldType == typeof(Vector3))
						{
							Match match = new Regex("\\((?<x>[^,]*?),(?<y>[^,]*?),(?<z>[^,]*?)\\)").Match(value2);
							if (!match.Success)
							{
								throw new FormatException();
							}
							Vector3 val = default(Vector3);
							val.x = float.Parse(match.Groups["x"].Value);
							val.y = float.Parse(match.Groups["y"].Value);
							val.z = float.Parse(match.Groups["z"].Value);
							obj2 = val;
						}
						else if (fieldInfo.FieldType == typeof(Vector2))
						{
							Match match2 = new Regex("\\((?<x>[^,]*?),(?<y>[^,]*?)\\)").Match(value2);
							if (!match2.Success)
							{
								throw new FormatException();
							}
							Vector2 val2 = default(Vector2);
							val2.x = float.Parse(match2.Groups["x"].Value);
							val2.y = float.Parse(match2.Groups["y"].Value);
							obj2 = val2;
						}
						else if (fieldInfo.FieldType == typeof(Vector4))
						{
							Match match3 = new Regex("\\((?<x>[^,]*?),(?<y>[^,]*?),(?<z>[^,]*?),(?<w>[^,]*?)\\)").Match(value2);
							if (!match3.Success)
							{
								throw new FormatException();
							}
							Vector4 val3 = default(Vector4);
							val3.x = float.Parse(match3.Groups["x"].Value);
							val3.y = float.Parse(match3.Groups["y"].Value);
							val3.z = float.Parse(match3.Groups["z"].Value);
							val3.w = float.Parse(match3.Groups["w"].Value);
							obj2 = val3;
						}
						else if (fieldInfo.FieldType.IsEnum)
						{
							obj2 = Enum.ToObject(fieldInfo.FieldType, value2);
						}
						else
						{
							Debug.LogWarning((object)("[ValheimVRM] unsupported setting type: " + fieldInfo.FieldType.FullName + " " + fieldInfo.Name));
						}
					}
					catch (Exception)
					{
						Debug.LogError((object)("[ValheimVRM] failed to read setting: " + fieldInfo.Name + "=" + value2));
					}
					list.Remove(fieldInfo.Name);
				}
				if (!value.Equals(obj2))
				{
					dictionary[fieldInfo.Name] = value;
				}
				fieldInfo.SetValue(this, obj2);
			}
			if (list.Count > 0)
			{
				foreach (string item in list)
				{
					Debug.LogWarning((object)("[ValheimVRM] unknown setting: " + item + "=" + data[item]));
				}
			}
			OnUpdate(dictionary);
		}

		public void Reset()
		{
			object obj = Activator.CreateInstance(GetType());
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			FieldInfo[] fields = GetType().GetFields();
			foreach (FieldInfo fieldInfo in fields)
			{
				if (fieldInfo.GetCustomAttribute(typeof(NonSerializedAttribute)) == null)
				{
					object value = fieldInfo.GetValue(this);
					object value2 = fieldInfo.GetValue(obj);
					fieldInfo.SetValue(this, value2);
					if (!value.Equals(value2))
					{
						dictionary[fieldInfo.Name] = value;
					}
				}
			}
			OnUpdate(dictionary);
		}

		public void CopyFrom(Container another)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			FieldInfo[] fields = GetType().GetFields();
			foreach (FieldInfo fieldInfo in fields)
			{
				if (fieldInfo.GetCustomAttribute(typeof(NonSerializedAttribute)) == null)
				{
					object value = fieldInfo.GetValue(this);
					object value2 = fieldInfo.GetValue(another);
					fieldInfo.SetValue(this, value2);
					if (!value.Equals(value2))
					{
						dictionary[fieldInfo.Name] = value;
					}
				}
			}
			OnUpdate(dictionary);
		}

		public virtual void OnUpdate(Dictionary<string, object> oldValues)
		{
		}
	}

	public class VrmSettingsContainer : Container
	{
		[NonSerialized]
		public string Name;

		public float ModelScale = 1.1f;

		public float ModelOffsetY;

		public float PlayerHeight = 1.85f;

		public float PlayerRadius = 0.5f;

		public Vector3 SittingOnChairOffset = Vector3.zero;

		public Vector3 SittingOnThroneOffset = Vector3.zero;

		public Vector3 SittingOnShipOffset = Vector3.zero;

		public Vector3 HoldingMastOffset = Vector3.zero;

		public Vector3 HoldingDragonOffset = Vector3.zero;

		public Vector3 SittingIdleOffset = Vector3.zero;

		public Vector3 SleepingOffset = Vector3.zero;

		public Vector3 RightHandItemPos = Vector3.zero;

		public Vector3 LeftHandItemPos = Vector3.zero;

		public Vector3 RightHandBackItemPos = Vector3.zero;

		public Vector3 RightHandBackItemToolPos = Vector3.zero;

		public Vector3 LeftHandBackItemPos = Vector3.zero;

		public Vector3 BowBackPos = Vector3.zero;

		public Vector3 KnifeSidePos = Vector3.zero;

		public Vector3 KnifeSideRot = Vector3.zero;

		public Vector3 StaffPos = Vector3.zero;

		public Vector3 StaffSkeletonPos = Vector3.zero;

		public Vector3 StaffRot = Vector3.zero;

		public bool HelmetVisible;

		public Vector3 HelmetScale = Vector3.one;

		public Vector3 HelmetOffset = Vector3.zero;

		public bool ChestVisible;

		public bool ShouldersVisible;

		public bool UtilityVisible;

		public bool LegsVisible;

		public float ModelBrightness = 0.8f;

		public bool FixCameraHeight = true;

		public bool UseMToonShader;

		public bool EnablePlayerFade = true;

		public bool AllowShare = true;

		public float SpringBoneStiffness = 1f;

		public float SpringBoneGravityPower = 1f;

		public float EquipmentScale = 1f;

		public float AttackDistanceScale = 1f;

		public float InteractionDistanceScale = 1f;

		public float SwimDepthScale = 1f;

		public bool AttemptTextureFix;

		public float HeightAspect => PlayerHeight / 1.85f;

		public float RadiusAspect => PlayerRadius / 0.5f;

		public override void OnUpdate(Dictionary<string, object> oldValues)
		{
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			if (!VrmManager.VrmDic.ContainsKey(Name))
			{
				return;
			}
			Player val = null;
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (allPlayer.GetPlayerName() == Name)
				{
					val = allPlayer;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<string, object> oldValue in oldValues)
			{
				switch (oldValue.Key)
				{
				case "ModelScale":
				{
					if (VrmManager.VrmDic.TryGetValue(Name, out var value))
					{
						value.VisualModel.transform.localScale = Vector3.one * ModelScale;
						VrmManager.PlayerToVrmInstance[val].transform.localScale = Vector3.one * ModelScale;
					}
					break;
				}
				case "PlayerHeight":
					((Component)val).GetComponent<CapsuleCollider>().height = PlayerHeight;
					((Component)val).GetComponent<CapsuleCollider>().center = new Vector3(0f, PlayerHeight / 2f, 0f);
					((Component)val).GetComponent<Rigidbody>().centerOfMass = new Vector3(0f, PlayerHeight / 2f, 0f);
					break;
				case "PlayerRadius":
					((Component)val).GetComponent<CapsuleCollider>().radius = PlayerRadius;
					break;
				case "SpringBoneStiffness":
				{
					VRMSpringBone[] componentsInChildren = ((Component)val).GetComponent<VrmController>().visual.GetComponentsInChildren<VRMSpringBone>();
					foreach (VRMSpringBone obj2 in componentsInChildren)
					{
						obj2.m_stiffnessForce = obj2.m_stiffnessForce / (float)oldValue.Value * SpringBoneStiffness;
					}
					break;
				}
				case "SpringBoneGravityPower":
				{
					VRMSpringBone[] componentsInChildren = ((Component)val).GetComponent<VrmController>().visual.GetComponentsInChildren<VRMSpringBone>();
					foreach (VRMSpringBone obj in componentsInChildren)
					{
						obj.m_gravityPower = obj.m_gravityPower / (float)oldValue.Value * SpringBoneGravityPower;
					}
					break;
				}
				case "InteractionDistanceScale":
					val.m_maxInteractDistance = val.m_maxInteractDistance / (float)oldValue.Value * InteractionDistanceScale;
					val.m_maxPlaceDistance = val.m_maxPlaceDistance / (float)oldValue.Value * InteractionDistanceScale;
					break;
				case "SwimDepthScale":
					((Character)val).m_swimDepth = ((Character)val).m_swimDepth / (float)oldValue.Value * SwimDepthScale;
					break;
				}
			}
		}
	}

	public class GlobalSettingsContainer : Container
	{
		public bool ReloadInMenu;

		public bool AcceptVrmSharing = true;

		public bool DrawPlayerSizeGizmo;

		public float StartVrmShareDelay = 10f;

		public bool ForceWindDisabled;

		public bool AllowIndividualWinds = true;

		public bool EnableProfileCode;

		public int ProfileLogThresholdMs = 20;

		public int CallThreshold = 6;

		public int TimeWindowMs = 100;

		public string UseShaderBundle = "current";

		public override void OnUpdate(Dictionary<string, object> oldValues)
		{
			using Dictionary<string, object>.Enumerator enumerator = oldValues.GetEnumerator();
			while (enumerator.MoveNext())
			{
				switch (enumerator.Current.Key)
				{
				case "DrawPlayerSizeGizmo":
				{
					VrmController localController = VrmController.GetLocalController();
					if ((Object)(object)localController != (Object)null)
					{
						if (DrawPlayerSizeGizmo)
						{
							localController.ActivateSizeGizmo();
						}
						else
						{
							localController.DeactivateSizeGizmo();
						}
					}
					break;
				}
				case "ForceWindDisabled":
				{
					VrmController[] array = Object.FindObjectsOfType<VrmController>();
					for (int i = 0; i < array.Length; i++)
					{
						array[i].ResetSpringBonesWind();
					}
					break;
				}
				case "AllowIndividualWinds":
				{
					VrmController[] array = Object.FindObjectsOfType<VrmController>();
					for (int i = 0; i < array.Length; i++)
					{
						array[i].ReloadSpringBones();
					}
					break;
				}
				}
			}
		}
	}

	private static Dictionary<string, VrmSettingsContainer> playerSettings = new Dictionary<string, VrmSettingsContainer>();

	public static readonly GlobalSettingsContainer globalSettings = new GlobalSettingsContainer();

	public static string ValheimVRMDir => Path.Combine(Environment.CurrentDirectory, "ValheimVRM");

	public static string PlayerSettingsPath(string playerName, bool shared)
	{
		return Path.Combine(ValheimVRMDir, shared ? "Shared" : "", "settings_" + playerName + ".txt");
	}

	public static VrmSettingsContainer GetSettings(string playerName)
	{
		if (!playerSettings.ContainsKey(playerName))
		{
			if (!playerSettings.ContainsKey("___Default"))
			{
				return null;
			}
			return playerSettings["___Default"];
		}
		return playerSettings[playerName];
	}

	public static void AddSettingsFromFile(string playerName, bool shared)
	{
		string path = PlayerSettingsPath(playerName, shared);
		if (File.Exists(path))
		{
			AddSettingsRaw(playerName, File.ReadAllLines(path));
			return;
		}
		if (!playerSettings.ContainsKey(playerName))
		{
			playerSettings[playerName] = new VrmSettingsContainer();
		}
		playerSettings[playerName].Name = playerName;
		playerSettings[playerName].Reset();
		Debug.Log((object)("[ValheimVRM] loaded settings for " + playerName + ":\n" + playerSettings[playerName].ToString()));
	}

	public static void AddSettingsRaw(string playerName, ICollection<string> settingLines)
	{
		Dictionary<string, string> dictionary = new Dictionary<string, string>();
		foreach (KeyValuePair<string, string> item in ParseSettings(settingLines))
		{
			dictionary[item.Key] = item.Value;
		}
		if (!playerSettings.ContainsKey(playerName))
		{
			playerSettings[playerName] = new VrmSettingsContainer();
		}
		playerSettings[playerName].Name = playerName;
		playerSettings[playerName].LoadFrom(dictionary);
		dictionary.Max((KeyValuePair<string, string> kvp) => kvp.Key.Length);
		Debug.Log((object)("[ValheimVRM] loaded settings for " + playerName + ":\n" + playerSettings[playerName].ToString()));
	}

	public static bool ContainsSettings(string playerName)
	{
		return playerSettings.ContainsKey(playerName);
	}

	public static IEnumerable<KeyValuePair<string, string>> ParseSettings(IEnumerable<string> lines)
	{
		foreach (string line in lines)
		{
			int num = line.IndexOf("//");
			string text = ((num > -1) ? line.Substring(0, num) : line);
			int num2 = text.IndexOf("=");
			if (num2 != -1)
			{
				string key = text.Substring(0, num2).Trim();
				string value = text.Substring(num2 + 1).Trim();
				yield return new KeyValuePair<string, string>(key, value);
			}
		}
	}

	public static void ReloadGlobalSettings()
	{
		string path = Path.Combine(ValheimVRMDir, "global_settings.txt");
		if (File.Exists(path))
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (KeyValuePair<string, string> item in ParseSettings(File.ReadAllLines(path)))
			{
				dictionary[item.Key] = item.Value;
			}
			globalSettings.LoadFrom(dictionary);
		}
		else
		{
			globalSettings.Reset();
		}
		Debug.Log((object)("[ValheimVRM] loaded global settings:\n" + globalSettings.ToString()));
	}

	public static void RemoveSettings(string playerName)
	{
		if (playerSettings.ContainsKey(playerName))
		{
			playerSettings.Remove(playerName);
		}
	}
}
public sealed class TextureDeserializerAsync : ITextureDeserializer
{
	public async Task<Texture2D> LoadTextureAsync(DeserializingTextureInfo textureInfo, IAwaitCaller awaitCaller)
	{
		LoaderSettings val = default(LoaderSettings);
		val.linear = (int)textureInfo.ColorSpace == 1;
		string dataMimeType = textureInfo.DataMimeType;
		if (!(dataMimeType == "image/png"))
		{
			if (dataMimeType == "image/jpeg")
			{
				val.format = (Format)2;
			}
			else if (string.IsNullOrEmpty(textureInfo.DataMimeType))
			{
				Debug.Log((object)"Texture image MIME type is empty.");
			}
			else
			{
				Debug.Log((object)("Texture image MIME type `" + textureInfo.DataMimeType + "` is not supported."));
			}
		}
		else
		{
			val.format = (Format)13;
		}
		Texture2D texture = await AsyncImageLoader.CreateFromImageAsync(textureInfo.ImageData, val);
		((Texture)texture).wrapModeU = textureInfo.WrapModeU;
		((Texture)texture).wrapModeV = textureInfo.WrapModeV;
		((Texture)texture).filterMode = textureInfo.FilterMode;
		await awaitCaller.NextFrame();
		return texture;
	}
}
public sealed class TextureDeserializer : ITextureDeserializer
{
	public async Task<Texture2D> LoadTextureAsync(DeserializingTextureInfo textureInfo, IAwaitCaller awaitCaller)
	{
		LoaderSettings val = default(LoaderSettings);
		val.linear = (int)textureInfo.ColorSpace == 1;
		switch (textureInfo.DataMimeType)
		{
		case "image/png":
			val.format = (Format)13;
			break;
		case "image/jpg":
		case "image/jpeg":
			val.format = (Format)2;
			break;
		default:
			if (string.IsNullOrEmpty(textureInfo.DataMimeType))
			{
				Debug.Log((object)"Texture image MIME type is empty.");
			}
			else
			{
				Debug.Log((object)("Texture image MIME type `" + textureInfo.DataMimeType + "` is not supported."));
			}
			break;
		}
		Texture2D texture = AsyncImageLoader.CreateFromImage(textureInfo.ImageData, val);
		((Texture)texture).wrapModeU = textureInfo.WrapModeU;
		((Texture)texture).wrapModeV = textureInfo.WrapModeV;
		((Texture)texture).filterMode = textureInfo.FilterMode;
		await awaitCaller.NextFrame();
		return texture;
	}
}
public class TimeTracker
{
	private static DateTime startTime;

	private static DateTime lastAccessTime;

	private static bool isStartTimeSet;

	public static void SetStartTime()
	{
		startTime = DateTime.UtcNow;
		lastAccessTime = DateTime.UtcNow;
		isStartTimeSet = true;
	}

	public static string GetElapsedTime()
	{
		if (!isStartTimeSet)
		{
			Debug.LogError((object)"Start time not set. Call SetStartTime() before getting elapsed time.");
			return "Error: Start time not set.";
		}
		DateTime utcNow = DateTime.UtcNow;
		TimeSpan timeSpan = utcNow - lastAccessTime;
		TimeSpan timeSpan2 = utcNow - startTime;
		lastAccessTime = utcNow;
		string text = $"{Math.Round(timeSpan.TotalMilliseconds, 2)}ms";
		string text2 = $"{Math.Round(timeSpan2.TotalSeconds, 2)}s";
		return " Time From Last: " + text + " | Total Time Elapsed: " + text2;
	}
}
public static class Utils
{
	public static Tout GetField<Tin, Tout>(this Tin self, string fieldName)
	{
		return AccessTools.FieldRefAccess<Tin, Tout>(fieldName).Invoke(self);
	}

	public static string GetHaxadecimalString(this IEnumerable<byte> self)
	{
		if (self == null)
		{
			return "none";
		}
		StringBuilder stringBuilder = new StringBuilder(self.Count() * 2);
		foreach (byte item in self)
		{
			stringBuilder.AppendFormat("{0:x2}", item);
		}
		return stringBuilder.ToString();
	}

	public static V GetOrCreateDefault<K, V>(this IDictionary<K, V> self, K key) where V : new()
	{
		if (self.ContainsKey(key))
		{
			return self[key];
		}
		return self[key] = new V();
	}

	public static bool CompareArrays<T>(IEnumerable<T> a, IEnumerable<T> b)
	{
		if (a == null == (b == null))
		{
			if (a == null || b == null)
			{
				return true;
			}
			return a.SequenceEqual(b);
		}
		return false;
	}

	public static FieldInfo GetField<T>(string name)
	{
		return typeof(T).GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
	}

	public static MethodInfo GetMethod<T>(string name)
	{
		return typeof(T).GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
	}

	public static int FindOp(this List<CodeInstruction> self, OpCode code, int from = 0)
	{
		return self.FindIndex(from, (CodeInstruction inst) => inst.opcode == code);
	}

	public static int FindOp(this List<CodeInstruction> self, OpCode code, object operand, int from = 0)
	{
		return self.FindIndex(from, (CodeInstruction inst) => inst.opcode == code && inst.operand.Equals(operand));
	}

	public static bool IsOp(CodeInstruction self, OpCode code)
	{
		return self.opcode == code;
	}

	public static bool IsOp(this CodeInstruction self, OpCode code, object operand)
	{
		if (self.opcode == code)
		{
			return self.operand.Equals(operand);
		}
		return false;
	}
}
[HarmonyPatch(typeof(Shader))]
[HarmonyPatch("Find")]
internal static class ShaderPatch
{
	private static readonly Dictionary<string, Shader> ShaderDictionary;

	static ShaderPatch()
	{
		ShaderDictionary = new Dictionary<string, Shader>();
		Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
		foreach (Shader val in array)
		{
			if (!ShaderDictionary.ContainsKey(((Object)val).name))
			{
				ShaderDictionary.Add(((Object)val).name, val);
			}
		}
		Debug.Log((object)"[ValheimVRM ShaderPatch] All shaders loaded into ShaderDictionary.");
	}

	private static bool Prefix(ref Shader __result, string name)
	{
		if (ShaderDictionary.TryGetValue(name, out var value))
		{
			Debug.Log((object)("[ValheimVRM ShaderPatch] Shader '" + name + "' found in preloaded ShaderDictionary."));
			__result = value;
			return false;
		}
		if (VRMShaders.Shaders.TryGetValue(name, out value))
		{
			Debug.Log((object)("[ValheimVRM ShaderPatch] Shader '" + name + "' found in VRMShaders.Shaders"));
			__result = value;
			return false;
		}
		Debug.Log((object)("[ValheimVRM ShaderPatch] Shader '" + name + "' NOT FOUND in ShaderDictionary. passing method to original Shader.Find."));
		return true;
	}
}
public static class VRMShaders
{
	public static Dictionary<string, Shader> Shaders { get; } = new Dictionary<string, Shader>();


	public static void Initialize()
	{
		string text = "";
		if (Settings.globalSettings.UseShaderBundle == "current")
		{
			text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "UniVrm.shaders");
		}
		else if (Settings.globalSettings.UseShaderBundle == "old")
		{
			text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "OldUniVrm.shaders");
		}
		else
		{
			Debug.LogError((object)"[ValheimVRM] Invalid UseShaderBundle; old, current");
		}
		if (File.Exists(text))
		{
			Shader[] array = AssetBundle.LoadFromFile(text).LoadAllAssets<Shader>();
			foreach (Shader val in array)
			{
				Debug.Log((object)("[ValheimVRM] Add Shader: " + ((Object)val).name));
				Shaders.Add(((Object)val).name, val);
			}
		}
	}
}
public static class VrmManager
{
	public static Dictionary<Player, GameObject> PlayerToVrmInstance = new Dictionary<Player, GameObject>();

	public static Dictionary<Player, string> PlayerToName = new Dictionary<Player, string>();

	public static Dictionary<string, VRM> VrmDic = new Dictionary<string, VRM>();

	public static VRM RegisterVrm(VRM vrm, LODGroup sampleLODGroup, Player player)
	{
		//IL_0229: 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)
		if ((Object)(object)vrm.VisualModel == (Object)null)
		{
			return null;
		}
		foreach (KeyValuePair<string, VRM> item3 in VrmDic)
		{
			if (!(item3.Key == vrm.Name) && (item3.Value == vrm || (Object)(object)item3.Value.VisualModel == (Object)(object)vrm.VisualModel))
			{
				Debug.LogError((object)("[ValheimVRM] attempt to register a vrm that is already registered as " + item3.Key));
				return null;
			}
		}
		if (VrmDic.ContainsKey(vrm.Name))
		{
			VRM vRM = VrmDic[vrm.Name];
			if (vRM == vrm)
			{
				return vrm;
			}
			if ((Object)(object)vRM.VisualModel != (Object)(object)vrm.VisualModel)
			{
				Object.Destroy((Object)(object)vRM.VisualModel);
			}
			VrmDic[vrm.Name] = null;
		}
		Object.DontDestroyOnLoad((Object)(object)vrm.VisualModel);
		VrmDic[vrm.Name] = vrm;
		Settings.VrmSettingsContainer settings = Settings.GetSettings(vrm.Name);
		List<Material> list = new List<Material>();
		SkinnedMeshRenderer[] componentsInChildren = vrm.VisualModel.GetComponentsInChildren<SkinnedMeshRenderer>();
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Material[] materials = ((Renderer)componentsInChildren[i]).materials;
			foreach (Material item in materials)
			{
				if (!list.Contains(item))
				{
					list.Add(item);
				}
			}
		}
		MeshRenderer[] componentsInChildren2 = vrm.VisualModel.GetComponentsInChildren<MeshRenderer>();
		for (int i = 0; i < componentsInChildren2.Length; i++)
		{
			Material[] materials = ((Renderer)componentsInChildren2[i]).materials;
			foreach (Material item2 in materials)
			{
				if (!list.Contains(item2))
				{
					list.Add(item2);
				}
			}
		}
		((MonoBehaviour)CoroutineHelper.Instance).StartCoroutine(ProcessMaterialsCoroutine(vrm, list, settings));
		LODGroup val = vrm.VisualModel.AddComponent<LODGroup>();
		if (settings.EnablePlayerFade)
		{
			LOD[] array = new LOD[1];
			Renderer[] componentsInChildren3 = (Renderer[])(object)vrm.VisualModel.GetComponentsInChildren<SkinnedMeshRenderer>();
			array[0] = new LOD(0.1f, componentsInChildren3);
			val.SetLODs((LOD[])(object)array);
		}
		val.RecalculateBounds();
		val.fadeMode = sampleLODGroup.fadeMode;
		val.animateCrossFading = sampleLODGroup.animateCrossFading;
		vrm.VisualModel.SetActive(false);
		return vrm;
	}

	public static IEnumerator ProcessMaterialsCoroutine(VRM vrm, List<Material> materials, Settings.VrmSettingsContainer settings)
	{
		Shader foundShader = Shader.Find("Custom/Player");
		foreach (Material mat in materials)
		{
			if (settings.UseMToonShader && !settings.AttemptTextureFix && mat.HasProperty("_Color"))
			{
				Color color2 = mat.GetColor("_Color");
				color2.r *= settings.ModelBrightness;
				color2.g *= settings.ModelBrightness;
				color2.b *= settings.ModelBrightness;
				mat.SetColor("_Color", color2);
			}
			else if (settings.AttemptTextureFix && (Object)(object)mat.shader != (Object)(object)foundShader)
			{
				Color color = (mat.HasProperty("_Color") ? mat.GetColor("_Color") : Color.white);
				Texture2D val = (Texture2D)(mat.HasProperty("_MainTex") ? /*isinst with value type is only supported in some contexts*/: null);
				Texture2D tex = val;
				if ((Object)(object)val != (Object)null)
				{
					tex = new Texture2D(((Texture)val).width, ((Texture)val).height);
					Color[] pixels = val.GetPixels();
					Task pixelsTask = Task.Run(delegate
					{
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0011: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						//IL_001b: Unknown result type (might be due to invalid IL or missing references)
						//IL_001c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0049: Unknown result type (might be due to invalid IL or missing references)
						//IL_004e: Unknown result type (might be due to invalid IL or missing references)
						//IL_005f: Unknown result type (might be due to invalid IL or missing references)
						float num = default(float);
						float num2 = default(float);
						float num3 = default(float);
						for (int i = 0; i < pixels.Length; i++)
						{
							Color val3 = pixels[i] * color;
							Color.RGBToHSV(val3, ref num, ref num2, ref num3);
							num3 *= settings.ModelBrightness;
							pixels[i] = Color.HSVToRGB(num, num2, num3, true);
							pixels[i].a = val3.a;
						}
					});
					while (!pixelsTask.IsCompleted)
					{
						yield return (object)new WaitUntil((Func<bool>)(() => pixelsTask.IsCompleted));
					}
					pixelsTask.Wait();
					tex.SetPixels(pixels);
					tex.Apply();
				}
				Texture val2 = (mat.HasProperty("_BumpMap") ? mat.GetTexture("_BumpMap") : null);
				mat.shader = foundShader;
				mat.SetTexture("_MainTex", (Texture)(object)tex);
				mat.SetTexture("_SkinBumpMap", val2);
				mat.SetColor("_SkinColor", color);
				mat.SetTexture("_ChestTex", (Texture)(object)tex);
				mat.SetTexture("_ChestBumpMap", val2);
				mat.SetTexture("_LegsTex", (Texture)(object)tex);
				mat.SetTexture("_LegsBumpMap", val2);
				mat.SetFloat("_Glossiness", 0.2f);
				mat.SetFloat("_MetalGlossiness", 0f);
			}
			yield return null;
		}
		Debug.Log((object)"[ValheimVRM] Material processing completed.");
	}
}
[HarmonyPatch(typeof(VisEquipment), "UpdateLodgroup")]
internal static class Patch_VisEquipment_UpdateLodgroup
{
	[HarmonyPostfix]
	private static void Postfix(VisEquipment __instance)
	{
		//IL_021d: Unknown result type (might be due to invalid IL or missing references)
		//IL_022e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_0254: Unknown result type (might be due to invalid IL or missing references)
		//IL_0265: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0302: Unknown result type (might be due to invalid IL or missing references)
		//IL_033e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0345: Unknown result type (might be due to invalid IL or missing references)
		//IL_0356: Unknown result type (might be due to invalid IL or missing references)
		//IL_035d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0407: Unknown result type (might be due to invalid IL or missing references)
		//IL_0411: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0422: Unknown result type (might be due to invalid IL or missing references)
		//IL_0429: Unknown result type (might be due to invalid IL or missing references)
		//IL_0330: Unknown result type (might be due to invalid IL or missing references)
		//IL_0328: Unknown result type (might be due to invalid IL or missing references)
		//IL_0335: Unknown result type (might be due to invalid IL or missing references)
		if (!__instance.m_isPlayer)
		{
			return;
		}
		Player component = ((Component)__instance).GetComponent<Player>();
		if ((Object)(object)component == (Object)null || !VrmManager.PlayerToVrmInstance.ContainsKey(component))
		{
			return;
		}
		Settings.VrmSettingsContainer settings = Settings.GetSettings(VrmManager.PlayerToName[component]);
		GameObject field = __instance.GetField<VisEquipment, GameObject>("m_hairItemInstance");
		if ((Object)(object)field != (Object)null)
		{
			SetVisible(field, flag: false);
		}
		GameObject field2 = __instance.GetField<VisEquipment, GameObject>("m_beardItemInstance");
		if ((Object)(object)field2 != (Object)null)
		{
			SetVisible(field2, flag: false);
		}
		List<GameObject> field3 = __instance.GetField<VisEquipment, List<GameObject>>("m_chestItemInstances");
		if (field3 != null && !settings.ChestVisible)
		{
			foreach (GameObject item in field3)
			{
				SetVisible(item, flag: false);
			}
		}
		List<GameObject> field4 = __instance.GetField<VisEquipment, List<GameObject>>("m_legItemInstances");
		if (field4 != null && !settings.LegsVisible)
		{
			foreach (GameObject item2 in field4)
			{
				SetVisible(item2, flag: false);
			}
		}
		List<GameObject> field5 = __instance.GetField<VisEquipment, List<GameObject>>("m_shoulderItemInstances");
		if (field5 != null && field5 != null && !settings.ShouldersVisible)
		{
			foreach (GameObject item3 in field5)
			{
				SetVisible(item3, flag: false);
			}
		}
		List<GameObject> field6 = __instance.GetField<VisEquipment, List<GameObject>>("m_utilityItemInstances");
		if (field6 != null && !settings.UtilityVisible)
		{
			foreach (GameObject item4 in field6)
			{
				SetVisible(item4, flag: false);
			}
		}
		GameObject field7 = __instance.GetField<VisEquipment, GameObject>("m_helmetItemInstance");
		if ((Object)(object)field7 != (Object)null)
		{
			if (!settings.HelmetVisible)
			{
				SetVisible(field7, flag: false);
			}
			else
			{
				field7.transform.localScale = settings.HelmetScale;
				field7.transform.localPosition = settings.HelmetOffset;
			}
		}
		float equipmentScale = settings.EquipmentScale;
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(equipmentScale, equipmentScale, equipmentScale);
		GameObject field8 = __instance.GetField<VisEquipment, GameObject>("m_leftItemInstance");
		if ((Object)(object)field8 != (Object)null)
		{
			field8.transform.localPosition = settings.LeftHandItemPos;
			field8.transform.localScale = val;
		}
		GameObject field9 = __instance.GetField<VisEquipment, GameObject>("m_rightItemInstance");
		if ((Object)(object)field9 != (Object)null)
		{
			field9.transform.localPosition = settings.RightHandItemPos;
			field9.transform.localScale = val;
		}
		GameObject field10 = __instance.GetField<VisEquipment, GameObject>("m_rightBackItemInstance");
		if ((Object)(object)field10 != (Object)null)
		{
			object? value = Utils.GetField<VisEquipment>("m_rightBackItem").GetValue(__instance);
			bool flag = value.ToString().Substring(0, 5) == "Knife";
			bool flag2 = value.ToString().Substring(0, 5) == "Staff";
			Vector3 zero = Vector3.zero;
			if (flag)
			{
				zero = settings.KnifeSidePos;
				field10.transform.Rotate(settings.KnifeSideRot);
			}
			else if (flag2)
			{
				zero = settings.StaffPos;
				field10.transform.Rotate(settings.StaffRot);
			}
			else
			{
				zero = (((Object)(object)field10.transform.parent == (Object)(object)__instance.m_backTool) ? settings.RightHandBackItemToolPos : settings.RightHandBackItemPos);
			}
			field10.transform.localPosition = zero / 100f;
			field10.transform.localScale = val / 100f;
		}
		GameObject field11 = __instance.GetField<VisEquipment, GameObject>("m_leftBackItemInstance");
		if ((Object)(object)field11 != (Object)null)
		{
			object? value2 = Utils.GetField<VisEquipment>("m_leftBackItem").GetValue(__instance);
			bool flag3 = value2.ToString().Substring(0, 3) == "Bow";
			bool flag4 = value2.ToString() == "StaffSkeleton";
			if (flag3)
			{
				field11.transform.localPosition = settings.BowBackPos / 100f;
			}
			else if (flag4)
			{
				field11.transform.localPosition = settings.StaffSkeletonPos / 100f;
			}
			else
			{
				field11.transform.localPosition = settings.LeftHandBackItemPos / 100f;
			}
			field11.transform.localScale = val / 100f;
		}
	}

	private static void SetVisible(GameObject obj, bool flag)
	{
		MeshRenderer[] componentsInChildren = obj.GetComponentsInChildren<MeshRenderer>();
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			((Renderer)componentsInChildren[i]).enabled = flag;
		}
		SkinnedMeshRenderer[] componentsInChildren2 = obj.GetComponentsInChildren<SkinnedMeshRenderer>();
		for (int i = 0; i < componentsInChildren2.Length; i++)
		{
			((Renderer)componentsInChildren2[i]).enabled = flag;
		}
	}
}
[HarmonyPatch(typeof(Humanoid), "OnRagdollCreated")]
internal static class Patch_Humanoid_OnRagdollCreated
{
	[HarmonyPostfix]
	private static void Postfix(Humanoid __instance, Ragdoll ragdoll)
	{
		Player val = (Player)(object)((__instance is Player) ? __instance : null);
		if (val != null)
		{
			SkinnedMeshRenderer[] componentsInChildren = ((Component)ragdoll).GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer obj in componentsInChildren)
			{
				((Renderer)obj).forceRenderingOff = true;
				obj.updateWhenOffscreen = true;
			}
			Animator val2 = ((Component)ragdoll).gameObject.AddComponent<Animator>();
			val2.keepAnimatorStateOnDisable = true;
			val2.cullingMode = (AnimatorCullingMode)0;
			Animator field = val.GetField<Player, Animator>("m_animator");
			val2.avatar = field.avatar;
			if (VrmManager.PlayerToVrmInstance.TryGetValue(val, out var value))
			{
				value.transform.SetParent(((Component)ragdoll).transform);
				value.GetComponent<VRMAnimationSync>().Setup(val2, Settings.GetSettings(VrmManager.PlayerToName[val]), isRagdoll: true);
			}
		}
	}
}
[HarmonyPatch(typeof(Character), "SetVisible")]
internal static class Patch_Character_SetVisible
{
	[HarmonyPostfix]
	private static void Postfix(Character __instance, bool visible)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		if (!__instance.IsPlayer() || !VrmManager.PlayerToVrmInstance.TryGetValue((Player)__instance, out var value) || !((Object)(object)value != (Object)null))
		{
			return;
		}
		LODGroup component = value.GetComponent<LODGroup>();
		if ((Object)(object)component != (Object)null)
		{
			if (visible)
			{
				component.localReferencePoint = __instance.GetField<Character, Vector3>("m_originalLocalRef");
			}
			else
			{
				component.localReferencePoint = new Vector3(999999f, 999999f, 999999f);
			}
		}
	}
}
[HarmonyPatch(typeof(Player), "OnDeath")]
internal static class Patch_Player_OnDeath
{
	[HarmonyPostfix]
	private static void Postfix(Player __instance)
	{
		string text = null;
		if (VrmManager.PlayerToName.ContainsKey(__instance))
		{
			text = VrmManager.PlayerToName[__instance];
		}
		if (text != null && Settings.GetSettings(text).FixCameraHeight)
		{
			Object.Destroy((Object)(object)((Component)__instance).GetComponent<VRMEyePositionSync>());
		}
	}
}
[HarmonyPatch(typeof(Character), "GetHeadPoint")]
internal static class Patch_Character_GetHeadPoint
{
	[HarmonyPostfix]
	private static bool Prefix(Character __instance, ref Vector3 __result)
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		Player val = (Player)(object)((__instance is Player) ? __instance : null);
		if ((Object)(object)val == (Object)null)
		{
			return true;
		}
		if (VrmManager.PlayerToVrmInstance.TryGetValue(val, out var value))
		{
			Animator componentInChildren = value.GetComponentInChildren<Animator>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return true;
			}
			Transform boneTransform = componentInChildren.GetBoneTransform((HumanBodyBones)10);
			if ((Object)(object)boneTransform == (Object)null)
			{
				return true;
			}
			__result = boneTransform.position;
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(Hud), "UpdateStealth")]
public static class Patch_Hud_UpdateStealth
{
	[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
	private static void Postfix(Hud __instance, Player player, float bowDrawPercentage)
	{
		if (((Character)player).IsCrouching() && (double)bowDrawPercentage == 0.0)
		{
			if (player.IsSensed())
			{
				__instance.m_targetedAlert.SetActive(true);
				__instance.m_targeted.SetActive(false);
				__instance.m_hidden.SetActive(false);
			}
			else if (player.IsTargeted())
			{
				__instance.m_targetedAlert.SetActive(false);
				__instance.m_targeted.SetActive(true);
				__instance.m_hidden.SetActive(false);
			}
			else
			{
				__instance.m_targetedAlert.SetActive(false);
				__instance.m_targeted.SetActive(false);
				__instance.m_hidden.SetActive(true);
			}
			((Component)__instance.m_stealthBar).gameObject.SetActive(true);
			__instance.m_stealthBar.SetValue(((Character)player).GetStealthFactor());
		}
		else
		{
			__instance.m_targetedAlert.SetActive(false);
			__instance.m_hidden.SetActive(false);
			__instance.m_targeted.SetActive(false);
			((Component)__instance.m_stealthBar).gameObject.SetActive(false);
		}
	}
}
[HarmonyPatch(typeof(Humanoid), "StartAttack")]
internal static class Patch_Humanoid_StartAttack
{
	[HarmonyPostfix]
	private static void Postfix(Humanoid __instance, Character target, bool secondaryAttack)
	{
		Player val = (Player)(object)((__instance is Player) ? __instance : null);
		if (val != null)
		{
			ref Attack reference = ref AccessTools.FieldRefAccess<Player, Attack>("m_currentAttack").Invoke(val);
			if (reference != null && AccessTools.FieldRefAccess<Attack, float>("m_time").Invoke(reference) == 0f && VrmManager.PlayerToName.TryGetValue(val, out var value) && Settings.ContainsSettings(value))
			{
				Settings.VrmSettingsContainer settings = Settings.GetSettings(value);
				Attack obj = reference;
				obj.m_attackRange *= settings.AttackDistanceScale;
				Attack obj2 = reference;
				obj2.m_attackHeight *= settings.PlayerHeight / 1.85f;
				Attack obj3 = reference;
				obj3.m_attackOffset *= settings.PlayerHeight / 1.85f;
			}
		}
	}
}
[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
internal static class Patch_Player_UpdatePlacementGhost
{
	[HarmonyPostfix]
	private static void UpdatePlacementGhost(Player __instance, bool flashGuardStone)
	{
		FieldInfo field = typeof(Player).GetField("m_placementStatus", BindingFlags.Instance | BindingFlags.NonPublic);
		if ((int)field.GetValue(__instance) == 10)
		{
			field.SetValue(__instance, 0);
		}
	}
}
[HarmonyPatch(typeof(Game), "SpawnPlayer")]
internal static class Patch_Game_SpawnPlayer
{
	[HarmonyPostfix]
	private static void Postfix(Game __instance, bool ___m_firstSpawn, Player __result)
	{
		if (___m_firstSpawn)
		{
			((Component)__result).GetComponent<VrmController>().ShareVrm();
			((Component)__result).GetComponent<VrmController>().QueryAllVrm();
		}
	}
}
[HarmonyPatch(typeof(Player), "OnDestroy")]
internal static class Patch_Player_OnDestroy
{
	[HarmonyPostfix]
	private static void Postfix(Player __instance)
	{
		VrmManager.PlayerToName.Remove(__instance);
		VrmManager.PlayerToVrmInstance.Remove(__instance);
	}
}
[HarmonyPatch(typeof(Player), "Awake")]
internal static class Patch_Player_Awake
{
	[HarmonyPostfix]
	private static void Postfix(Player __instance, ZNetView ___m_nview)
	{
		//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)
		Commands.Trigger();
		string text = null;
		string text2 = null;
		if ((Object)(object)Game.instance != (Object)null)
		{
			text2 = Game.instance.GetPlayerProfile().GetName();
			text = __instance.GetPlayerName();
			if (text == "" || text == "...")
			{
				text = text2;
			}
		}
		else
		{
			int field = FejdStartup.instance.GetField<FejdStartup, int>("m_profileIndex");
			List<PlayerProfile> field2 = FejdStartup.instance.GetField<FejdStartup, List<PlayerProfile>>("m_profiles");
			if (field >= 0 && field < field2.Count)
			{
				text = field2[field].GetName();
			}
			text2 = text;
		}
		VrmManager.PlayerToName[__instance] = text;
		Scene scene = ((Component)__instance).gameObject.scene;
		bool flag = ((Scene)(ref scene)).name == "start";
		if (flag)
		{
			foreach (string item in new List<string>(VrmManager.VrmDic.Keys))
			{
				if (VrmManager.VrmDic[item].Source == VRM.SourceType.Shared)
				{
					VrmManager.VrmDic.Remove(item);
					Settings.RemoveSettings(item);
				}
			}
			VrmController.CleanupLoadings();
		}
		___m_nview.GetZDO();
		((Component)__instance).gameObject.AddComponent<VrmController>();
		if (string.IsNullOrEmpty(text))
		{
			return;
		}
		bool settingsUpdated = false;
		string path = Path.Combine(Environment.CurrentDirectory, "ValheimVRM", text + ".vrm");
		string path2 = Path.Combine(Environment.CurrentDirectory, "ValheimVRM", "Shared", text + ".vrm");
		if (!Settings.ContainsSettings(text) || (Settings.globalSettings.ReloadInMenu && flag))
		{
			if (File.Exists(path))
			{
				Settings.AddSettingsFromFile(text, shared: false);
				settingsUpdated = true;
			}
			else if (File.Exists(path2))
			{
				Settings.AddSettingsFromFile(text, shared: true);
				settingsUpdated = true;
			}
		}
		VRM vrm = null;
		Settings.VrmSettingsContainer settings = Settings.GetSettings(text);
		if (settings != null)
		{
			if (!VrmManager.VrmDic.ContainsKey(text) || (Settings.globalSettings.ReloadInMenu && flag))
			{
				if (File.Exists(path))
				{
					if (text2 == text)
					{
						byte[] array = File.ReadAllBytes(path);
						GameObject val = VRM.ImportVisual(array, path, settings.ModelScale);
						if ((Object)(object)val != (Object)null)
						{
							vrm = CreateVrm(val, __instance, array, text);
						}
					}
					else
					{
						((MonoBehaviour)CoroutineHelper.Instance).StartCoroutine(LoadVrm(__instance, text, text2, path, settings.ModelScale, settingsUpdated, settings));
					}
				}
				else if (File.Exists(path2))
				{
					if (text2 == text)
					{
						byte[] array2 = File.ReadAllBytes(path2);
						GameObject val2 = VRM.ImportVisual(array2, path2, settings.ModelScale);
						if ((Object)(object)val2 != (Object)null)
						{
							vrm = CreateVrm(val2, __instance, array2, text, isShared: true);
						}
					}
					else
					{
						((MonoBehaviour)CoroutineHelper.Instance).StartCoroutine(LoadVrm(__instance, text, text2, path2, settings.ModelScale, settingsUpdated, settings, isShared: true));
					}
				}
				else if (!VrmManager.VrmDic.ContainsKey("___Default"))
				{
					string path3 = Path.Combine(Environment.CurrentDirectory, "ValheimVRM", "___Default.vrm");
					if (File.Exists(path3))
					{
						if (text2 == text)
						{
							byte[] array3 = File.ReadAllBytes(path3);
							GameObject val3 = VRM.ImportVisual(array3, path3, settings.ModelScale);
							if ((Object)(object)val3 != (Object)null)
							{
								vrm = CreateVrm(val3, __instance, array3, text);
							}
						}
						else
						{
							((MonoBehaviour)CoroutineHelper.Instance).StartCoroutine(LoadVrm(__instance, "___Default", text2, path3, settings.ModelScale, settingsUpdated, settings));
						}
					}
				}
				else
				{
					vrm = VrmManager.VrmDic["___Default"];
				}
			}
			else
			{
				vrm = VrmManager.VrmDic[text];
			}
		}
		else
		{
			Debug.LogError((object)"Settings are still null");
		}
		SetVrm(__instance, vrm, settingsUpdated);
	}

	private static void SetVrm(Player player, VRM vrm, bool settingsUpdated)
	{
		if (vrm != null)
		{
			if (settingsUpdated)
			{
				vrm.RecalculateSettingsHash();
			}
			((MonoBehaviour)CoroutineHelper.Instance).StartCoroutine(vrm.SetToPlayer(player));
		}
	}

	private static VRM CreateVrm(GameObject vrmVisual, Player player, byte[] bytes, string name, bool isShared = false)
	{
		VRM vrm = new VRM(vrmVisual, name);
		vrm = VrmManager.RegisterVrm(vrm, ((Component)player).GetComponentInChildren<LODGroup>(), player);
		if (vrm != null)
		{
			vrm.Src = bytes;
			vrm.RecalculateSrcBytesHash();
			if (isShared)
			{
				vrm.Source = VRM.SourceType.Shared;
			}
		}
		return vrm;
	}

	private static IEnumerator LoadVrm(Player player, string playerName, string localPlayerName, string path, float scale, bool settingsUpdated, Settings.VrmSettingsContainer settings, bool isShared = false)
	{
		Task<byte[]> bytesTask = Task.Run(() => File.ReadAllBytes(path));
		while (!bytesTask.IsCompleted)
		{
			yield return (object)new WaitUntil((Func<bool>)(() => bytesTask.IsCompleted));
		}
		if (bytesTask.IsFaulted)
		{
			Debug.LogError((object)$"Error loading VRM: {bytesTask.Exception.Flatten().InnerException}");
			yield break;
		}
		yield return ((MonoBehaviour)player).StartCoroutine(VRM.ImportVisualAsync(bytesTask.Result, path, settings.ModelScale, delegate(GameObject loadedRoot)
		{
			if ((Object)(object)loadedRoot != (Object)null)
			{
				VRM vRM = CreateVrm(loadedRoot, player, bytesTask.Result, playerName, isShared);
				if (vRM != null)
				{
					SetVrm(player, vRM, settingsUpdated);
				}
			}
		}));
	}
}
public class VRM
{
	public enum SourceType
	{
		Local,
		Shared
	}

	public class Timer : IDisposable
	{
		private Stopwatch stopwatch;

		private string name;

		public Timer(string name)
		{
			this.name = name;
			stopwatch = Stopwatch.StartNew();
		}

		public void Dispose()
		{
			stopwatch.Stop();
			Debug.Log((object)$"{name} took {stopwatch.ElapsedMilliseconds} ms");
		}
	}

	public byte[] Src;

	public byte[] SrcHash;

	public byte[] SettingsHash;

	public SourceType Source;

	public GameObject VisualModel { get; private set; }

	public string Name { get; private set; }

	public VRM(GameObject visualModel, string name)
	{
		VisualModel = visualModel;
		Name = name;
	}

	~VRM()
	{
		if ((Object)(object)VisualModel != (Object)null)
		{
			Object.Destroy((Object)(object)VisualModel);
		}
	}

	public void RecalculateSrcBytesHash()
	{
		Task.Run(delegate
		{
			using MD5 mD = MD5.Create();
			byte[] srcHash = mD.ComputeHash(Src);
			lock (this)
			{
				SrcHash = srcHash;
			}
		});
	}

	public void RecalculateSettingsHash()
	{
		Task.Run(delegate
		{
			using MD5 mD = MD5.Create();
			byte[] bytes = Encoding.ASCII.GetBytes(Settings.GetSettings(Name).ToStringDiffOnly());
			lock (this)
			{
				SettingsHash = mD.ComputeHash(bytes);
			}
		});
	}

	public static GameObject ImportVisual(byte[] buf, string path, float scale)
	{
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Expected O, but got Unknown
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Expected O, but got Unknown
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		Debug.Log((object)("[ValheimVRM] loading vrm: " + buf.Length + " bytes"));
		try
		{
			GltfData val = new GlbBinaryParser(buf, path).Parse();
			RuntimeGltfInstance val2 = null;
			try
			{
				VRMImporterContext val3 = new VRMImporterContext(new VRMData(val), (IReadOnlyDictionary<SubAssetKey, Object>)null, (ITextureDeserializer)null, (IMaterialDescriptorGenerator)null, false);
				try
				{
					val2 = ImporterContextExtensions.Load((ImporterContext)(object)val3);
				}
				catch (TypeLoadException ex)
				{
					Debug.LogError((object)("Failed to load type: " + ex.TypeName));
					Debug.LogError((object)ex);
				}
			}
			catch (NotVrm0Exception)
			{
				Debug.Log((object)"[ValheimVRM] Not Vrm0, Trying VRM10");
				Vrm10Importer val4 = new Vrm10Importer(Vrm10Data.Parse(val), (IReadOnlyDictionary<SubAssetKey, Object>)null, (ITextureDeserializer)null, (IMaterialDescriptorGenerator)null, false);
				try
				{
					val2 = ImporterContextExtensions.Load((ImporterContext)(object)val4);
				}
				catch (TypeLoadException ex2)
				{
					Debug.LogError((object)("Failed to load type: " + ex2.TypeName));
					Debug.LogError((object)ex2);
				}
			}
			val2.ShowMeshes();
			val2.Root.transform.localScale = Vector3.one * scale;
			Debug.Log((object)"[ValheimVRM] VRM read successful");
			return val2.Root;
		}
		catch (Exception ex3)
		{
			Debug.LogError((object)ex3);
		}
		return null;
	}

	public static IEnumerator ImportVisualAsync(byte[] buf, string path, float scale, Action<GameObject> onCompleted)
	{
		Debug.Log((object)("[ValheimVRM Async] loading vrm: " + buf.Length + " bytes"));
		Task<GltfData> dataTask = Task.Run(() => new GlbBinaryParser(buf, path).Parse());
		while (!dataTask.IsCompleted)
		{
			yield return (object)new WaitUntil((Func<bool>)(() => dataTask.IsCompleted));
		}
		Task<RuntimeGltfInstance> loader = null;
		bool maybeVrm10 = false;
		Task<VRMData> vrm0Task = Task.Run((Func<VRMData>)(() => new VRMData(dataTask.Result)));
		while (!vrm0Task.IsCompleted)
		{
			yield return (object)new WaitUntil((Func<bool>)(() => vrm0Task.IsCompleted));
		}
		if (vrm0Task.IsFaulted)
		{
			if (vrm0Task.Exception.InnerException is NotVrm0Exception)
			{
				maybeVrm10 = true;
			}
		}
		else
		{
			VRMImporterContext val = new VRMImporterContext(vrm0Task.Result, (IReadOnlyDictionary<SubAssetKey, Object>)null, (ITextureDeserializer)(object)new TextureDeserializerAsync(), (IMaterialDescriptorGenerator)null, false);
			loader = ((ImporterContext)val).LoadAsync((IAwaitCaller)new RuntimeOnlyAwaitCaller(0.001f), (Func<string, IDisposable>)null);
		}
		if (maybeVrm10)
		{
			Debug.Log((object)"[ValheimVRM] Not Vrm0, Trying VRM10");
			Task<Vrm10Data> vrmTask = Task.Run(() => Vrm10Data.Parse(dataTask.Result));
			while (!vrmTask.IsCompleted)
			{
				yield return (object)new WaitUntil((Func<bool>)(() => vrmTask.IsCompleted));
			}
			Vrm10Importer val2 = new Vrm10Importer(vrmTask.Result, (IReadOnlyDictionary<SubAssetKey, Object>)null, (ITextureDeserializer)(object)new TextureDeserializerAsync(), (IMaterialDescriptorGenerator)null, false);
			loader = ((ImporterContext)val2).LoadAsync((IAwaitCaller)new RuntimeOnlyAwaitCaller(0.001f), (Func<string, IDisposable>)null);
		}
		if (loader == null)
		{
			Debug.LogError((object)"Loader was not initialized.");
			yield break;
		}
		while (!loader.IsCompleted)
		{
			yield return (object)new WaitUntil((Func<bool>)(() => loader.IsCompleted));
		}
		if (loader.IsFaulted)
		{
			Debug.LogError((object)("Error during VRM loading: " + loader.Exception.Flatten()));
		}
		RuntimeGltfInstance loaded = loader.Result;
		foreach (Renderer visibleRenderer in loaded.VisibleRenderers)
		{
			visibleRenderer.enabled = true;
			yield return null;
		}
		loaded.Root.transform.localScale = Vector3.one * scale;
		Debug.Log((object)"[ValheimVRM] VRM read successful");
		onCompleted(loaded.Root);
	}

	public static async Task<GameObject> ImportVisualAsync(byte[] buf, string path, float scale)
	{
		Debug.Log((object)("[ValheimVRM Async] loading vrm: " + buf.Length + " bytes"));
		VRMData val = new VRMData(new GlbBinaryParser(buf, path).Parse());
		VRMImporterContext loader = new VRMImporterContext(val, (IReadOnlyDictionary<SubAssetKey, Object>)null, (ITextureDeserializer)null, (IMaterialDescriptorGenerator)null, false);
		RuntimeGltfInstance val2;
		try
		{
			val2 = await ((ImporterContext)loader).LoadAsync((IAwaitCaller)new RuntimeOnlyAwaitCaller(0.001f), (Func<string, IDisposable>)null);
		}
		finally
		{
			((IDisposable)loader)?.Dispose();
		}
		try
		{
			val2.ShowMeshes();
			val2.Root.transform.localScale = Vector3.one * scale;
			Debug.Log((object)"[ValheimVRM] VRM read successful");
			return val2.Root;
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("Error during VRM loading: " + ex));
		}
		return null;
	}

	public IEnumerator SetToPlayer(Player player)
	{
		Animator animator = ((Component)player).GetComponentInChildren<Animator>();
		VrmController component = ((Component)player).GetComponent<VrmController>();
		Settings.VrmSettingsContainer settings = Settings.GetSettings(Name);
		player.m_maxInteractDistance *= settings.InteractionDistanceScale;
		GameObject vrmModel = Object.Instantiate<GameObject>(VisualModel);
		VrmManager.PlayerToVrmInstance[player] = vrmModel;
		((Object)vrmModel).name = "VRM_Visual";
		vrmModel.SetActive(true);
		component.visual = vrmModel;
		Transform val = ((Component)animator).transform.parent.Find("VRM_Visual");
		if ((Object)(object)val != (Object)null)
		{
			Object.Destroy((Object)(object)val);
		}
		vrmModel.transform.SetParent(((Component)animator).transform.parent, false);
		float playerHeight = settings.PlayerHeight;
		float playerRadius = settings.PlayerRadius;
		Rigidbody component2 = ((Component)player).GetComponent<Rigidbody>();
		CapsuleCollider component3 = ((Component)player).GetComponent<CapsuleCollider>();
		component3.height = playerHeight;
		component3.radius = playerRadius;
		component3.center = new Vector3(0f, playerHeight / 2f, 0f);
		component2.centerOfMass = component3.center;
		yield return null;
		SkinnedMeshRenderer[] componentsInChildren = ((Character)player).GetVisual().GetComponentsInChildren<SkinnedMeshRenderer>();
		foreach (SkinnedMeshRenderer obj in componentsInChildren)
		{
			((Renderer)obj).forceRenderingOff = true;
			obj.updateWhenOffscreen = true;
			yield return null;
		}
		Animator orgAnim = AccessTools.FieldRefAccess<Player, Animator>(player, "m_animator");
		orgAnim.keepAnimatorStateOnDisable = true;
		orgAnim.cullingMode = (AnimatorCullingMode)0;
		yield return null;
		vrmModel.transform.localPosition = ((Component)orgAnim).transform.localPosition;
		VRMAnimationSync component4 = vrmModel.GetComponent<VRMAnimationSync>();
		if ((Object)(object)component4 == (Object)null)
		{
			component4 = vrmModel.AddComponent<VRMAnimationSync>();
			component4.Setup(orgAnim, settings);
		}
		else
		{
			component4.Setup(orgAnim, settings);
		}
		yield return null;
		if (settings.FixCameraHeight)
		{
			Transform boneTransform = animator.GetBoneTransform((HumanBodyBones)21);
			if ((Object)(object)boneTransform == (Object)null)
			{
				boneTransform = animator.GetBoneTransform((HumanBodyBones)10);
			}
			if ((Object)(object)boneTransform == (Object)null)
			{
				boneTransform = animator.GetBoneTransform((HumanBodyBones)9);
			}
			if ((Object)(object)boneTransform != (Object)null)
			{
				VRMEyePositionSync component5 = ((Component)player).gameObject.GetComponent<VRMEyePositionSync>();
				if ((Object)(object)component5 == (Object)null)
				{
					component5 = ((Component)player).gameObject.AddComponent<VRMEyePositionSync>();
					component5.Setup(boneTransform);
				}
				else
				{
					component5.Setup(boneTransform);
				}
			}
		}
		yield return null;
		if (settings.UseMToonShader)
		{
			MToonColorSync component6 = vrmModel.GetComponent<MToonColorSync>();
			if ((Object)(object)component6 == (Object)null)
			{
				component6 = vrmModel.AddComponent<MToonColorSync>();
				component6.Setup(vrmModel);
			}
			else
			{
				component6.Setup(vrmModel);
			}
		}
		yield return null;
		VRMSpringBone[] componentsInChildren2 = vrmModel.GetComponentsInChildren<VRMSpringBone>();
		foreach (VRMSpringBone obj2 in componentsInChildren2)
		{
			obj2.m_stiffnessForce *= settings.SpringBoneStiffness;
			obj2.m_gravityPower *= settings.SpringBoneGravityPower;
			obj2.m_updateType = (SpringBoneUpdateType)1;
			obj2.m_center = null;
			yield return null;
		}
		((Component)player).GetComponent<VrmController>().ReloadSpringBones();
	}
}
[DefaultExecutionOrder(int.MaxValue)]
public class VRMAnimationSync : MonoBehaviour
{
	private Animator orgAnim;

	private Animator vrmAnim;

	private HumanPoseHandler orgPose;

	private HumanPoseHandler vrmPose;

	private HumanPose hp;

	private bool ragdoll;

	private Settings.VrmSettingsContainer settings;

	private Vector3? adjustPos;

	private int oldStateHash;

	private const int FirstTime = -161139084;

	private const int Usually = 229373857;

	private const int FirstRise = -1536343465;

	private const int RiseUp = -805461806;

	private const int StartToSitDown = 890925016;

	private const int SittingIdle = -1544306596;

	private const int StandingUpFromSit = -805461806;

	private const int SittingChair = -1829310159;

	private const int SittingThrone = 1271596;

	private const int SittingShip = -675369009;

	private const int StartSleeping = 337039637;

	private const int Sleeping = -1603096;

	private const int GetUpFromBed = -496559199;

	private const int Crouch = -2015693266;

	private const int HoldingMast = -2110678410;

	private const int HoldingDragon = -2076823180;

	private static List<int> adjustHipHashes = new List<int> { -1829310159, 1271596, -675369009, -1603096 };

	public void Setup(Animator orgAnim, Settings.VrmSettingsContainer settings, bool isRagdoll = false)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		ragdoll = isRagdoll;
		this.settings = settings;
		this.orgAnim = orgAnim;
		vrmAnim = ((Component)this).GetComponent<Animator>();
		vrmAnim.applyRootMotion = true;
		vrmAnim.updateMode = orgAnim.updateMode;
		vrmAnim.feetPivotActive = orgAnim.feetPivotActive;
		vrmAnim.layersAffectMassCenter = orgAnim.layersAffectMassCenter;
		vrmAnim.stabilizeFeet = orgAnim.stabilizeFeet;
		PoseHandlerCreate(orgAnim, vrmAnim);
	}

	private void PoseHandlerCreate(Animator org, Animator vrm)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Expected O, but got Unknown
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Expected O, but got Unknown
		OnDestroy();
		orgPose = new HumanPoseHandler(org.avatar, ((Component)org).transform);
		vrmPose = new HumanPoseHandler(vrm.avatar, ((Component)vrm).transform);
	}

	private void OnDestroy()
	{
		if (orgPose != null)
		{
			orgPose.Dispose();
		}
		if (vrmPose != null)
		{
			vrmPose.Dispose();
		}
	}

	private Vector3 StateHashToOffset(int stateHash, out float interpSpeed)
	{
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		interpSpeed = Time.deltaTime * 5f;
		switch (stateHash)
		{
		case -1544306596:
		case 890925016:
			return settings.SittingIdleOffset;
		case -1829310159:
			return settings.SittingOnChairOffset;
		case 1271596:
			return settings.SittingOnThroneOffset;
		case -675369009:
			return settings.SittingOnShipOffset;
		case -2110678410:
			return settings.HoldingMastOffset;
		case -2076823180:
			return settings.HoldingDragonOffset;
		case -1603096:
			return settings.SleepingOffset;
		default:
			interpSpeed = 1f;
			return Vector3.zero;
		}
	}

	private void Update()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		((Component)vrmAnim).transform.localPosition = Vector3.zero;
		if (!ragdoll)
		{
			for (int i = 0; i < 55; i++)
			{
				Transform boneTransform = orgAnim.GetBoneTransform((HumanBodyBones)i);
				Transform boneTransform2 = vrmAnim.GetBoneTransform((HumanBodyBones)i);
				if (i > 0 && (Object)(object)boneTransform != (Object)null && (Object)(object)boneTransform2 != (Object)null)
				{
					if (i == 5 || i == 6)
					{
						boneTransform.position = boneTransform2.position;
					}
					else
					{
						boneTransform.position = boneTransform2.position + Vector3.up * settings.ModelOffsetY;
					}
				}
			}
		}
		Transform transform = ((Component)vrmAnim).transform;
		transform.localPosition += Vector3.up * settings.ModelOffsetY;
	}

	private void LateUpdate()
	{
		//IL_001d: 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_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_015a: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_0205: Unknown result type (might be due to invalid IL or missing references)
		//IL_020a: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_019a: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_021e: 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)
		//IL_022e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_028d: Unknown result type (might be due to invalid IL or missing references)
		//IL_029d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
		float num = settings.PlayerHeight / 1.85f;
		((Component)vrmAnim).transform.localPosition = Vector3.zero;
		orgPose.GetHumanPose(ref hp);
		vrmPose.SetHumanPose(ref hp);
		AnimatorStateInfo currentAnimatorStateInfo = orgAnim.GetCurrentAnimatorStateInfo(0);
		int shortNameHash = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).shortNameHash;
		AnimatorStateInfo nextAnimatorStateInfo = orgAnim.GetNextAnimatorStateInfo(0);
		int shortNameHash2 = ((AnimatorStateInfo)(ref nextAnimatorStateInfo)).shortNameHash;
		Transform boneTransform = vrmAnim.GetBoneTransform((HumanBodyBones)0);
		Transform boneTransform2 = orgAnim.GetBoneTransform((HumanBodyBones)0);
		boneTransform.position = orgAnim.GetBoneTransform((HumanBodyBones)0).position;
		Vector3 val = Vector3.zero;
		if (!adjustHipHashes.Contains(shortNameHash))
		{
			Vector3 val2 = boneTransform2.position - boneTransform2.parent.position;
			val = val2 * num - val2;
		}
		float interpSpeed = Time.deltaTime * 5f;
		Vector3 val3 = StateHashToOffset(shortNameHash, out interpSpeed);
		if (val3 != Vector3.zero)
		{
			val += ((Component)boneTransform2).transform.rotation * val3;
		}
		Vector3 val4 = Vector3.zero;
		float num3;
		Vector3 val7;
		if (shortNameHash2 != 0)
		{
			if (!adjustHipHashes.Contains(shortNameHash2))
			{
				Vector3 val5 = boneTransform2.position - boneTransform2.parent.position;
				val4 = val5 * num - val5;
			}
			float interpSpeed2 = Time.deltaTime * 5f;
			Vector3 val6 = StateHashToOffset(shortNameHash2, out interpSpeed2);
			if (val6 != Vector3.zero)
			{
				val4 += ((Component)boneTransform2).transform.rotation * val6;
			}
			float num2 = Mathf.Clamp01(((AnimatorStateInfo)(ref nextAnimatorStateInfo)).normalizedTime * ((AnimatorStateInfo)(ref nextAnimatorStateInfo)).length / 0.5f);
			num3 = Mathf.Lerp(interpSpeed, interpSpeed2, num2);
			val7 = Vector3.Lerp(val, val4, num2);
		}
		else
		{
			num3 = interpSpeed;
			val7 = val;
		}
		adjustPos = (adjustPos.HasValue ? Vector3.Lerp(adjustPos.Value, val7, num3) : val);
		boneTransform.position += adjustPos.Value;
		if (!ragdoll)
		{
			for (int i = 0; i < 55; i++)
			{
				Transform boneTransform3 = orgAnim.GetBoneTransform((HumanBodyBones)i);
				Transform boneTransform4 = vrmAnim.GetBoneTransform((HumanBodyBones)i);
				if (i > 0 && (Object)(object)boneTransform3 != (Object)null && (Object)(object)boneTransform4 != (Object)null)
				{
					if (i == 5 || i == 6)
					{
						boneTransform3.position = boneTransform4.position;
					}
					else
					{
						boneTransform3.position = boneTransform4.position + Vector3.up * settings.ModelOffsetY;
					}
				}
			}
		}
		Transform transform = ((Component)vrmAnim).transform;
		transform.localPosition += Vector3.up * settings.ModelOffsetY;
		oldStateHash = shortNameHash;
	}
}
public class VrmController : MonoBehaviour
{
	private class LoadingProcess
	{
		public bool UseExistingData;

		public List<byte[]> Packets = new List<byte[]>();

		public bool PacketsDone;

		public bool UseExistingSettings;

		public string Settings;

		public bool SettingsDone;

		public bool IsLoaded()
		{
			if (UseExistingData || PacketsDone)
			{
				if (!UseExistingSettings)
				{
					return SettingsDone;
				}
				return true;
			}
			return false;
		}

		public byte[] GetVrmData()
		{
			int num = 0;
			foreach (byte[] packet in Packets)
			{
				num += packet.Length;
			}
			byte[] array = new byte[num];
			int num2 = 0;
			foreach (byte[] packet2 in Packets)
			{
				Array.Copy(packet2, 0, array, num2, packet2.Length);
				num2 += packet2.Length;
			}
			return array;
		}
	}

	private class SpringBoneState
	{
		public VRMSpringBone SpringBone;

		public Vector3 InitialGravityForce;
	}

	private class WindItem
	{
		public float Time;

		public Vector3 Dir;

		public float Rise;

		public float Sit;

		public float MaxFactor;

		public Vector3 CachedWindForce;
	}

	private const int MaxPacketSize = 512000;

	private static Dictionary<string, LoadingProcess> _activeLoadings = new Dictionary<string, LoadingProcess>();

	private static Material _playerSizeGizmoMaterial;

	private ZNetView view;

	private Player player;

	private string playerName;

	public GameObject visual;

	private CapsuleCollider playerCollider;

	private GameObject playerSizeGizmo;

	private SpringBoneState[] springBones = new SpringBoneState[0];

	private Vector2 windIntervalRange = new Vector2(0.7f, 1.9f);

	private float windDirRange = 0.2f;

	private Vector2 windRiseRange = new Vector2(0.4f, 0.6f);

	private Vector2 windSitRange = new Vector2(1.3f, 1.8f);

	private Vector2 windStrengthRange = new Vector2(0.03f, 0.12f);

	private WindItem[] windItems;

	private float windCoverPercentage;

	private float windCoverUpdateTimer;

	private Vector3[] windCoverRays;

	public static VrmController GetLocalController()
	{
		VrmController[] array = Object.FindObjectsOfType<VrmController>();
		foreach (VrmController vrmController in array)
		{
			if ((vrmController.view.GetZDO() != null && vrmController.view.IsOwner()) || vrmController.view.GetZDO() == null)
			{
				return vrmController;
			}
		}
		return null;
	}

	private string GetPeerName(long peerId)
	{
		ZNet instance = ZNet.instance;
		return ((instance == null) ? null : instance.GetPeer(peerId)?.m_playerName) ?? peerId.ToString();
	}

	public void ReloadSpringBones()
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		SpringBoneState[] array = springBones;
		foreach (SpringBoneState springBoneState in array)
		{
			if ((Object)(object)springBoneState.SpringBone != (Object)null)
			{
				springBoneState.SpringBone.m_gravityDir = ((Vector3)(ref springBoneState.InitialGravityForce)).normalized;
				springBoneState.SpringBone.m_gravityPower = ((Vector3)(ref springBoneState.InitialGravityForce)).magnitude;
			}
		}
		springBones = (from bone in ((Component)this).GetComponentsInChildren<VRMSpringBone>()
			select new SpringBoneState
			{
				SpringBone = bone,
				InitialGravityForce = bone.m_gravityDir * bone.m_gravityPower
			}).ToArray();
		windItems = new WindItem[(!Settings.globalSettings.AllowIndividualWinds) ? 1 : springBones.Length];
		for (int j = 0; j < windItems.Length; j++)
		{
			windItems[j] = new WindItem();
		}
		windCoverUpdateTimer = 0f;
	}

	public void ResetSpringBonesWind()
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		SpringBoneState[] array = springBones;
		foreach (SpringBoneState springBoneState in array)
		{
			if ((Object)(object)springBoneState.SpringBone != (Object)null)
			{
				springBoneState.SpringBone.m_gravityDir = ((Vector3)(ref springBoneState.InitialGravityForce)).normalized;
				springBoneState.SpringBone.m_gravityPower = ((Vector3)(ref springBoneState.InitialGravityForce)).magnitude;
			}
		}
	}

	private void Awake()
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		view = ((Component)this).GetComponent<ZNetView>();
		player = ((Component)this).GetComponent<Player>();
		if ((Object)(object)_playerSizeGizmoMaterial == (Object)null)
		{
			_playerSizeGizmoMaterial = new Material(Shader.Find("Standard"));
			_playerSizeGizmoMaterial.SetFloat("_Mode", 2f);
			_playerSizeGizmoMaterial.SetInt("_SrcBlend", 5);
			_playerSizeGizmoMaterial.SetInt("_DstBlend", 10);
			_playerSizeGizmoMaterial.SetInt("_ZWrite", 0);
			_playerSizeGizmoMaterial.DisableKeyword("_ALPHATEST_ON");
			_playerSizeGizmoMaterial.EnableKeyword("_ALPHABLEND_ON");
			_playerSizeGizmoMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			_playerSizeGizmoMaterial.SetFloat("_GlossMapScale", 0f);
			_playerSizeGizmoMaterial.renderQueue = 3000;
			_playerSizeGizmoMaterial.color = new Color(1f, 0f, 0f, 0.3f);
		}
		playerCollider = ((Component)this).GetComponent<CapsuleCollider>();
		if (Settings.globalSettings.DrawPlayerSizeGizmo)
		{
			ActivateSizeGizmo();
		}
		if ((Object)(object)Game.instance != (Object)null)
		{
			playerName = ((Component)this).GetComponent<Player>().GetPlayerName();
			if (playerName == "" || playerName == "...")
			{
				playerName = Game.instance.GetPlayerProfile().GetName();
			}
		}
		else
		{
			int field = FejdStartup.instance.GetField<FejdStartup, int>("m_profileIndex");
			List<PlayerProfile> field2 = FejdStartup.instance.GetField<FejdStartup, List<PlayerProfile>>("m_profiles");
			if (field >= 0 && field < field2.Count)
			{
				playerName = field2[field].GetName();
			}
		}
		if (view.GetZDO() != null)
		{
			view.Register("RPC_QueryAll", (Action<long>)RPC_QueryAll);
			view.Register<string, ZPackage, ZPackage>("RPC_SendHashes", (Action<long, string, ZPackage, ZPackage>)RPC_SendHashes);
			view.Register<string>("RPC_QueryData", (Action<long, string>)RPC_QueryData);
			view.Register<string, ZPackage>("RPC_SendDataPacket", (Action<long, string, ZPackage>)RPC_SendDataPacket);
			view.Register<string, int>("RPC_DataPacketCallback", (Action<long, string, int>)RPC_DataPacketCallback);
			view.Register<string>("RPC_QuerySettings", (Action<long, string>)RPC_QuerySettings);
			view.Register<string, string>("RPC_SendSettings", (Action<long, string, string>)RPC_SendSettings);
		}
	}

	private void Update()
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)playerCollider == (Object)null) && !((Object)(object)playerSizeGizmo == (Object)null))
		{
			Transform transform = playerSizeGizmo.transform;
			Bounds bounds = ((Collider)playerCollider).bounds;
			transform.position = ((Bounds)(ref bounds)).center;
			Transform transform2 = playerSizeGizmo.transform;
			bounds = ((Collider)playerCollider).bounds;
			float x = ((Bounds)(ref bounds)).size.x;
			bounds = ((Collider)playerCollider).bounds;
			float num = ((Bounds)(ref bounds)).size.y / 2f;
			bounds = ((Collider)playerCollider).bounds;
			transform2.localScale = new Vector3(x, num, ((Bounds)(ref bounds)).size.z);
		}
	}

	private void FixedUpdate()
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02af: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0321: Unknown result type (might be due to invalid IL or missing references)
		//IL_0326: Unknown result type (might be due to invalid IL or missing references)
		//IL_032b: Unknown result type (might be due to invalid IL or missing references)
		//IL_033d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		if (springBones.Length == 0 || Settings.globalSettings.ForceWindDisabled)
		{
			return;
		}
		EnvMan instance = EnvMan.instance;
		Vector3 val = ((instance != null) ? instance.GetWindDir() : Vector3.back);
		EnvMan instance2 = EnvMan.instance;
		float num = ((instance2 != null) ? instance2.GetWindIntensity() : 0.3f);
		windCoverUpdateTimer -= Time.deltaTime;
		if (windCoverUpdateTimer < 0f)
		{
			windCoverUpdateTimer = 1f;
			int mask = LayerMask.GetMask(new string[6] { "Default", "static_solid", "Default_small", "piece", "terrain", "vehicle" });
			windCoverPercentage = 0f;
			Vector3[] array = windCoverRays;
			RaycastHit val4 = default(RaycastHit);
			foreach (Vector3 val2 in array)
			{
				Vector3 val3 = Quaternion.LookRotation(-val) * val2;
				if (Physics.Raycast(((Character)player).GetCenterPoint() + val3 * 0.5f, val3, ref val4, 29.5f, mask))
				{
					windCoverPercentage += 1f;
				}
			}
			windCoverPercentage /= windCoverRays.Length;
		}
		WindItem[] array2 = windItems;
		foreach (WindItem windItem in array2)
		{
			windItem.Time -= Time.deltaTime;
			if (windItem.Time < 0f)
			{
				windItem.Time = Random.Range(windIntervalRange.x, windIntervalRange.y);
				Vector3 val5 = val + new Vector3(Random.Range(0f - windDirRange, windDirRange), Random.Range(0f - windDirRange, windDirRange), Random.Range(0f - windDirRange, windDirRange));
				windItem.Dir = ((Vector3)(ref val5)).normalized;
				windItem.Rise = Random.Range(windRiseRange.x, windRiseRange.y);
				windItem.Sit = Random.Range(windSitRange.x, windSitRange.y);
				windItem.MaxFactor = Random.Range(windStrengthRange.x, windStrengthRange.y);
			}
			float num2 = ((windItem.Time < windItem.Rise) ? (windItem.MaxFactor * windItem.Time / windItem.Rise) : (windItem.MaxFactor * (1f - (windItem.Time - windItem.Rise) / windItem.Sit)));
			windItem.CachedWindForce = windItem.Dir * (num2 * (num * Mathf.Lerp(1f, 0.1f, windCoverPercentage) * 3f));
		}
		for (int j = 0; j < springBones.Length; j++)
		{
			Vector3 val6 = springBones[j].InitialGravityForce + (Settings.globalSettings.AllowIndividualWinds ? windItems[j] : windItems[0]).CachedWindForce;
			springBones[j].SpringBone.m_gravityDir = ((Vector3)(ref val6)).normalized;
			springBones[j].SpringBone.m_gravityPower = ((Vector3)(ref val6)).magnitude;
		}
	}

	public void ActivateSizeGizmo()
	{
		if (!((Object)(object)playerSizeGizmo != (Object)null))
		{
			playerSizeGizmo = GameObject.CreatePrimitive((PrimitiveType)2);
			((Renderer)playerSizeGizmo.GetComponent<MeshRenderer>()).material = _playerSizeGizmoMaterial;
			Object.Destroy((Object)(object)playerSizeGizmo.GetComponent<Collider>());
		}
	}

	public void DeactivateSizeGizmo()
	{
		if (!((Object)(object)playerSizeGizmo == (Object)null))
		{
			Object.Destroy((Object)(object)playerSizeGizmo);
		}
	}

	public static void CleanupLoadings()
	{
		_activeLoadings.Clear();
	}

	private void SendDataPacket(long target, string vrmName, int packetIndex)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Expected O, but got Unknown
		VRM vRM = VrmManager.VrmDic[vrmName];
		int num = Mathf.CeilToInt((float)vRM.Src.Length / 512000f);
		ZPackage val = new ZPackage();
		if (packetIndex >= num)
		{
			val.Write(false);
			view.InvokeRPC(target, "RPC_SendDataPacket", new object[2] { vrmName, val });
			return;
		}
		int num2 = ((packetIndex < num - 1) ? 512000 : (vRM.Src.Length % num));
		byte[] array = new byte[num2];
		Array.Copy(vRM.Src, packetIndex * 512000, array, 0, num2);
		val.Write(true);
		val.Write(packetIndex);
		val.Write(num);
		val.Write(array);
		view.InvokeRPC(target, "RPC_SendDataPacket", new object[2] { vrmName, val });
		Debug.Log((object)$"[ValheimVRM] sent {vrmName} packet {packetIndex + 1} of {num} to {GetPeerName(target)}");
	}

	public void ShareVrm(bool delay = true)
	{
		if (view.GetZDO() != null && view.IsOwner())
		{
			if (delay)
			{
				((MonoBehaviour)this).StartCoroutine("ShareVrmDelayed");
			}
			else
			{
				DoShareVrm();
			}
		}
	}

	public IEnumerator ShareVrmDelay