using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Hitcontinue")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Hitcontinue")]
[assembly: AssemblyTitle("Hitcontinue")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Hitcontinue
{
	[BepInPlugin("com.clippton.hitcontinue", "Hitcontinue", "1.0.0")]
	public sealed class HitcontinuePlugin : BaseUnityPlugin
	{
		private struct RigidbodyState
		{
			private readonly Rigidbody rb;

			private readonly bool isKinematic;

			private readonly Vector3 velocity;

			private readonly Vector3 angularVelocity;

			public RigidbodyState(Rigidbody rb)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				this.rb = rb;
				isKinematic = rb.isKinematic;
				velocity = rb.velocity;
				angularVelocity = rb.angularVelocity;
			}

			public void Restore()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)rb == (Object)null))
				{
					rb.isKinematic = isKinematic;
					rb.velocity = velocity;
					rb.angularVelocity = angularVelocity;
				}
			}
		}

		private struct AnimatorState
		{
			private readonly Animator animator;

			private readonly float speed;

			public AnimatorState(Animator animator)
			{
				this.animator = animator;
				speed = animator.speed;
			}

			public void Restore()
			{
				if ((Object)(object)animator != (Object)null)
				{
					animator.speed = speed;
				}
			}
		}

		private struct AgentState
		{
			private readonly NavMeshAgent agent;

			private readonly bool isStopped;

			private readonly Vector3 velocity;

			public AgentState(NavMeshAgent agent)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				this.agent = agent;
				isStopped = agent.isStopped;
				velocity = agent.velocity;
			}

			public void Restore()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)agent == (Object)null) && agent.isOnNavMesh)
				{
					agent.isStopped = isStopped;
					agent.velocity = velocity;
				}
			}
		}

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

			private object <>2__current;

			public HitcontinuePlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Expected O, but got Unknown
				int num = <>1__state;
				HitcontinuePlugin hitcontinuePlugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!hitcontinuePlugin.cacheBuilt)
				{
					hitcontinuePlugin.FindPlayerRoots();
					if (hitcontinuePlugin.playerRoots.Count > 0)
					{
						hitcontinuePlugin.BuildObjectCache();
						hitcontinuePlugin.cacheBuilt = true;
						hitcontinuePlugin.cacheRoutine = null;
						return false;
					}
					<>2__current = (object)new WaitForSecondsRealtime(1f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public float length;

			public object timeController;

			public bool trueStop;

			public HitcontinuePlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Expected O, but got Unknown
				int num = <>1__state;
				HitcontinuePlugin hitcontinuePlugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(length);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					float num2 = (float)currentStopField.GetValue(timeController);
					if (length < num2)
					{
						return false;
					}
					hitstopActive = false;
					Time.timeScale = GetNormalTimeScale(timeController);
					if (trueStop)
					{
						CallSetAllPitch(timeController, 1f);
					}
					currentStopField.SetValue(timeController, 0f);
					hitcontinuePlugin.RestoreObjects();
					return false;
				}
				}
			}

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

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

		private const string Guid = "com.clippton.hitcontinue";

		private static HitcontinuePlugin instance;

		private static readonly Harmony harmony = new Harmony("com.clippton.hitcontinue");

		private static ConfigEntry<bool> timeControllerPatchEnabled;

		private static ConfigEntry<bool> shotgunHammerPatchEnabled;

		private static FieldInfo currentStopField;

		private static bool hitstopActive;

		private readonly List<Transform> playerRoots = new List<Transform>();

		private readonly List<Rigidbody> cachedRigidbodies = new List<Rigidbody>();

		private readonly List<Animator> cachedAnimators = new List<Animator>();

		private readonly List<NavMeshAgent> cachedAgents = new List<NavMeshAgent>();

		private readonly List<RigidbodyState> frozenRigidbodies = new List<RigidbodyState>();

		private readonly List<AnimatorState> frozenAnimators = new List<AnimatorState>();

		private readonly List<AgentState> frozenAgents = new List<AgentState>();

		private Coroutine cacheRoutine;

		private bool cacheBuilt;

		private bool frozen;

		private void Awake()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			instance = this;
			timeControllerPatchEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Hitstop", "TimeControllerPatch", true, "Convert regular TimeController HitStop/TrueStop calls into selective hitstop.");
			shotgunHammerPatchEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Hitstop", "ShotgunHammerPatch", true, "Convert ShotgunHammer TrueStop calls into selective hitstop, even if the general TimeController patch is disabled.");
			Type type = AccessTools.TypeByName("TimeController");
			if (type == null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Could not find TimeController.");
				return;
			}
			currentStopField = AccessTools.Field(type, "currentStop");
			if (currentStopField == null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Could not find TimeController.currentStop.");
				return;
			}
			harmony.Patch((MethodBase)AccessTools.Method(type, "HitStop", (Type[])null, (Type[])null), new HarmonyMethod(typeof(HitcontinuePlugin), "HitStopPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(type, "TrueStop", (Type[])null, (Type[])null), new HarmonyMethod(typeof(HitcontinuePlugin), "TrueStopPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			PatchGameUpdateMethods();
			SceneManager.sceneLoaded += OnSceneLoaded;
			StartCacheScan();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Hitcontinue loaded.");
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			harmony.UnpatchSelf();
			RestoreObjects();
			StopCacheScan();
			hitstopActive = false;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			RestoreObjects();
			ClearCache();
			cacheBuilt = false;
			hitstopActive = false;
			StartCacheScan();
		}

		private void PatchGameUpdateMethods()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			HarmonyMethod prefix = new HarmonyMethod(typeof(HitcontinuePlugin), "UpdateFreezePrefix", (Type[])null);
			HarmonyMethod prefix2 = new HarmonyMethod(typeof(HitcontinuePlugin), "CoroutineFreezePrefix", (Type[])null);
			int num = 0;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (assembly.GetName().Name != "Assembly-CSharp")
				{
					continue;
				}
				Type[] types;
				try
				{
					types = assembly.GetTypes();
				}
				catch (ReflectionTypeLoadException ex)
				{
					types = ex.Types;
				}
				Type[] array = types;
				foreach (Type type in array)
				{
					if (type == null)
					{
						continue;
					}
					if (typeof(MonoBehaviour).IsAssignableFrom(type))
					{
						if (typeof(BaseUnityPlugin).IsAssignableFrom(type))
						{
							continue;
						}
						num += PatchUpdateMethod(type, "Update", prefix);
						num += PatchUpdateMethod(type, "FixedUpdate", prefix);
						num += PatchUpdateMethod(type, "LateUpdate", prefix);
					}
					num += PatchCoroutineMethods(type, prefix2);
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Hitcontinue patched " + num + " update/coroutine methods."));
		}

		private int PatchUpdateMethod(Type type, string methodName, HarmonyMethod prefix)
		{
			MethodInfo methodInfo = AccessTools.DeclaredMethod(type, methodName, (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				return 0;
			}
			if (methodInfo.IsStatic || methodInfo.GetParameters().Length != 0 || methodInfo.ReturnType != typeof(void))
			{
				return 0;
			}
			try
			{
				harmony.Patch((MethodBase)methodInfo, prefix, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return 1;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not patch " + type.FullName + "." + methodName + ": " + ex.Message));
				return 0;
			}
		}

		private int PatchCoroutineMethods(Type type, HarmonyMethod prefix)
		{
			if (type == null || !typeof(IEnumerator).IsAssignableFrom(type))
			{
				return 0;
			}
			MethodInfo methodInfo = AccessTools.DeclaredMethod(type, "MoveNext", (Type[])null, (Type[])null);
			if (methodInfo == null || methodInfo.ReturnType != typeof(bool))
			{
				return 0;
			}
			try
			{
				harmony.Patch((MethodBase)methodInfo, prefix, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return 1;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not patch coroutine " + type.FullName + ".MoveNext: " + ex.Message));
				return 0;
			}
		}

		private static bool UpdateFreezePrefix(MonoBehaviour __instance)
		{
			if (!hitstopActive || (Object)(object)instance == (Object)null || (Object)(object)__instance == (Object)null)
			{
				return true;
			}
			return !instance.ShouldFreeze(((Component)__instance).gameObject);
		}

		private static bool CoroutineFreezePrefix(object __instance)
		{
			if (!hitstopActive || (Object)(object)instance == (Object)null || __instance == null)
			{
				return true;
			}
			if (!TryGetCoroutineOwner(__instance, out var owner))
			{
				return true;
			}
			if ((Object)(object)owner == (Object)null)
			{
				return true;
			}
			return !instance.ShouldFreeze(((Component)owner).gameObject);
		}

		private static bool TryGetCoroutineOwner(object coroutine, out MonoBehaviour owner)
		{
			owner = null;
			FieldInfo[] fields = coroutine.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (typeof(MonoBehaviour).IsAssignableFrom(fieldInfo.FieldType))
				{
					object? value = fieldInfo.GetValue(coroutine);
					owner = (MonoBehaviour)((value is MonoBehaviour) ? value : null);
					if ((Object)(object)owner != (Object)null)
					{
						return true;
					}
				}
			}
			return false;
		}

		private void StartCacheScan()
		{
			StopCacheScan();
			cacheRoutine = ((MonoBehaviour)this).StartCoroutine(CacheWhenPlayerExistsRoutine());
		}

		private void StopCacheScan()
		{
			if (cacheRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(cacheRoutine);
				cacheRoutine = null;
			}
		}

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

		private static bool HitStopPrefix(object __instance, float length)
		{
			if ((Object)(object)instance == (Object)null || !timeControllerPatchEnabled.Value)
			{
				return true;
			}
			instance.DoStop(__instance, length, trueStop: false);
			return false;
		}

		private static bool TrueStopPrefix(object __instance, float length)
		{
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (!timeControllerPatchEnabled.Value && (!shotgunHammerPatchEnabled.Value || !IsShotgunHammerTrueStopCall()))
			{
				return true;
			}
			instance.DoStop(__instance, length, trueStop: true);
			return false;
		}

		private static bool IsShotgunHammerTrueStopCall()
		{
			StackTrace stackTrace = new StackTrace();
			for (int i = 0; i < stackTrace.FrameCount; i++)
			{
				MethodBase method = stackTrace.GetFrame(i).GetMethod();
				if (!(method == null) && !(method.DeclaringType == null))
				{
					Type declaringType = method.DeclaringType;
					if (declaringType.Name == "ShotgunHammer")
					{
						return true;
					}
					if (declaringType.FullName != null && declaringType.FullName.Contains("ShotgunHammer"))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void DoStop(object timeController, float length, bool trueStop)
		{
			float num = (float)currentStopField.GetValue(timeController);
			if (length <= num)
			{
				return;
			}
			currentStopField.SetValue(timeController, length);
			if (!cacheBuilt)
			{
				FindPlayerRoots();
				if (playerRoots.Count <= 0)
				{
					Time.timeScale = GetNormalTimeScale(timeController);
					return;
				}
				BuildObjectCache();
				cacheBuilt = true;
			}
			if (!frozen)
			{
				FreezeObjects();
			}
			hitstopActive = true;
			Time.timeScale = GetNormalTimeScale(timeController);
			if (trueStop)
			{
				CallSetAllPitch(timeController, 0f);
			}
			((MonoBehaviour)this).StartCoroutine(StopRoutine(timeController, length, trueStop));
		}

		[IteratorStateMachine(typeof(<StopRoutine>d__33))]
		private IEnumerator StopRoutine(object timeController, float length, bool trueStop)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StopRoutine>d__33(0)
			{
				<>4__this = this,
				timeController = timeController,
				length = length,
				trueStop = trueStop
			};
		}

		private void FindPlayerRoots()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			playerRoots.Clear();
			GameObject[] array = GameObject.FindGameObjectsWithTag("Player");
			foreach (GameObject val in array)
			{
				if (!((Object)(object)val != (Object)null))
				{
					continue;
				}
				Scene scene = val.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					scene = val.scene;
					if (((Scene)(ref scene)).isLoaded)
					{
						playerRoots.Add(val.transform);
					}
				}
			}
		}

		private void BuildObjectCache()
		{
			cachedRigidbodies.Clear();
			cachedAnimators.Clear();
			cachedAgents.Clear();
			Rigidbody[] array = Object.FindObjectsOfType<Rigidbody>();
			foreach (Rigidbody val in array)
			{
				if ((Object)(object)val != (Object)null && ShouldFreeze(((Component)val).gameObject))
				{
					cachedRigidbodies.Add(val);
				}
			}
			Animator[] array2 = Object.FindObjectsOfType<Animator>();
			foreach (Animator val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null && ShouldFreeze(((Component)val2).gameObject))
				{
					cachedAnimators.Add(val2);
				}
			}
			NavMeshAgent[] array3 = Object.FindObjectsOfType<NavMeshAgent>();
			foreach (NavMeshAgent val3 in array3)
			{
				if ((Object)(object)val3 != (Object)null && ShouldFreeze(((Component)val3).gameObject))
				{
					cachedAgents.Add(val3);
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Hitcontinue cache built: " + playerRoots.Count + " player roots, " + cachedRigidbodies.Count + " rigidbodies, " + cachedAnimators.Count + " animators, " + cachedAgents.Count + " nav agents."));
		}

		private void ClearCache()
		{
			playerRoots.Clear();
			cachedRigidbodies.Clear();
			cachedAnimators.Clear();
			cachedAgents.Clear();
		}

		private void FreezeObjects()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			frozen = true;
			foreach (Rigidbody cachedRigidbody in cachedRigidbodies)
			{
				if (!((Object)(object)cachedRigidbody == (Object)null))
				{
					frozenRigidbodies.Add(new RigidbodyState(cachedRigidbody));
					cachedRigidbody.velocity = Vector3.zero;
					cachedRigidbody.angularVelocity = Vector3.zero;
					cachedRigidbody.isKinematic = true;
				}
			}
			foreach (Animator cachedAnimator in cachedAnimators)
			{
				if (!((Object)(object)cachedAnimator == (Object)null))
				{
					frozenAnimators.Add(new AnimatorState(cachedAnimator));
					cachedAnimator.speed = 0f;
				}
			}
			foreach (NavMeshAgent cachedAgent in cachedAgents)
			{
				if (!((Object)(object)cachedAgent == (Object)null))
				{
					frozenAgents.Add(new AgentState(cachedAgent));
					if (cachedAgent.isOnNavMesh)
					{
						cachedAgent.isStopped = true;
						cachedAgent.velocity = Vector3.zero;
					}
				}
			}
		}

		private void RestoreObjects()
		{
			foreach (RigidbodyState frozenRigidbody in frozenRigidbodies)
			{
				frozenRigidbody.Restore();
			}
			foreach (AnimatorState frozenAnimator in frozenAnimators)
			{
				frozenAnimator.Restore();
			}
			foreach (AgentState frozenAgent in frozenAgents)
			{
				frozenAgent.Restore();
			}
			frozenRigidbodies.Clear();
			frozenAnimators.Clear();
			frozenAgents.Clear();
			frozen = false;
		}

		private bool ShouldFreeze(GameObject obj)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)obj != (Object)null)
			{
				Scene scene = obj.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					scene = obj.scene;
					if (((Scene)(ref scene)).isLoaded)
					{
						return !IsPlayerOrChild(obj);
					}
				}
			}
			return false;
		}

		private bool IsPlayerOrChild(GameObject obj)
		{
			Transform val = obj.transform;
			while ((Object)(object)val != (Object)null)
			{
				foreach (Transform playerRoot in playerRoots)
				{
					if ((Object)(object)playerRoot != (Object)null && (Object)(object)val == (Object)(object)playerRoot)
					{
						return true;
					}
				}
				val = val.parent;
			}
			return false;
		}

		private static float GetNormalTimeScale(object timeController)
		{
			float num = (float)AccessTools.Field(timeController.GetType(), "timeScale").GetValue(timeController);
			float num2 = (float)AccessTools.Field(timeController.GetType(), "timeScaleModifier").GetValue(timeController);
			return num * num2;
		}

		private static void CallSetAllPitch(object timeController, float pitch)
		{
			MethodInfo methodInfo = AccessTools.Method(timeController.GetType(), "SetAllPitch", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				methodInfo.Invoke(timeController, new object[1] { pitch });
			}
		}
	}
}