using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using Atlas;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
using Sodalite.Api;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace JalexInteractive.VirtualMission
{
	[BepInPlugin("JalexInteractive.VirtualMission", "VirtualMission", "1.0.1")]
	[BepInProcess("h3vr.exe")]
	[Description("Built with MeatKit")]
	[BepInDependency("nrgill28.Atlas", "1.0.1")]
	public class VirtualMissionPlugin : BaseUnityPlugin
	{
		private static readonly string BasePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		internal static ManualLogSource Logger;

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			LoadAssets();
		}

		private void LoadAssets()
		{
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "JalexInteractive.VirtualMission");
			AtlasPlugin.RegisterScene(Path.Combine(BasePath, "virtualmission"));
		}
	}
}
public class ActiveFlip : MonoBehaviour
{
	public GameObject[] objects;

	public AudioSource onSound;

	public AudioSource offSound;

	public void DoAFlip()
	{
		GameObject[] array = objects;
		foreach (GameObject val in array)
		{
			val.SetActive(!val.activeSelf);
			if (val.activeSelf)
			{
				onSound.Play();
			}
			else
			{
				offSound.Play();
			}
		}
	}
}
public class BangBangButton : MonoBehaviour, IFVRDamageable
{
	public List<UnityEvent> triggerThis;

	public void Damage(Damage D)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		if ((int)D.Class != 1)
		{
			return;
		}
		foreach (UnityEvent triggerThi in triggerThis)
		{
			triggerThi.Invoke();
		}
	}
}
public class BobAndSpin : MonoBehaviour
{
	private float originalY;

	public float floatStrength = 0.05f;

	public int spinSpeed = 45;

	private void Start()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		originalY = ((Component)this).transform.localPosition.y;
	}

	private void Update()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: 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_0047: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(((Component)this).transform.localPosition.x, originalY + (float)Math.Sin(Time.time) * floatStrength, ((Component)this).transform.localPosition.z);
		((Component)this).transform.Rotate(0f, (float)spinSpeed * Time.deltaTime, 0f, (Space)1);
	}
}
public class BobbingBarrels : MonoBehaviour
{
	private float originalY;

	public float floatStrengthLower = 1f;

	public float floatStrengthUpper = 1f;

	private float floatStrength;

	private void Start()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		originalY = ((Component)this).transform.position.y;
		floatStrength = Random.Range(floatStrengthLower, floatStrengthUpper);
	}

	private void Update()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: 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_0047: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.position = new Vector3(((Component)this).transform.position.x, originalY + (float)Math.Sin(Time.time) * floatStrength, ((Component)this).transform.position.z);
	}
}
namespace VirtualMission
{
	public class ColourSwitcher : MonoBehaviour
	{
		public List<MeshRenderer> switchRenderers;

		public List<MeshRenderer> particleMeshRenderers;

		public List<ParticleSystemRenderer> particleRenderers;

		public static byte transValue = byte.MaxValue;

		private Color32 selectedColour = new Color32((byte)0, (byte)192, byte.MaxValue, transValue);

		public void ColourSwitch(int colour)
		{
			//IL_0075: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00d1: 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_00f2: 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_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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_0167: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			if (DevPanel.overdrawOn)
			{
				transValue = 150;
			}
			else
			{
				transValue = byte.MaxValue;
			}
			switch (colour)
			{
			case 0:
				selectedColour = new Color32((byte)0, (byte)192, byte.MaxValue, transValue);
				break;
			case 1:
				selectedColour = new Color32((byte)0, byte.MaxValue, (byte)0, transValue);
				break;
			case 2:
				selectedColour = new Color32(byte.MaxValue, (byte)0, (byte)0, transValue);
				break;
			case 3:
				selectedColour = new Color32(byte.MaxValue, (byte)111, byte.MaxValue, transValue);
				break;
			case 4:
				selectedColour = new Color32(byte.MaxValue, (byte)143, (byte)0, transValue);
				break;
			case 5:
				selectedColour = new Color32(byte.MaxValue, (byte)235, (byte)4, transValue);
				break;
			case 6:
				selectedColour = new Color32((byte)0, (byte)50, (byte)111, transValue);
				break;
			case 7:
				selectedColour = new Color32((byte)0, (byte)101, (byte)0, transValue);
				break;
			case 8:
				selectedColour = new Color32((byte)101, (byte)0, (byte)0, transValue);
				break;
			case 9:
				selectedColour = new Color32((byte)169, (byte)0, (byte)169, transValue);
				break;
			case 10:
				selectedColour = new Color32((byte)101, (byte)60, (byte)0, transValue);
				break;
			case 11:
				selectedColour = new Color32((byte)150, (byte)150, (byte)0, transValue);
				break;
			}
			foreach (MeshRenderer switchRenderer in switchRenderers)
			{
				((Renderer)switchRenderer).sharedMaterial.SetColor("_Color", Color32.op_Implicit(selectedColour));
				((Renderer)switchRenderer).sharedMaterial.SetColor("_EmissionColor", Color32.op_Implicit(selectedColour));
				((Renderer)switchRenderer).sharedMaterial.SetColor("_RimColor", Color32.op_Implicit(selectedColour));
			}
			foreach (MeshRenderer particleMeshRenderer in particleMeshRenderers)
			{
				((Renderer)particleMeshRenderer).sharedMaterial.SetColor("_TintColor", Color32.op_Implicit(selectedColour));
			}
			foreach (ParticleSystemRenderer particleRenderer in particleRenderers)
			{
				((Renderer)particleRenderer).sharedMaterial.SetColor("_TintColor", Color32.op_Implicit(selectedColour));
			}
		}
	}
	public class DevPanel : MonoBehaviour
	{
		public static TNH_Manager tnhManager;

		public static FVRPlayerBody player;

		public static GM gameManager;

		public Material overdrawMat;

		public List<MeshRenderer> overdrawRenderers;

		public List<Material> originalMats;

		public static bool overdrawOn = false;

		private void Start()
		{
			foreach (MeshRenderer overdrawRenderer in overdrawRenderers)
			{
				Material item = ((Renderer)overdrawRenderer).materials[0];
				originalMats.Add(item);
			}
		}

		private void Update()
		{
			if (!Object.op_Implicit((Object)(object)tnhManager))
			{
				tnhManager = Object.FindObjectOfType<TNH_Manager>();
			}
			if (!Object.op_Implicit((Object)(object)player))
			{
				player = Object.FindObjectOfType<FVRPlayerBody>();
			}
			if (!Object.op_Implicit((Object)(object)gameManager))
			{
				gameManager = Object.FindObjectOfType<GM>();
			}
		}

		public void ButtonPress(int button)
		{
			LeaderboardAPI.LeaderboardDisabled.TakeLock();
			switch (button)
			{
			case 0:
				player.ResetHealth();
				break;
			case 1:
				tnhManager.AddTokens(1, true);
				tnhManager.EnqueueTokenLine(1);
				break;
			case 2:
			{
				if (!overdrawOn)
				{
					foreach (MeshRenderer overdrawRenderer in overdrawRenderers)
					{
						((Renderer)overdrawRenderer).material = overdrawMat;
					}
					overdrawOn = true;
					break;
				}
				int num = 0;
				foreach (MeshRenderer overdrawRenderer2 in overdrawRenderers)
				{
					((Renderer)overdrawRenderer2).material = originalMats[num];
					num++;
				}
				overdrawOn = false;
				break;
			}
			case 3:
				tnhManager.GenerateValidPatrol(tnhManager.m_curLevel.PatrolChallenge, tnhManager.m_curHoldIndex, tnhManager.m_curHoldIndex, false);
				break;
			case 4:
				tnhManager.KillAllPatrols();
				break;
			case 5:
			{
				for (int k = 0; k < tnhManager.HoldPoints.Count; k++)
				{
					tnhManager.HoldPoints[k].DeleteSosigs();
					tnhManager.HoldPoints[k].DeleteTurrets();
				}
				for (int l = 0; l < tnhManager.SupplyPoints.Count; l++)
				{
					tnhManager.SupplyPoints[l].DeleteSosigs();
					tnhManager.SupplyPoints[l].DeleteTurrets();
				}
				break;
			}
			case 6:
			{
				tnhManager.KillAllPatrols();
				for (int i = 0; i < tnhManager.HoldPoints.Count; i++)
				{
					tnhManager.HoldPoints[i].DeleteSosigs();
					tnhManager.HoldPoints[i].DeleteTurrets();
				}
				for (int j = 0; j < tnhManager.SupplyPoints.Count; j++)
				{
					tnhManager.SupplyPoints[j].DeleteSosigs();
					tnhManager.SupplyPoints[j].DeleteTurrets();
				}
				break;
			}
			case 7:
				switch (player.GetPlayerIFF())
				{
				case 0:
					player.SetPlayerIFF(-3);
					break;
				case -3:
					player.SetPlayerIFF(0);
					break;
				}
				break;
			case 8:
				player.KillPlayer(true);
				break;
			}
		}
	}
	public class HoldManager : MonoBehaviour
	{
		[Tooltip("List of hold points")]
		public List<GameObject> geoHolds;

		public static TNH_Manager tnhManager;

		private TNH_HoldPoint currentHold;

		private int currentHoldIndex = -1;

		private Vector3 target;

		private void Start()
		{
			tnhManager = Object.FindObjectOfType<TNH_Manager>();
		}

		private void Update()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: 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_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)tnhManager))
			{
				tnhManager = Object.FindObjectOfType<TNH_Manager>();
			}
			if (!object.ReferenceEquals(currentHold, tnhManager.m_curHoldPoint))
			{
				currentHold = tnhManager.m_curHoldPoint;
			}
			for (int i = 0; i <= tnhManager.HoldPoints.Count() - 1; i++)
			{
				if ((Object)(object)tnhManager.HoldPoints[i] == (Object)(object)currentHold)
				{
					currentHoldIndex = i;
					break;
				}
			}
			if ((int)tnhManager.Phase != 1)
			{
				foreach (GameObject geoHold in geoHolds)
				{
					if (geoHold.activeInHierarchy)
					{
						if (geoHold.transform.position.y != -10f)
						{
							target = new Vector3(geoHold.transform.position.x, -10f, geoHold.transform.position.z);
							geoHold.transform.position = Vector3.MoveTowards(geoHold.transform.position, target, 5f * Time.deltaTime);
						}
						else
						{
							geoHold.SetActive(false);
						}
					}
				}
				return;
			}
			if (!geoHolds[currentHoldIndex].activeInHierarchy)
			{
				geoHolds[currentHoldIndex].SetActive(true);
			}
			else if (geoHolds[currentHoldIndex].activeInHierarchy && geoHolds[currentHoldIndex].transform.position.y != 0f)
			{
				target = new Vector3(geoHolds[currentHoldIndex].transform.position.x, 0f, geoHolds[currentHoldIndex].transform.position.z);
				geoHolds[currentHoldIndex].transform.position = Vector3.MoveTowards(geoHolds[currentHoldIndex].transform.position, target, 5f * Time.deltaTime);
			}
		}
	}
}
public class LookAtTarget : MonoBehaviour
{
	public GameObject Target;

	public bool X;

	public bool Y;

	public bool Z;

	private Transform LookAtMe;

	private Vector3 LookAtThis;

	private Vector3 OGUp;

	private void Awake()
	{
	}

	private void Start()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		OGUp = ((Component)this).transform.up;
		Debug.Log((object)OGUp);
	}

	private void LateUpdate()
	{
		//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_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: 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_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: 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)
		if ((Object)(object)Target == (Object)null)
		{
			LookAtMe = ((Component)GM.CurrentPlayerBody.Head).transform;
		}
		else
		{
			LookAtMe = Target.transform;
		}
		LookAtThis = LookAtMe.position;
		if (!X)
		{
			LookAtThis.x = ((Component)this).transform.position.x;
		}
		if (!Y)
		{
			LookAtThis.y = ((Component)this).transform.position.y;
		}
		if (!Z)
		{
			LookAtThis.z = ((Component)this).transform.position.z;
		}
		((Component)this).transform.LookAt(LookAtThis, OGUp);
	}
}
namespace VirtualMission
{
	public class MapGlowies : MonoBehaviour
	{
		public static TNH_Manager tnhManager;

		public GameObject[] glowieLocations;

		private List<int> activeSupplies;

		private void Start()
		{
			tnhManager = Object.FindObjectOfType<TNH_Manager>();
			activeSupplies = tnhManager.ActiveSupplyPointIndicies();
		}

		private void Update()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)tnhManager))
			{
				tnhManager = Object.FindObjectOfType<TNH_Manager>();
			}
			if ((int)tnhManager.Phase == 0)
			{
				if (activeSupplies != tnhManager.ActiveSupplyPointIndicies())
				{
					activeSupplies = tnhManager.ActiveSupplyPointIndicies();
				}
				for (int i = 0; i <= glowieLocations.Count(); i++)
				{
					if (activeSupplies.Contains(i))
					{
						glowieLocations[i].SetActive(true);
					}
				}
			}
			else
			{
				GameObject[] array = glowieLocations;
				foreach (GameObject val in array)
				{
					val.SetActive(false);
				}
			}
		}
	}
}
namespace Packer
{
	public class Packer_Platform : MovingPlatformBase
	{
		public void Awake()
		{
			((MovingPlatformBase)this).Awake();
		}

		public void FixedUpdate()
		{
			//IL_000d: 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)
			base.refT.position = ((Component)this).transform.position;
			base.refT.rotation = ((Component)this).transform.rotation;
		}

		public override Vector3 PhysicsStep()
		{
			//IL_000d: 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_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_0039: Unknown result type (might be due to invalid IL or missing references)
			base.refT.position = ((Component)this).transform.position;
			base.refT.rotation = ((Component)this).transform.rotation;
			return ((MovingPlatformBase)this).PhysicsStep();
		}
	}
}
namespace VirtualMission
{
	public class ParticleTrigger : MonoBehaviour
	{
		public static TNH_Manager tnhManager;

		public ParticleSystem[] particles;

		private TNH_HoldPoint currentHold;

		private bool doneThisHold = true;

		private void Start()
		{
			tnhManager = Object.FindObjectOfType<TNH_Manager>();
		}

		private void Update()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)tnhManager))
			{
				tnhManager = Object.FindObjectOfType<TNH_Manager>();
			}
			if (!Object.op_Implicit((Object)(object)currentHold))
			{
				currentHold = tnhManager.m_curHoldPoint;
			}
			if (!object.ReferenceEquals(currentHold, tnhManager.m_curHoldPoint))
			{
				currentHold = tnhManager.m_curHoldPoint;
				doneThisHold = false;
			}
			if ((int)tnhManager.Phase != 1 && !doneThisHold)
			{
				ParticleSystem[] array = particles;
				foreach (ParticleSystem val in array)
				{
					val.Play();
				}
				doneThisHold = true;
			}
		}
	}
}
public class PlayerBodyTrigger : MonoBehaviour
{
	public bool LooksForPlayerBody;

	public bool LooksForPlayerHand;

	public List<UnityEvent> OnPlayerHeadOrBodyEnter;

	public List<UnityEvent> OnPlayerHeadOrBodyExit;

	public List<UnityEvent> OnPlayerHandEnter;

	public List<UnityEvent> OnPlayerHandExit;

	private void OnTriggerEnter(Collider other)
	{
		if (LooksForPlayerBody && ((Component)other).gameObject.layer == 15)
		{
			if (OnPlayerHeadOrBodyEnter == null)
			{
				return;
			}
			{
				foreach (UnityEvent item in OnPlayerHeadOrBodyEnter)
				{
					item.Invoke();
				}
				return;
			}
		}
		if (((Component)other).gameObject.layer != 9 || OnPlayerHandEnter == null)
		{
			return;
		}
		foreach (UnityEvent item2 in OnPlayerHandEnter)
		{
			item2.Invoke();
		}
	}

	private void OnTriggerExit(Collider other)
	{
		if (LooksForPlayerBody && ((Component)other).gameObject.layer == 15)
		{
			if (OnPlayerHeadOrBodyExit == null)
			{
				return;
			}
			{
				foreach (UnityEvent item in OnPlayerHeadOrBodyExit)
				{
					item.Invoke();
				}
				return;
			}
		}
		if (!LooksForPlayerHand || ((Component)other).gameObject.layer != 9 || OnPlayerHeadOrBodyExit == null)
		{
			return;
		}
		foreach (UnityEvent item2 in OnPlayerHandExit)
		{
			item2.Invoke();
		}
	}
}
public class PlayerParent : MonoBehaviour
{
	public enum BodyPart
	{
		Head,
		LeftHand,
		RightHand
	}

	public BodyPart selected;

	public float offsetX = 0f;

	public float offsetY = 0f;

	public float offsetZ = 0f;

	private Vector3 destination;

	private bool parented;

	private void Start()
	{
		parented = false;
		destination.x = offsetX;
		destination.y = offsetY;
		destination.z = offsetZ;
	}

	private void LateUpdate()
	{
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		if (!parented)
		{
			switch (selected)
			{
			case BodyPart.Head:
				((Component)this).transform.SetParent(GM.CurrentPlayerBody.Head, false);
				break;
			case BodyPart.LeftHand:
				((Component)this).transform.SetParent(GM.CurrentPlayerBody.LeftHand, false);
				break;
			case BodyPart.RightHand:
				((Component)this).transform.SetParent(GM.CurrentPlayerBody.RightHand, false);
				break;
			}
			((Component)this).transform.localPosition = destination;
			parented = true;
		}
	}
}
public class PlayerTeleport : MonoBehaviour
{
	public Transform TeleportPoint;

	public void Teleport()
	{
		//IL_000c: 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)
		GM.CurrentMovementManager.TeleportToPoint(TeleportPoint.position, true, TeleportPoint.forward);
	}
}
namespace VirtualMission
{
	public class ScoreDisplay : MonoBehaviour
	{
		public enum Type
		{
			Health,
			Tokens,
			Score,
			HoldName,
			HoldNumber,
			Wave,
			ShotsFired,
			TotalKills,
			Time
		}

		public static TNH_Manager tnhManager;

		public static FVRPlayerBody player;

		public static HoldManager holdManager;

		public Text label;

		private TNH_HoldPoint currentHold;

		private int currentHoldIndex = -1;

		private Traverse<int> trCurPhaseIdx;

		private Traverse<int> trMaxPhases;

		public Type type;

		private void Start()
		{
			tnhManager = Object.FindObjectOfType<TNH_Manager>();
			player = Object.FindObjectOfType<FVRPlayerBody>();
			holdManager = Object.FindObjectOfType<HoldManager>();
		}

		private void Update()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Expected I4, but got Unknown
			if (!Object.op_Implicit((Object)(object)tnhManager))
			{
				tnhManager = Object.FindObjectOfType<TNH_Manager>();
			}
			if (!Object.op_Implicit((Object)(object)player))
			{
				player = Object.FindObjectOfType<FVRPlayerBody>();
			}
			if (!Object.op_Implicit((Object)(object)holdManager))
			{
				holdManager = Object.FindObjectOfType<HoldManager>();
			}
			switch (type)
			{
			case Type.HoldNumber:
				if ((int)tnhManager.ProgressionMode == 1)
				{
					label.text = tnhManager.m_level + " / ∞";
				}
				else
				{
					label.text = tnhManager.m_level + " / " + tnhManager.m_maxLevels;
				}
				break;
			case Type.HoldName:
			{
				if (!object.ReferenceEquals(currentHold, tnhManager.m_curHoldPoint))
				{
					currentHold = tnhManager.m_curHoldPoint;
				}
				for (int i = 0; i <= tnhManager.HoldPoints.Count; i++)
				{
					if ((Object)(object)tnhManager.HoldPoints[i] == (Object)(object)currentHold)
					{
						currentHoldIndex = i;
						break;
					}
				}
				label.text = ((Object)holdManager.geoHolds[currentHoldIndex]).name;
				break;
			}
			case Type.Health:
			{
				float num3 = player.GetPlayerHealthRaw();
				label.text = num3.ToString();
				break;
			}
			case Type.Tokens:
			{
				int numTokens = tnhManager.GetNumTokens();
				label.text = numTokens.ToString();
				break;
			}
			case Type.Score:
			{
				int num2 = tnhManager.ReturnSummedBaseScore();
				label.text = num2.ToString();
				break;
			}
			case Type.Wave:
				switch ((int)tnhManager.Phase)
				{
				case 0:
					label.text = "Take";
					break;
				case 1:
					if (!object.ReferenceEquals(currentHold, tnhManager.m_curHoldPoint))
					{
						currentHold = tnhManager.m_curHoldPoint;
					}
					trCurPhaseIdx = Traverse.Create((object)currentHold).Field<int>("m_phaseIndex");
					trMaxPhases = Traverse.Create((object)currentHold).Field<int>("m_maxPhases");
					if (trCurPhaseIdx.Value + 1 > trMaxPhases.Value)
					{
						label.text = "Complete";
					}
					else
					{
						label.text = $"{trCurPhaseIdx.Value + 1} / {trMaxPhases.Value}";
					}
					break;
				case 2:
					label.text = "Victory!";
					break;
				case 3:
					label.text = "Failure";
					break;
				}
				break;
			case Type.Time:
			{
				float timePlaying = tnhManager.m_timePlaying;
				int num = (int)Mathf.Round(timePlaying);
				TimeSpan timeSpan = TimeSpan.FromSeconds(num);
				string text = $"{timeSpan.Minutes:D2}m:{timeSpan.Seconds:D2}s";
				label.text = text;
				break;
			}
			case Type.ShotsFired:
			case Type.TotalKills:
				break;
			}
		}
	}
}
public class SpinnyFan : MonoBehaviour
{
	public int Speed;

	private void Start()
	{
	}

	private void Update()
	{
		((Component)this).transform.Rotate(0f, (float)Speed * Time.deltaTime, 0f, (Space)0);
	}
}
namespace VirtualMission
{
	internal class TNHInfo : MonoBehaviour
	{
		private void Start()
		{
		}

		private void Update()
		{
		}
	}
}
public class Throb : MonoBehaviour
{
	public AnimationCurve Curve_Scaling;

	private bool isThrobbing = false;

	private float lerp = 0f;

	public void Update()
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		if (lerp < 1f)
		{
			lerp += Time.deltaTime * 0.1f;
		}
		if (isThrobbing || (lerp > 0f && lerp < 1f))
		{
			float num = Curve_Scaling.Evaluate(lerp);
			((Component)this).transform.localScale = new Vector3(num, num, num);
		}
		else
		{
			isThrobbing = false;
		}
	}

	public void StartThrobbing()
	{
		lerp = 0f;
		isThrobbing = true;
	}
}
public class TokenReplacement : MonoBehaviour
{
	[Tooltip("Will apply the Bob and Spin script to the health model similar to the way vanilla tokens spin.")]
	public bool CopyTokenSpinning;

	[Tooltip("Model to replace the health pickup with.")]
	public Mesh healthModel;

	[Tooltip("Material to replace the health pickups with.")]
	public Material healthMaterial;

	private MeshFilter healthFilter;

	private MeshRenderer healthRenderer;

	[Tooltip("Model to replace the token pickup with.")]
	public Mesh tokenModel;

	[Tooltip("Material to replace the token pickups with.")]
	public Material tokenMaterial;

	private MeshFilter tokenFilter;

	private MeshRenderer tokenRenderer;

	private Vector3 default0 = new Vector3(0f, 1f, 0f);

	private Vector3 default1 = new Vector3(1f, 1f, 1f);

	private void Update()
	{
		//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_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: 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_0091: 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_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: 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)
		GameObject val = GameObject.Find("HealthPickup_Minor(Clone)/HealthCrystal");
		if (Object.op_Implicit((Object)(object)val))
		{
			healthFilter = val.GetComponent<MeshFilter>();
			((Object)((Component)val.transform.parent).gameObject).name = "HealthPickup_Minor(IAmNotASheep)";
			healthRenderer = val.GetComponent<MeshRenderer>();
			Vector3 localScale = val.transform.localScale;
			if (!((object)(Vector3)(ref localScale)).Equals((object?)default1))
			{
				val.transform.localScale = default1;
			}
			Vector3 localPosition = val.transform.localPosition;
			if (!((object)(Vector3)(ref localPosition)).Equals((object?)default0))
			{
				val.transform.localPosition = default0;
			}
			if ((Object)(object)healthFilter.mesh != (Object)(object)healthModel)
			{
				healthFilter.mesh = healthModel;
			}
			if ((Object)(object)((Renderer)healthRenderer).material != (Object)(object)healthMaterial)
			{
				((Renderer)healthRenderer).material = healthMaterial;
			}
			if (CopyTokenSpinning && (Object)(object)val.GetComponent<BobAndSpin>() == (Object)null)
			{
				val.AddComponent<BobAndSpin>();
			}
		}
		GameObject val2 = GameObject.Find("TNH_OverrideToken(Clone)/GameObject/Display");
		if (Object.op_Implicit((Object)(object)val2))
		{
			tokenFilter = val2.GetComponent<MeshFilter>();
			tokenRenderer = val2.GetComponent<MeshRenderer>();
			((Object)((Component)val2.transform.parent).gameObject).name = "TNH_OverrideToken(IAmNotASheep)";
			Vector3 localScale2 = val2.transform.localScale;
			if (!((object)(Vector3)(ref localScale2)).Equals((object?)default1))
			{
				val2.transform.localScale = default1;
			}
			if ((Object)(object)tokenFilter.mesh != (Object)(object)tokenModel)
			{
				tokenFilter.mesh = tokenModel;
			}
			if ((Object)(object)((Renderer)tokenRenderer).material != (Object)(object)tokenMaterial)
			{
				((Renderer)tokenRenderer).material = tokenMaterial;
			}
		}
	}
}
public class UmaUmaLeftAndRight : MonoBehaviour
{
	private float originalX;

	public float floatStrengthLower = 1f;

	public float floatStrengthUpper = 1f;

	private float floatStrength;

	private void Start()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		originalX = ((Component)this).transform.localPosition.x;
		floatStrength = Random.Range(floatStrengthLower, floatStrengthUpper);
	}

	private void Update()
	{
		//IL_0027: 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_0047: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(originalX + (float)Math.Sin(Time.time) * floatStrength, ((Component)this).transform.localPosition.y, ((Component)this).transform.localPosition.z);
	}
}
public class UmaUmaRightAndLeft : MonoBehaviour
{
	private float originalZ;

	public float floatStrengthLower = 1f;

	public float floatStrengthUpper = 1f;

	private float floatStrength;

	private void Start()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		originalZ = ((Component)this).transform.localPosition.z;
		floatStrength = Random.Range(floatStrengthLower, floatStrengthUpper);
	}

	private void Update()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(((Component)this).transform.localPosition.x, ((Component)this).transform.localPosition.y, originalZ + (float)Math.Sin(Time.time) * floatStrength);
	}
}
public class UmaUmaUpAndDown : MonoBehaviour
{
	private float originalY;

	public float floatStrengthLower = 1f;

	public float floatStrengthUpper = 1f;

	private float floatStrength;

	private void Start()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		originalY = ((Component)this).transform.localPosition.y;
		floatStrength = Random.Range(floatStrengthLower, floatStrengthUpper);
	}

	private void Update()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: 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_0047: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(((Component)this).transform.localPosition.x, originalY + (float)Math.Sin(Time.time) * floatStrength, ((Component)this).transform.localPosition.z);
	}
}
public class CuttableMesh
{
	private MeshRenderer inputMeshRenderer;

	private bool hasUvs;

	private bool hasUv1s;

	private bool hasColours;

	private List<CuttableSubMesh> subMeshes;

	public CuttableMesh(Mesh inputMesh)
	{
		Init(inputMesh, ((Object)inputMesh).name);
	}

	public CuttableMesh(MeshRenderer input)
	{
		inputMeshRenderer = input;
		MeshFilter component = ((Component)input).GetComponent<MeshFilter>();
		Mesh sharedMesh = component.sharedMesh;
		Init(sharedMesh, ((Object)input).name);
	}

	public CuttableMesh(CuttableMesh inputMesh, List<CuttableSubMesh> newSubMeshes)
	{
		inputMeshRenderer = inputMesh.inputMeshRenderer;
		hasUvs = inputMesh.hasUvs;
		hasUv1s = inputMesh.hasUv1s;
		hasColours = inputMesh.hasColours;
		subMeshes = new List<CuttableSubMesh>();
		subMeshes.AddRange(newSubMeshes);
	}

	private void Init(Mesh inputMesh, string debugName)
	{
		subMeshes = new List<CuttableSubMesh>();
		if (inputMesh.isReadable)
		{
			Vector3[] vertices = inputMesh.vertices;
			Vector3[] normals = inputMesh.normals;
			Vector2[] uv = inputMesh.uv;
			Vector2[] uv2 = inputMesh.uv2;
			Color32[] colors = inputMesh.colors32;
			hasUvs = uv != null && uv.Length > 0;
			hasUv1s = uv2 != null && uv2.Length > 0;
			hasColours = colors != null && colors.Length > 0;
			for (int i = 0; i < inputMesh.subMeshCount; i++)
			{
				int[] indices = inputMesh.GetIndices(i);
				CuttableSubMesh item = new CuttableSubMesh(indices, vertices, normals, colors, uv, uv2);
				subMeshes.Add(item);
			}
		}
		else
		{
			Debug.LogError((object)("CuttableMesh's input mesh is not readable: " + debugName), (Object)(object)inputMesh);
		}
	}

	public void Add(CuttableMesh other)
	{
		if (subMeshes.Count != other.subMeshes.Count)
		{
			throw new Exception("Mismatched submesh count");
		}
		for (int i = 0; i < subMeshes.Count; i++)
		{
			subMeshes[i].Add(other.subMeshes[i]);
		}
	}

	public int NumSubMeshes()
	{
		return subMeshes.Count;
	}

	public bool HasUvs()
	{
		return hasUvs;
	}

	public bool HasColours()
	{
		return hasColours;
	}

	public List<CuttableSubMesh> GetSubMeshes()
	{
		return subMeshes;
	}

	public CuttableSubMesh GetSubMesh(int index)
	{
		return subMeshes[index];
	}

	public Transform GetTransform()
	{
		if ((Object)(object)inputMeshRenderer != (Object)null)
		{
			return ((Component)inputMeshRenderer).transform;
		}
		return null;
	}

	public MeshRenderer ConvertToRenderer(string newObjectName)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		//IL_003d: 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_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		Mesh val = CreateMesh();
		if (val.vertexCount == 0)
		{
			return null;
		}
		GameObject val2 = new GameObject(newObjectName);
		val2.transform.SetParent(((Component)inputMeshRenderer).transform);
		val2.transform.localPosition = Vector3.zero;
		val2.transform.localRotation = Quaternion.identity;
		val2.transform.localScale = Vector3.one;
		MeshFilter val3 = val2.AddComponent<MeshFilter>();
		val3.mesh = val;
		MeshRenderer val4 = val2.AddComponent<MeshRenderer>();
		((Renderer)val4).shadowCastingMode = ((Renderer)inputMeshRenderer).shadowCastingMode;
		((Renderer)val4).reflectionProbeUsage = ((Renderer)inputMeshRenderer).reflectionProbeUsage;
		((Renderer)val4).lightProbeUsage = ((Renderer)inputMeshRenderer).lightProbeUsage;
		((Renderer)val4).sharedMaterials = ((Renderer)inputMeshRenderer).sharedMaterials;
		return val4;
	}

	public Mesh CreateMesh()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Expected O, but got Unknown
		Mesh val = new Mesh();
		int num = 0;
		for (int i = 0; i < subMeshes.Count; i++)
		{
			num += subMeshes[i].NumIndices();
		}
		List<Vector3> list = new List<Vector3>();
		List<Vector3> list2 = new List<Vector3>();
		List<Color32> list3 = ((!hasColours) ? null : new List<Color32>());
		List<Vector2> list4 = ((!hasUvs) ? null : new List<Vector2>());
		List<Vector2> list5 = ((!hasUv1s) ? null : new List<Vector2>());
		List<int> list6 = new List<int>();
		foreach (CuttableSubMesh subMesh in subMeshes)
		{
			list6.Add(list.Count);
			subMesh.AddTo(list, list2, list3, list4, list5);
		}
		val.vertices = list.ToArray();
		val.normals = list2.ToArray();
		val.colors32 = ((!hasColours) ? null : list3.ToArray());
		val.uv = ((!hasUvs) ? null : list4.ToArray());
		val.uv2 = ((!hasUv1s) ? null : list5.ToArray());
		val.subMeshCount = subMeshes.Count;
		for (int j = 0; j < subMeshes.Count; j++)
		{
			CuttableSubMesh cuttableSubMesh = subMeshes[j];
			int num2 = list6[j];
			int[] array = cuttableSubMesh.GenIndices();
			for (int k = 0; k < array.Length; k++)
			{
				array[k] += num2;
			}
			val.SetTriangles(array, j, true);
		}
		return val;
	}
}
public class CuttableSubMesh
{
	private List<Vector3> vertices;

	private List<Vector3> normals;

	private List<Color32> colours;

	private List<Vector2> uvs;

	private List<Vector2> uv1s;

	public CuttableSubMesh(bool hasNormals, bool hasColours, bool hasUvs, bool hasUv1)
	{
		vertices = new List<Vector3>();
		if (hasNormals)
		{
			normals = new List<Vector3>();
		}
		if (hasColours)
		{
			colours = new List<Color32>();
		}
		if (hasUvs)
		{
			uvs = new List<Vector2>();
		}
		if (hasUv1)
		{
			uv1s = new List<Vector2>();
		}
	}

	public CuttableSubMesh(int[] indices, Vector3[] inputVertices, Vector3[] inputNormals, Color32[] inputColours, Vector2[] inputUvs, Vector2[] inputUv1)
	{
		//IL_0099: 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_00de: 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_0124: Unknown result type (might be due to invalid IL or missing references)
		vertices = new List<Vector3>();
		if (inputNormals != null && inputNormals.Length > 0)
		{
			normals = new List<Vector3>();
		}
		if (inputColours != null && inputColours.Length > 0)
		{
			colours = new List<Color32>();
		}
		if (inputUvs != null && inputUvs.Length > 0)
		{
			uvs = new List<Vector2>();
		}
		if (inputUv1 != null && inputUv1.Length > 0)
		{
			uv1s = new List<Vector2>();
		}
		foreach (int num in indices)
		{
			vertices.Add(inputVertices[num]);
			if (normals != null)
			{
				normals.Add(inputNormals[num]);
			}
			if (colours != null)
			{
				colours.Add(inputColours[num]);
			}
			if (uvs != null)
			{
				uvs.Add(inputUvs[num]);
			}
			if (uv1s != null)
			{
				uv1s.Add(inputUv1[num]);
			}
		}
	}

	public void Add(CuttableSubMesh other)
	{
		for (int i = 0; i < other.vertices.Count; i++)
		{
			CopyVertex(i, other);
		}
	}

	public int NumVertices()
	{
		return vertices.Count;
	}

	public Vector3 GetVertex(int index)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		return vertices[index];
	}

	public bool HasNormals()
	{
		return normals != null;
	}

	public bool HasColours()
	{
		return colours != null;
	}

	public bool HasUvs()
	{
		return uvs != null;
	}

	public bool HasUv1()
	{
		return uv1s != null;
	}

	public void CopyVertex(int srcIndex, CuttableSubMesh srcMesh)
	{
		//IL_000e: 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_0052: 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_0096: Unknown result type (might be due to invalid IL or missing references)
		vertices.Add(srcMesh.vertices[srcIndex]);
		if (normals != null)
		{
			normals.Add(srcMesh.normals[srcIndex]);
		}
		if (colours != null)
		{
			colours.Add(srcMesh.colours[srcIndex]);
		}
		if (uvs != null)
		{
			uvs.Add(srcMesh.uvs[srcIndex]);
		}
		if (uv1s != null)
		{
			uv1s.Add(srcMesh.uv1s[srcIndex]);
		}
	}

	public void AddInterpolatedVertex(int i0, int i1, float weight, CuttableSubMesh srcMesh)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: 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_001c: 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_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: 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_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: 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)
		Vector3 vertex = srcMesh.GetVertex(i0);
		Vector3 vertex2 = srcMesh.GetVertex(i1);
		vertices.Add(Vector3.Lerp(vertex, vertex2, weight));
		if (normals != null)
		{
			List<Vector3> list = normals;
			Vector3 val = Vector3.Lerp(srcMesh.normals[i0], srcMesh.normals[i1], weight);
			list.Add(((Vector3)(ref val)).normalized);
		}
		if (colours != null)
		{
			colours.Add(Color32.Lerp(srcMesh.colours[i0], srcMesh.colours[i1], weight));
		}
		if (uvs != null)
		{
			uvs.Add(Vector2.Lerp(srcMesh.uvs[i0], srcMesh.uvs[i1], weight));
		}
		if (uv1s != null)
		{
			uv1s.Add(Vector2.Lerp(srcMesh.uv1s[i0], srcMesh.uv1s[i1], weight));
		}
	}

	public void AddTo(List<Vector3> destVertices, List<Vector3> destNormals, List<Color32> destColours, List<Vector2> destUvs, List<Vector2> destUv1s)
	{
		destVertices.AddRange(vertices);
		if (normals != null)
		{
			destNormals.AddRange(normals);
		}
		if (colours != null)
		{
			destColours.AddRange(colours);
		}
		if (uvs != null)
		{
			destUvs.AddRange(uvs);
		}
		if (uv1s != null)
		{
			destUv1s.AddRange(uv1s);
		}
	}

	public int NumIndices()
	{
		return vertices.Count;
	}

	public int[] GenIndices()
	{
		int[] array = new int[vertices.Count];
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = i;
		}
		return array;
	}
}
public enum VertexClassification
{
	Front = 1,
	Back = 2,
	OnPlane = 4
}
public class MeshCutter
{
	private CuttableMesh inputMesh;

	private List<CuttableSubMesh> outputFrontSubMeshes;

	private List<CuttableSubMesh> outputBackSubMeshes;

	public void Cut(CuttableMesh input, Plane worldCutPlane)
	{
		//IL_0067: 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_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: 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_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: 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_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		inputMesh = input;
		outputFrontSubMeshes = new List<CuttableSubMesh>();
		outputBackSubMeshes = new List<CuttableSubMesh>();
		Transform transform = inputMesh.GetTransform();
		Plane cutPlane = default(Plane);
		if ((Object)(object)transform != (Object)null)
		{
			Vector3 val = transform.InverseTransformPoint(ClosestPointOnPlane(worldCutPlane, Vector3.zero));
			Vector3 val2 = transform.InverseTransformDirection(((Plane)(ref worldCutPlane)).normal);
			((Plane)(ref cutPlane))..ctor(val2, val);
		}
		else
		{
			cutPlane = worldCutPlane;
		}
		foreach (CuttableSubMesh subMesh in input.GetSubMeshes())
		{
			Cut(subMesh, cutPlane);
		}
	}

	private static Vector3 ClosestPointOnPlane(Plane plane, Vector3 point)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: 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)
		//IL_0045: 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_001b: 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)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		float distanceToPoint = ((Plane)(ref plane)).GetDistanceToPoint(point);
		if (((Plane)(ref plane)).GetSide(point))
		{
			return point - ((Plane)(ref plane)).normal * distanceToPoint;
		}
		return point + ((Plane)(ref plane)).normal * distanceToPoint;
	}

	public CuttableMesh GetFrontOutput()
	{
		return new CuttableMesh(inputMesh, outputFrontSubMeshes);
	}

	public CuttableMesh GetBackOutput()
	{
		return new CuttableMesh(inputMesh, outputBackSubMeshes);
	}

	private void Cut(CuttableSubMesh inputSubMesh, Plane cutPlane)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: 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_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: 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_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: 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_0081: 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_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: 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_02be: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c2: 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_02c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d2: 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_02d6: 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_02dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02df: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: 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_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_0261: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		bool hasNormals = inputSubMesh.HasNormals();
		bool hasColours = inputSubMesh.HasColours();
		bool hasUvs = inputSubMesh.HasUvs();
		bool hasUv = inputSubMesh.HasUv1();
		CuttableSubMesh cuttableSubMesh = new CuttableSubMesh(hasNormals, hasColours, hasUvs, hasUv);
		CuttableSubMesh cuttableSubMesh2 = new CuttableSubMesh(hasNormals, hasColours, hasUvs, hasUv);
		for (int i = 0; i < inputSubMesh.NumVertices(); i += 3)
		{
			int num = i;
			int num2 = i + 1;
			int num3 = i + 2;
			Vector3 vertex = inputSubMesh.GetVertex(num);
			Vector3 vertex2 = inputSubMesh.GetVertex(num2);
			Vector3 vertex3 = inputSubMesh.GetVertex(num3);
			VertexClassification vertexClassification = Classify(vertex, cutPlane);
			VertexClassification vertexClassification2 = Classify(vertex2, cutPlane);
			VertexClassification vertexClassification3 = Classify(vertex3, cutPlane);
			int numFront = 0;
			int numBehind = 0;
			CountSides(vertexClassification, ref numFront, ref numBehind);
			CountSides(vertexClassification2, ref numFront, ref numBehind);
			CountSides(vertexClassification3, ref numFront, ref numBehind);
			if (numFront > 0 && numBehind == 0)
			{
				KeepTriangle(num, num2, num3, inputSubMesh, cuttableSubMesh);
			}
			else if (numFront == 0 && numBehind > 0)
			{
				KeepTriangle(num, num2, num3, inputSubMesh, cuttableSubMesh2);
			}
			else if (numFront == 2 && numBehind == 1)
			{
				if (vertexClassification == VertexClassification.Back)
				{
					SplitA(num, num2, num3, inputSubMesh, cutPlane, cuttableSubMesh2, cuttableSubMesh);
				}
				else if (vertexClassification2 == VertexClassification.Back)
				{
					SplitA(num2, num3, num, inputSubMesh, cutPlane, cuttableSubMesh2, cuttableSubMesh);
				}
				else
				{
					SplitA(num3, num, num2, inputSubMesh, cutPlane, cuttableSubMesh2, cuttableSubMesh);
				}
			}
			else if (numFront == 1 && numBehind == 2)
			{
				if (vertexClassification == VertexClassification.Front)
				{
					SplitA(num, num2, num3, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
				}
				else if (vertexClassification2 == VertexClassification.Front)
				{
					SplitA(num2, num3, num, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
				}
				else
				{
					SplitA(num3, num, num2, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
				}
			}
			else if (numFront == 1 && numBehind == 1)
			{
				if (vertexClassification == VertexClassification.OnPlane)
				{
					if (vertexClassification3 == VertexClassification.Front)
					{
						SplitB(num3, num, num2, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
					}
					else
					{
						SplitBFlipped(num2, num3, num, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
					}
					continue;
				}
				switch (vertexClassification2)
				{
				case VertexClassification.OnPlane:
					if (vertexClassification == VertexClassification.Front)
					{
						SplitB(num, num2, num3, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
					}
					else
					{
						SplitBFlipped(num3, num, num2, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
					}
					break;
				case VertexClassification.Front:
					SplitB(num2, num3, num, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
					break;
				default:
					SplitBFlipped(num, num2, num3, inputSubMesh, cutPlane, cuttableSubMesh, cuttableSubMesh2);
					break;
				}
			}
			else if (numFront == 0 && numBehind == 0)
			{
				Vector3 val = vertex2 - vertex;
				Vector3 val2 = vertex3 - vertex;
				Vector3 val3 = Vector3.Cross(val, val2);
				if (Vector3.Dot(val3, ((Plane)(ref cutPlane)).normal) > 0f)
				{
					KeepTriangle(num, num2, num3, inputSubMesh, cuttableSubMesh2);
				}
				else
				{
					KeepTriangle(num, num2, num3, inputSubMesh, cuttableSubMesh);
				}
			}
		}
		outputFrontSubMeshes.Add(cuttableSubMesh);
		outputBackSubMeshes.Add(cuttableSubMesh2);
	}

	private VertexClassification Classify(Vector3 vertex, Plane cutPlane)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(vertex.x, vertex.y, vertex.z);
		float distanceToPoint = ((Plane)(ref cutPlane)).GetDistanceToPoint(val);
		double num = 9.999999747378752E-06;
		if ((double)distanceToPoint > 0.0 - num && (double)distanceToPoint < num)
		{
			return VertexClassification.OnPlane;
		}
		if (distanceToPoint > 0f)
		{
			return VertexClassification.Front;
		}
		return VertexClassification.Back;
	}

	private void CountSides(VertexClassification c, ref int numFront, ref int numBehind)
	{
		switch (c)
		{
		case VertexClassification.Front:
			numFront++;
			break;
		case VertexClassification.Back:
			numBehind++;
			break;
		}
	}

	private void KeepTriangle(int i0, int i1, int i2, CuttableSubMesh inputSubMesh, CuttableSubMesh destSubMesh)
	{
		destSubMesh.CopyVertex(i0, inputSubMesh);
		destSubMesh.CopyVertex(i1, inputSubMesh);
		destSubMesh.CopyVertex(i2, inputSubMesh);
	}

	private void SplitA(int i0, int i1, int i2, CuttableSubMesh inputSubMesh, Plane cutPlane, CuttableSubMesh frontSubMesh, CuttableSubMesh backSubMesh)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: 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_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: 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)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: 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_0030: Unknown result type (might be due to invalid IL or missing references)
		Vector3 vertex = inputSubMesh.GetVertex(i0);
		Vector3 vertex2 = inputSubMesh.GetVertex(i1);
		Vector3 vertex3 = inputSubMesh.GetVertex(i2);
		CalcIntersection(vertex, vertex2, cutPlane, out var weight);
		CalcIntersection(vertex3, vertex, cutPlane, out var weight2);
		frontSubMesh.CopyVertex(i0, inputSubMesh);
		frontSubMesh.AddInterpolatedVertex(i0, i1, weight, inputSubMesh);
		frontSubMesh.AddInterpolatedVertex(i2, i0, weight2, inputSubMesh);
		backSubMesh.AddInterpolatedVertex(i0, i1, weight, inputSubMesh);
		backSubMesh.CopyVertex(i1, inputSubMesh);
		backSubMesh.CopyVertex(i2, inputSubMesh);
		backSubMesh.CopyVertex(i2, inputSubMesh);
		backSubMesh.AddInterpolatedVertex(i2, i0, weight2, inputSubMesh);
		backSubMesh.AddInterpolatedVertex(i0, i1, weight, inputSubMesh);
	}

	private void SplitB(int i0, int i1, int i2, CuttableSubMesh inputSubMesh, Plane cutPlane, CuttableSubMesh frontSubMesh, CuttableSubMesh backSubMesh)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: 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_001a: Unknown result type (might be due to invalid IL or missing references)
		Vector3 vertex = inputSubMesh.GetVertex(i0);
		Vector3 vertex2 = inputSubMesh.GetVertex(i2);
		CalcIntersection(vertex2, vertex, cutPlane, out var weight);
		frontSubMesh.CopyVertex(i0, inputSubMesh);
		frontSubMesh.CopyVertex(i1, inputSubMesh);
		frontSubMesh.AddInterpolatedVertex(i2, i0, weight, inputSubMesh);
		backSubMesh.CopyVertex(i1, inputSubMesh);
		backSubMesh.CopyVertex(i2, inputSubMesh);
		backSubMesh.AddInterpolatedVertex(i2, i0, weight, inputSubMesh);
	}

	private void SplitBFlipped(int i0, int i1, int i2, CuttableSubMesh inputSubMesh, Plane cutPlane, CuttableSubMesh frontSubMesh, CuttableSubMesh backSubMesh)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: 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_001a: Unknown result type (might be due to invalid IL or missing references)
		Vector3 vertex = inputSubMesh.GetVertex(i0);
		Vector3 vertex2 = inputSubMesh.GetVertex(i1);
		CalcIntersection(vertex, vertex2, cutPlane, out var weight);
		frontSubMesh.CopyVertex(i0, inputSubMesh);
		frontSubMesh.AddInterpolatedVertex(i0, i1, weight, inputSubMesh);
		frontSubMesh.CopyVertex(i2, inputSubMesh);
		backSubMesh.CopyVertex(i1, inputSubMesh);
		backSubMesh.CopyVertex(i2, inputSubMesh);
		backSubMesh.AddInterpolatedVertex(i0, i1, weight, inputSubMesh);
	}

	private Vector3 CalcIntersection(Vector3 v0, Vector3 v1, Plane plane, out float weight)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: 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_0022: 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_0034: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: 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_0055: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = v1 - v0;
		float magnitude = ((Vector3)(ref val)).magnitude;
		Ray val2 = default(Ray);
		((Ray)(ref val2))..ctor(v0, val / magnitude);
		float num = default(float);
		((Plane)(ref plane)).Raycast(val2, ref num);
		Vector3 result = ((Ray)(ref val2)).origin + ((Ray)(ref val2)).direction * num;
		weight = num / magnitude;
		return result;
	}
}