using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("ValheimOptimizer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ValheimOptimizer")]
[assembly: AssemblyTitle("ValheimOptimizer")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ValheimOptimizer
{
	[BepInPlugin("com.yourname.valheimoptimizer", "Valheim Optimizer", "1.9.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ValheimOptimizer : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <DelayedZoneReflection>d__63 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ValheimOptimizer <>4__this;

			private float <t>5__1;

			private Type <zsType>5__2;

			private object <zsInst>5__3;

			private Type <pType>5__4;

			private Type <cType>5__5;

			private Type <zType>5__6;

			private Type <znsType>5__7;

			private object <znsInst>5__8;

			private MethodInfo <destroyM>5__9;

			private Exception <ex>5__10;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<zsType>5__2 = null;
				<zsInst>5__3 = null;
				<pType>5__4 = null;
				<cType>5__5 = null;
				<zType>5__6 = null;
				<znsType>5__7 = null;
				<znsInst>5__8 = null;
				<destroyM>5__9 = null;
				<ex>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ef: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<t>5__1 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<t>5__1 += 0.5f;
					<zsType>5__2 = null;
					<zsInst>5__3 = null;
					break;
				}
				if (<t>5__1 < 10f)
				{
					<zsType>5__2 = AccessTools.TypeByName("ZoneSystem");
					<zsInst>5__3 = <zsType>5__2?.GetField("instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
					if (<zsInst>5__3 != null)
					{
						try
						{
							<>4__this._spawnZoneDel = (Action<int, int>)Delegate.CreateDelegate(typeof(Action<int, int>), <zsInst>5__3, <zsType>5__2.GetMethod("SpawnZone", new Type[2]
							{
								typeof(int),
								typeof(int)
							}));
							<>4__this._zoneCellSize = (float)<zsType>5__2.GetField("m_cellSize", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(<zsInst>5__3);
							<pType>5__4 = AccessTools.TypeByName("Player");
							<>4__this._playerField = <pType>5__4.GetField("m_localPlayer", BindingFlags.Static | BindingFlags.NonPublic);
							<>4__this._transformProp = <pType>5__4.GetProperty("transform", BindingFlags.Instance | BindingFlags.Public);
							<>4__this._characterField = <pType>5__4.GetField("m_character", BindingFlags.Instance | BindingFlags.NonPublic);
							<cType>5__5 = AccessTools.TypeByName("Character");
							<>4__this._velocityField = <cType>5__5.GetField("m_velocity", BindingFlags.Instance | BindingFlags.NonPublic);
							<>4__this._getAllChars = (Func<IEnumerable>)Delegate.CreateDelegate(typeof(Func<IEnumerable>), <cType>5__5.GetMethod("GetAllCharacters", BindingFlags.Static | BindingFlags.Public));
							<>4__this._isAlive = (Func<object, bool>)Delegate.CreateDelegate(typeof(Func<object, bool>), <cType>5__5.GetMethod("IsAlive", BindingFlags.Instance | BindingFlags.Public));
							<>4__this._isBoss = (Func<object, bool>)Delegate.CreateDelegate(typeof(Func<object, bool>), <cType>5__5.GetMethod("IsBoss", BindingFlags.Instance | BindingFlags.Public));
							<>4__this._isPlayer = (Func<object, bool>)Delegate.CreateDelegate(typeof(Func<object, bool>), <cType>5__5.GetMethod("IsPlayer", BindingFlags.Instance | BindingFlags.Public));
							<zType>5__6 = AccessTools.TypeByName("ZNet");
							<>4__this._getZNetInstance = (Func<object>)Delegate.CreateDelegate(typeof(Func<object>), <zType>5__6.GetProperty("instance", BindingFlags.Static | BindingFlags.Public).GetGetMethod());
							<>4__this._isServer = (Func<object, bool>)Delegate.CreateDelegate(typeof(Func<object, bool>), <zType>5__6.GetProperty("IsServer", BindingFlags.Instance | BindingFlags.Public).GetGetMethod());
							<znsType>5__7 = AccessTools.TypeByName("ZNetScene");
							<>4__this._getZNetSceneInstance = (Func<object>)Delegate.CreateDelegate(typeof(Func<object>), <znsType>5__7.GetProperty("instance", BindingFlags.Static | BindingFlags.Public).GetGetMethod());
							<znsInst>5__8 = <>4__this._getZNetSceneInstance();
							<destroyM>5__9 = <znsType>5__7.GetMethod("Destroy", new Type[1] { typeof(GameObject) });
							<>4__this._znetSceneDestroy = (Action<GameObject>)Delegate.CreateDelegate(typeof(Action<GameObject>), <znsInst>5__8, <destroyM>5__9);
							<>4__this._zoneReflectionDone = true;
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[VO] Reflection complete");
							return false;
						}
						catch (Exception ex)
						{
							<ex>5__10 = ex;
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)$"[VO] Reflection error: {<ex>5__10}");
							return false;
						}
					}
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)"[VO] Zone reflection timed out; prefetch disabled");
				return false;
			}

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

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

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

			private object <>2__current;

			public ValheimOptimizer <>4__this;

			private float <lastGC>5__1;

			private float <lastLOD>5__2;

			private bool <jitDone>5__3;

			private float <now>5__4;

			private float <ft>5__5;

			private int <maxBatch>5__6;

			private int <minBatch>5__7;

			private int <batch>5__8;

			private int <toSpawn>5__9;

			private object <netInst>5__10;

			private float <bias>5__11;

			private float <target>5__12;

			private string[] <>s__13;

			private int <>s__14;

			private string <sig>5__15;

			private MethodInfo <mi>5__16;

			private Queue<Vector2Int> <>s__17;

			private bool <>s__18;

			private int <i>5__19;

			private Vector2Int <cell>5__20;

			private object <plObj>5__21;

			private Vector3 <plPos>5__22;

			private int <removed>5__23;

			private int <maxKill>5__24;

			private int <perTick>5__25;

			private IEnumerator <>s__26;

			private object <chr>5__27;

			private Vector3 <cpos>5__28;

			private object <plObj>5__29;

			private Vector3 <plPos>5__30;

			private IEnumerator <>s__31;

			private object <chr>5__32;

			private Component <comp>5__33;

			private float <dist>5__34;

			private bool <show>5__35;

			private Renderer[] <>s__36;

			private int <>s__37;

			private Renderer <rend>5__38;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<netInst>5__10 = null;
				<>s__13 = null;
				<sig>5__15 = null;
				<mi>5__16 = null;
				<>s__17 = null;
				<plObj>5__21 = null;
				<>s__26 = null;
				<chr>5__27 = null;
				<plObj>5__29 = null;
				<>s__31 = null;
				<chr>5__32 = null;
				<comp>5__33 = null;
				<>s__36 = null;
				<rend>5__38 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_047a: Unknown result type (might be due to invalid IL or missing references)
				//IL_047f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0555: Unknown result type (might be due to invalid IL or missing references)
				//IL_055a: Unknown result type (might be due to invalid IL or missing references)
				//IL_055f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0797: Unknown result type (might be due to invalid IL or missing references)
				//IL_079c: Unknown result type (might be due to invalid IL or missing references)
				//IL_07a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0667: Unknown result type (might be due to invalid IL or missing references)
				//IL_066c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0671: Unknown result type (might be due to invalid IL or missing references)
				//IL_0677: Unknown result type (might be due to invalid IL or missing references)
				//IL_067d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0857: Unknown result type (might be due to invalid IL or missing references)
				//IL_0867: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<lastGC>5__1 = Time.time;
					<lastLOD>5__2 = Time.time;
					<jitDone>5__3 = false;
					<>4__this._avgFT = Time.unscaledDeltaTime;
					goto IL_0071;
				case 1:
					<>1__state = -1;
					goto IL_0071;
				case 2:
					{
						<>1__state = -1;
						<now>5__4 = Time.time;
						if (<now>5__4 - <lastGC>5__1 >= <>4__this._cleanupInterval.Value && Time.unscaledDeltaTime < <>4__this._maxFrameTime.Value)
						{
							GC.Collect();
							Resources.UnloadUnusedAssets();
							<lastGC>5__1 = <now>5__4;
						}
						<ft>5__5 = Time.unscaledDeltaTime;
						<>4__this._avgFT = <>4__this._lodAdjustStep.Value * <ft>5__5 + (1f - <>4__this._lodAdjustStep.Value) * <>4__this._avgFT;
						if (<now>5__4 - <lastLOD>5__2 >= <>4__this._lodInterval.Value)
						{
							<bias>5__11 = QualitySettings.lodBias;
							<target>5__12 = ((<>4__this._avgFT > <>4__this._lodUpperThresh.Value) ? <>4__this._lodBiasMin.Value : ((<>4__this._avgFT < <>4__this._lodLowerThresh.Value) ? <>4__this._lodBiasMax.Value : <bias>5__11));
							QualitySettings.lodBias = Mathf.MoveTowards(<bias>5__11, <target>5__12, <>4__this._lodAdjustStep.Value * <ft>5__5);
							if (<>4__this._avgFT > <>4__this._lodUpperThresh.Value)
							{
								QualitySettings.masterTextureLimit = Math.Min(<>4__this._texLimitMax.Value, QualitySettings.masterTextureLimit + 1);
							}
							else if (<>4__this._avgFT < <>4__this._lodLowerThresh.Value)
							{
								QualitySettings.masterTextureLimit = Math.Max(<>4__this._texLimitMin.Value, QualitySettings.masterTextureLimit - 1);
							}
							<lastLOD>5__2 = <now>5__4;
						}
						if (!<jitDone>5__3)
						{
							<>s__13 = new string[4] { "BaseAI:FixedUpdate", "ZoneSystem:SpawnZone", "Projectile:OnHit", "Projectile:LateUpdate" };
							for (<>s__14 = 0; <>s__14 < <>s__13.Length; <>s__14++)
							{
								<sig>5__15 = <>s__13[<>s__14];
								<mi>5__16 = AccessTools.Method(<sig>5__15, (Type[])null, (Type[])null);
								if (<mi>5__16 != null)
								{
									RuntimeHelpers.PrepareMethod(<mi>5__16.MethodHandle);
								}
								<mi>5__16 = null;
								<sig>5__15 = null;
							}
							<>s__13 = null;
							<jitDone>5__3 = true;
						}
						<maxBatch>5__6 = <>4__this._zoneBatchSize.Value;
						<minBatch>5__7 = <>4__this._minZoneBatchSize.Value;
						<batch>5__8 = ((<>4__this._avgFT > <>4__this._lodUpperThresh.Value) ? <minBatch>5__7 : <maxBatch>5__6);
						<>s__17 = <>4__this._zoneQ;
						<>s__18 = false;
						try
						{
							Monitor.Enter(<>s__17, ref <>s__18);
							<toSpawn>5__9 = Math.Min(<>4__this._zoneQ.Count, <batch>5__8);
						}
						finally
						{
							if (<>s__18)
							{
								Monitor.Exit(<>s__17);
							}
						}
						<>s__17 = null;
						<i>5__19 = 0;
						while (<i>5__19 < <toSpawn>5__9)
						{
							if (<>4__this._spawnZoneDel != null)
							{
								<cell>5__20 = <>4__this._zoneQ.Dequeue();
								<>4__this._spawnZoneDel(((Vector2Int)(ref <cell>5__20)).x, ((Vector2Int)(ref <cell>5__20)).y);
							}
							<i>5__19++;
						}
						<netInst>5__10 = <>4__this._getZNetInstance();
						if (<netInst>5__10 != null && <>4__this._isServer(<netInst>5__10))
						{
							<plObj>5__21 = <>4__this._playerField.GetValue(null);
							if (<plObj>5__21 != null)
							{
								<plPos>5__22 = ((Transform)<>4__this._transformProp.GetValue(<plObj>5__21)).position;
								<removed>5__23 = 0;
								<maxKill>5__24 = <>4__this._mobDespawnsPerTick.Value;
								<perTick>5__25 = ((<>4__this._avgFT > <>4__this._lodUpperThresh.Value) ? 1 : <maxKill>5__24);
								<>s__26 = <>4__this._getAllChars().GetEnumerator();
								try
								{
									while (<>s__26.MoveNext())
									{
										<chr>5__27 = <>s__26.Current;
										if (<removed>5__23 >= <perTick>5__25)
										{
											break;
										}
										if (!<>4__this._isAlive(<chr>5__27) || <>4__this._isBoss(<chr>5__27) || <>4__this._isPlayer(<chr>5__27))
										{
											continue;
										}
										<cpos>5__28 = ((Transform)<>4__this._transformProp.GetValue(<chr>5__27)).position;
										if (!(Vector3.Distance(<plPos>5__22, <cpos>5__28) <= <>4__this._mobDespawnDistance.Value))
										{
											Action<GameObject> znetSceneDestroy = <>4__this._znetSceneDestroy;
											if (znetSceneDestroy != null)
											{
												object obj = <chr>5__27;
												object obj2 = ((obj is Component) ? obj : null);
												znetSceneDestroy((obj2 != null) ? ((Component)obj2).gameObject : null);
											}
											<removed>5__23++;
											<chr>5__27 = null;
										}
									}
								}
								finally
								{
									if (<>s__26 is IDisposable disposable)
									{
										disposable.Dispose();
									}
								}
								<>s__26 = null;
							}
							<plObj>5__21 = null;
						}
						if (<netInst>5__10 != null && !<>4__this._isServer(<netInst>5__10))
						{
							<plObj>5__29 = <>4__this._playerField.GetValue(null);
							if (<plObj>5__29 != null)
							{
								<plPos>5__30 = ((Transform)<>4__this._transformProp.GetValue(<plObj>5__29)).position;
								<>s__31 = <>4__this._getAllChars().GetEnumerator();
								try
								{
									while (<>s__31.MoveNext())
									{
										<chr>5__32 = <>s__31.Current;
										if (!<>4__this._isAlive(<chr>5__32) || <>4__this._isBoss(<chr>5__32) || <>4__this._isPlayer(<chr>5__32))
										{
											continue;
										}
										ref Component reference = ref <comp>5__33;
										object obj3 = <chr>5__32;
										reference = (Component)((obj3 is Component) ? obj3 : null);
										if (!((Object)(object)<comp>5__33 == (Object)null))
										{
											<dist>5__34 = Vector3.Distance(<plPos>5__30, <comp>5__33.transform.position);
											<show>5__35 = <dist>5__34 <= <>4__this._clientMobHideDistance.Value;
											<>s__36 = <comp>5__33.GetComponentsInChildren<Renderer>(true);
											for (<>s__37 = 0; <>s__37 < <>s__36.Length; <>s__37++)
											{
												<rend>5__38 = <>s__36[<>s__37];
												<rend>5__38.enabled = <show>5__35;
												<rend>5__38 = null;
											}
											<>s__36 = null;
											<comp>5__33 = null;
											<chr>5__32 = null;
										}
									}
								}
								finally
								{
									if (<>s__31 is IDisposable disposable2)
									{
										disposable2.Dispose();
									}
								}
								<>s__31 = null;
							}
							<plObj>5__29 = null;
						}
						<netInst>5__10 = null;
						break;
					}
					IL_0071:
					if (!<>4__this._zoneReflectionDone)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					break;
				}
				<>2__current = null;
				<>1__state = 2;
				return true;
			}

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

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

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

			private object <>2__current;

			public ValheimOptimizer <>4__this;

			private bool <spawned>5__1;

			private string[] <>s__2;

			private int <>s__3;

			private string <name>5__4;

			private Shader <s>5__5;

			private Material <m>5__6;

			private Dictionary<string, GameObject>.Enumerator <>s__7;

			private KeyValuePair<string, GameObject> <kv>5__8;

			private Type <zsType>5__9;

			private object <inst>5__10;

			private MethodInfo <mSpawn>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__2 = null;
				<name>5__4 = null;
				<s>5__5 = null;
				<m>5__6 = null;
				<>s__7 = default(Dictionary<string, GameObject>.Enumerator);
				<kv>5__8 = default(KeyValuePair<string, GameObject>);
				<zsType>5__9 = null;
				<inst>5__10 = null;
				<mSpawn>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>s__2 = new string[2] { "Standard", "Unlit/Texture" };
						<>s__3 = 0;
						goto IL_0183;
					case 1:
						<>1__state = -1;
						<m>5__6 = null;
						goto IL_0167;
					case 2:
						<>1__state = -3;
						<kv>5__8.Value.SetActive(false);
						<kv>5__8 = default(KeyValuePair<string, GameObject>);
						goto IL_021e;
					case 3:
						<>1__state = -1;
						goto IL_034f;
					case 4:
						{
							<>1__state = -1;
							return false;
						}
						IL_0183:
						if (<>s__3 < <>s__2.Length)
						{
							<name>5__4 = <>s__2[<>s__3];
							<s>5__5 = Shader.Find(<name>5__4);
							if (<s>5__5 != null)
							{
								<m>5__6 = new Material(<s>5__5);
								GL.PushMatrix();
								GL.LoadOrtho();
								<m>5__6.SetPass(0);
								GL.Begin(7);
								GL.Vertex3(0f, 0f, 0f);
								GL.Vertex3(1f, 0f, 0f);
								GL.Vertex3(1f, 1f, 0f);
								GL.Vertex3(0f, 1f, 0f);
								GL.End();
								GL.PopMatrix();
								Object.Destroy((Object)(object)<m>5__6);
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
							goto IL_0167;
						}
						<>s__2 = null;
						<>s__7 = <>4__this._prefabPool.GetEnumerator();
						<>1__state = -3;
						goto IL_021e;
						IL_021e:
						if (<>s__7.MoveNext())
						{
							<kv>5__8 = <>s__7.Current;
							<kv>5__8.Value.SetActive(true);
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>s__7 = default(Dictionary<string, GameObject>.Enumerator);
						<spawned>5__1 = false;
						try
						{
							<zsType>5__9 = AccessTools.TypeByName("ZoneSystem");
							<inst>5__10 = <zsType>5__9?.GetField("instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
							<mSpawn>5__11 = <zsType>5__9?.GetMethod("SpawnZone", new Type[2]
							{
								typeof(int),
								typeof(int)
							});
							if (<inst>5__10 != null && <mSpawn>5__11 != null)
							{
								<mSpawn>5__11.Invoke(<inst>5__10, new object[2] { 0, 0 });
								<spawned>5__1 = true;
							}
							<zsType>5__9 = null;
							<inst>5__10 = null;
							<mSpawn>5__11 = null;
						}
						catch
						{
						}
						if (<spawned>5__1)
						{
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
						goto IL_034f;
						IL_034f:
						GC.Collect();
						<>2__current = Resources.UnloadUnusedAssets();
						<>1__state = 4;
						return true;
						IL_0167:
						<s>5__5 = null;
						<name>5__4 = null;
						<>s__3++;
						goto IL_0183;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__7).Dispose();
			}

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

		private ConfigEntry<float> _cleanupInterval;

		private ConfigEntry<float> _maxFrameTime;

		private ConfigEntry<float> _lodBiasMin;

		private ConfigEntry<float> _lodBiasMax;

		private ConfigEntry<float> _lodAdjustStep;

		private ConfigEntry<float> _lodUpperThresh;

		private ConfigEntry<float> _lodLowerThresh;

		private ConfigEntry<float> _lodInterval;

		private ConfigEntry<int> _lodSamples;

		private ConfigEntry<int> _texLimitMin;

		private ConfigEntry<int> _texLimitMax;

		private ConfigEntry<int> _texAdjustStep;

		private ConfigEntry<float> _texInterval;

		private ConfigEntry<float> _prefetchInterval;

		private ConfigEntry<float> _prefetchSpeed;

		private ConfigEntry<float> _prefetchDistance;

		private ConfigEntry<int> _zoneBatchSize;

		private ConfigEntry<int> _minZoneBatchSize;

		private ConfigEntry<bool> _enableVSync;

		private ConfigEntry<int> _targetFrameRate;

		private ConfigEntry<float> _mobDespawnDistance;

		private ConfigEntry<int> _mobDespawnsPerTick;

		private ConfigEntry<float> _clientMobHideDistance;

		private FileSystemWatcher _configWatcher;

		private DateTime _lastReloadTime;

		private const long RELOAD_DELAY = 10000000L;

		private const string CONFIG_NAME = "com.yourname.valheimoptimizer.cfg";

		private static readonly string[] HeavyPrefabs = new string[5] { "vfx_fireplace", "npc_troll", "piece_workbench", "Arrow_explosive", "Arrow_explosion" };

		private readonly Dictionary<string, GameObject> _prefabPool = new Dictionary<string, GameObject>();

		private Action<int, int> _spawnZoneDel;

		private float _zoneCellSize;

		private FieldInfo _playerField;

		private PropertyInfo _transformProp;

		private FieldInfo _characterField;

		private FieldInfo _velocityField;

		private bool _zoneReflectionDone;

		private Func<IEnumerable> _getAllChars;

		private Func<object, bool> _isAlive;

		private Func<object, bool> _isBoss;

		private Func<object, bool> _isPlayer;

		private Func<object> _getZNetInstance;

		private Func<object, bool> _isServer;

		private Func<object> _getZNetSceneInstance;

		private Action<GameObject> _znetSceneDestroy;

		private Vector3 _latestPos;

		private Vector3 _latestVel;

		private readonly object _movLock = new object();

		private readonly Queue<Vector2Int> _zoneQ = new Queue<Vector2Int>();

		private Thread _zoneThread;

		private bool _zoneThreadRunning;

		private Harmony _harmony;

		private float _avgFT;

		private WaitForSeconds _wsMaster;

		public static ValheimOptimizer Instance { get; private set; }

		private void Awake()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Expected O, but got Unknown
			Instance = this;
			_harmony = new Harmony("com.yourname.valheimoptimizer");
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			_cleanupInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Performance", "MemoryCleanupInterval", 60f, "Secs between GC sweeps");
			_maxFrameTime = ((BaseUnityPlugin)this).Config.Bind<float>("Performance", "MaxFrameTime", 0.033f, "Skip GC if frame > this");
			_enableVSync = ((BaseUnityPlugin)this).Config.Bind<bool>("Performance", "EnableVSync", true, "Enable V‑Sync");
			_targetFrameRate = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "TargetFrameRate", 60, "Hard FPS cap (0 = uncapped)");
			_mobDespawnDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Performance", "MobDespawnDistance", 100f, "Distance to drip‑despawn mobs");
			_mobDespawnsPerTick = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "MobDespawnsPerTick", 2, "Max mobs removed per tick");
			_clientMobHideDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Performance", "ClientMobHideDistance", 150f, "Hide mobs beyond this distance on clients");
			_lodBiasMin = ((BaseUnityPlugin)this).Config.Bind<float>("Graphics", "LODBiasMin", 0.5f, "Min LOD bias");
			_lodBiasMax = ((BaseUnityPlugin)this).Config.Bind<float>("Graphics", "LODBiasMax", 2f, "Max LOD bias");
			_lodAdjustStep = ((BaseUnityPlugin)this).Config.Bind<float>("Graphics", "LODBiasStep", 0.1f, "Adjust/sec");
			_lodUpperThresh = ((BaseUnityPlugin)this).Config.Bind<float>("Graphics", "LODUpperFrameThreshold", 0.04f, "Above → drop");
			_lodLowerThresh = ((BaseUnityPlugin)this).Config.Bind<float>("Graphics", "LODLowerFrameThreshold", 0.03f, "Below → raise");
			_lodSamples = ((BaseUnityPlugin)this).Config.Bind<int>("Graphics", "LODNumSamples", 10, "Frames/window");
			_lodInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Graphics", "LODUpdateInterval", 1f, "Secs between adj");
			_texLimitMin = ((BaseUnityPlugin)this).Config.Bind<int>("Graphics", "TextureLimitMin", 0, "Best (0=full)");
			_texLimitMax = ((BaseUnityPlugin)this).Config.Bind<int>("Graphics", "TextureLimitMax", 2, "Worst (2=¼)");
			_texAdjustStep = ((BaseUnityPlugin)this).Config.Bind<int>("Graphics", "TextureLimitStep", 1, "Step size");
			_texInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Graphics", "TextureChangeInterval", 30f, "Secs between changes");
			_prefetchInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Travel", "ZonePrefetchInterval", 0.1f, "Secs per check");
			_prefetchSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Travel", "ZonePrefetchSpeed", 10f, "Speed to prefetch");
			_prefetchDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Travel", "ZonePrefetchDistance", 50f, "Meters ahead");
			_zoneBatchSize = ((BaseUnityPlugin)this).Config.Bind<int>("Travel", "ZoneBatchSize", 8, "Zones/tick (max)");
			_minZoneBatchSize = ((BaseUnityPlugin)this).Config.Bind<int>("Travel", "MinZoneBatchSize", 1, "Zones/tick under load");
			((BaseUnityPlugin)this).Config.Save();
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
			SetupWatcher();
			QualitySettings.vSyncCount = (_enableVSync.Value ? 1 : 0);
			Application.targetFrameRate = ((_targetFrameRate.Value > 0) ? _targetFrameRate.Value : (-1));
			_wsMaster = new WaitForSeconds(0.2f);
			CachePrefabPool();
			((MonoBehaviour)this).StartCoroutine(DelayedZoneReflection());
			_zoneThreadRunning = true;
			_zoneThread = new Thread(ZonePrefetchLoop)
			{
				IsBackground = true
			};
			_zoneThread.Start();
			((MonoBehaviour)this).StartCoroutine(PreloadRoutine());
			((MonoBehaviour)this).StartCoroutine(MasterLoop());
			_harmony.PatchAll();
		}

		private void OnDestroy()
		{
			_configWatcher?.Dispose();
			_zoneThreadRunning = false;
			_zoneThread?.Join(500);
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, "com.yourname.valheimoptimizer.cfg")
			{
				NotifyFilter = (NotifyFilters.LastWrite | NotifyFilters.CreationTime)
			};
			fileSystemWatcher.Changed += OnConfigChanged;
			fileSystemWatcher.Created += OnConfigChanged;
			fileSystemWatcher.EnableRaisingEvents = true;
			_configWatcher = fileSystemWatcher;
		}

		private void OnConfigChanged(object s, FileSystemEventArgs e)
		{
			if (DateTime.Now.Ticks - _lastReloadTime.Ticks >= 10000000)
			{
				try
				{
					((BaseUnityPlugin)this).Logger.LogDebug((object)"[VO] Reloading config");
					((BaseUnityPlugin)this).Config.Reload();
				}
				catch (Exception arg)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)$"[VO] Config reload failed: {arg}");
				}
				_lastReloadTime = DateTime.Now;
			}
		}

		private void Update()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (_zoneReflectionDone)
			{
				object obj = _playerField?.GetValue(null);
				if (obj != null)
				{
					object value = _characterField.GetValue(obj);
					_latestVel = (Vector3)_velocityField.GetValue(value);
					_latestPos = ((Transform)_transformProp.GetValue(obj)).position;
				}
			}
		}

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

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

		private void ZonePrefetchLoop()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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)
			try
			{
				while (_zoneThreadRunning)
				{
					Vector3 latestPos;
					Vector3 latestVel;
					lock (_movLock)
					{
						latestPos = _latestPos;
						latestVel = _latestVel;
					}
					if (((Vector3)(ref latestVel)).magnitude >= _prefetchSpeed.Value)
					{
						Vector3 val = latestPos + ((Vector3)(ref latestVel)).normalized * _prefetchDistance.Value;
						int num = Mathf.FloorToInt(val.x / _zoneCellSize);
						int num2 = Mathf.FloorToInt(val.z / _zoneCellSize);
						lock (_zoneQ)
						{
							for (int i = -1; i <= 1; i++)
							{
								for (int j = -1; j <= 1; j++)
								{
									_zoneQ.Enqueue(new Vector2Int(num + i, num2 + j));
								}
							}
						}
					}
					Thread.Sleep((int)(_prefetchInterval.Value * 1000f));
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"[VO] Zone thread error: {arg}");
			}
		}

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

		private void CachePrefabPool()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			string[] heavyPrefabs = HeavyPrefabs;
			foreach (string text in heavyPrefabs)
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab(text);
				if (!((Object)(object)prefab == (Object)null))
				{
					GameObject val = Object.Instantiate<GameObject>(prefab);
					((Object)val).name = "Pool_" + text;
					val.SetActive(false);
					Object.DontDestroyOnLoad((Object)(object)val);
					_prefabPool[text] = val;
					Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
					LODGroup val2 = val.AddComponent<LODGroup>();
					val2.SetLODs((LOD[])(object)new LOD[2]
					{
						new LOD(0.5f, componentsInChildren),
						new LOD(0f, (Renderer[])(object)new Renderer[0])
					});
					val2.RecalculateBounds();
				}
			}
		}
	}
}
namespace ValheimOptimizer.Patches
{
	public static class ArrowReflectionPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("Projectile:LateUpdate")]
		public static void LateUpdatePrefix(object __instance)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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)
			//IL_009b: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			Component val = (Component)((__instance is Component) ? __instance : null);
			if (!((Object)(object)val == (Object)null) && ((Object)val.gameObject).name.Contains("Arrow"))
			{
				Type type = __instance.GetType();
				FieldInfo field = type.GetField("m_velocity", BindingFlags.Instance | BindingFlags.NonPublic);
				Vector3 val2 = (Vector3)field.GetValue(__instance);
				Vector3 position = val.transform.position;
				Vector3 val3 = position - val2 * Time.deltaTime;
				Vector3 val4 = position - val3;
				RaycastHit val5 = default(RaycastHit);
				if (!(((Vector3)(ref val4)).sqrMagnitude < 1E-06f) && Physics.Raycast(val3, val4, ref val5, ((Vector3)(ref val4)).magnitude, LayerMask.GetMask(new string[2] { "Default", "character" })))
				{
					MethodInfo method = type.GetMethod("OnHit", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					method.Invoke(__instance, new object[3]
					{
						((RaycastHit)(ref val5)).point,
						((RaycastHit)(ref val5)).normal,
						((RaycastHit)(ref val5)).collider
					});
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Projectile:Awake")]
		public static void AwakePostfix(object __instance)
		{
			Component val = (Component)((__instance is Component) ? __instance : null);
			CapsuleCollider val2 = default(CapsuleCollider);
			if (!((Object)(object)val == (Object)null) && ((Object)val.gameObject).name.Contains("Arrow") && val.TryGetComponent<CapsuleCollider>(ref val2))
			{
				CapsuleCollider obj = val2;
				obj.radius *= 1.2f;
				CapsuleCollider obj2 = val2;
				obj2.height *= 1.1f;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Projectile:OnHit")]
		public static void OnHitPostfix(object __instance, object character, object hitData)
		{
			Type type = __instance.GetType();
			FieldInfo field = type.GetField("m_nview", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			object value = field.GetValue(__instance);
			MethodInfo method = value.GetType().GetMethod("InvokeRPC", new Type[2]
			{
				typeof(string),
				typeof(object[])
			});
			method.Invoke(value, new object[5]
			{
				"Hit",
				character.GetType().GetMethod("GetZDOID").Invoke(character, null),
				hitData.GetType().GetField("m_damage", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(hitData),
				hitData.GetType().GetField("m_point", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(hitData),
				hitData.GetType().GetField("m_dir", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(hitData)
			});
			(AccessTools.TypeByName("EpicLoot.Magic.ExplosionHandler")?.GetMethod("TryExplode", BindingFlags.Static | BindingFlags.Public))?.Invoke(null, new object[3] { __instance, character, hitData });
		}
	}
}