using System;
using System.Collections;
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 System.Text;
using System.Xml;
using System.Xml.Serialization;
using Atlas;
using Atlas.MappingComponents.Sandbox;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
using Sodalite.Api;
using Sodalite.Utilities;
using Technie.PhysicsCreator.QHull;
using UnityEditor;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
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 MeatKit
{
	public class HideInNormalInspectorAttribute : PropertyAttribute
	{
	}
}
namespace Danny.Payload_Sample
{
	[BepInPlugin("Danny.Payload_Sample", "Payload_Sample", "1.0.0")]
	[BepInProcess("h3vr.exe")]
	[Description("Built with MeatKit")]
	[BepInDependency("nrgill28.Atlas", "1.0.1")]
	public class Payload_SamplePlugin : 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(), "Danny.Payload_Sample");
			AtlasPlugin.RegisterScene(Path.Combine(BasePath, "payload example scene"));
		}
	}
}
[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
public class MeshCombiner : MonoBehaviour
{
	private const int Mesh16BitBufferVertexLimit = 65535;

	[SerializeField]
	private bool createMultiMaterialMesh = false;

	[SerializeField]
	private bool combineInactiveChildren = false;

	[SerializeField]
	private bool deactivateCombinedChildren = true;

	[SerializeField]
	private bool deactivateCombinedChildrenMeshRenderers = false;

	[SerializeField]
	private bool generateUVMap = false;

	[SerializeField]
	private bool destroyCombinedChildren = false;

	[SerializeField]
	private string folderPath = "Prefabs/CombinedMeshes";

	[SerializeField]
	[Tooltip("MeshFilters with Meshes which we don't want to combine into one Mesh.")]
	private MeshFilter[] meshFiltersToSkip = (MeshFilter[])(object)new MeshFilter[0];

	public bool CreateMultiMaterialMesh
	{
		get
		{
			return createMultiMaterialMesh;
		}
		set
		{
			createMultiMaterialMesh = value;
		}
	}

	public bool CombineInactiveChildren
	{
		get
		{
			return combineInactiveChildren;
		}
		set
		{
			combineInactiveChildren = value;
		}
	}

	public bool DeactivateCombinedChildren
	{
		get
		{
			return deactivateCombinedChildren;
		}
		set
		{
			deactivateCombinedChildren = value;
			CheckDeactivateCombinedChildren();
		}
	}

	public bool DeactivateCombinedChildrenMeshRenderers
	{
		get
		{
			return deactivateCombinedChildrenMeshRenderers;
		}
		set
		{
			deactivateCombinedChildrenMeshRenderers = value;
			CheckDeactivateCombinedChildren();
		}
	}

	public bool GenerateUVMap
	{
		get
		{
			return generateUVMap;
		}
		set
		{
			generateUVMap = value;
		}
	}

	public bool DestroyCombinedChildren
	{
		get
		{
			return destroyCombinedChildren;
		}
		set
		{
			destroyCombinedChildren = value;
			CheckDestroyCombinedChildren();
		}
	}

	public string FolderPath
	{
		get
		{
			return folderPath;
		}
		set
		{
			folderPath = value;
		}
	}

	private void CheckDeactivateCombinedChildren()
	{
		if (deactivateCombinedChildren || deactivateCombinedChildrenMeshRenderers)
		{
			destroyCombinedChildren = false;
		}
	}

	private void CheckDestroyCombinedChildren()
	{
		if (destroyCombinedChildren)
		{
			deactivateCombinedChildren = false;
			deactivateCombinedChildrenMeshRenderers = false;
		}
	}

	public void CombineMeshes(bool showCreatedMeshInfo)
	{
		//IL_0007: 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_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: 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_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_005d: 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_007d: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		Vector3 localScale = ((Component)this).transform.localScale;
		int siblingIndex = ((Component)this).transform.GetSiblingIndex();
		Transform parent = ((Component)this).transform.parent;
		((Component)this).transform.parent = null;
		Quaternion rotation = ((Component)this).transform.rotation;
		Vector3 position = ((Component)this).transform.position;
		Vector3 localScale2 = ((Component)this).transform.localScale;
		((Component)this).transform.rotation = Quaternion.identity;
		((Component)this).transform.position = Vector3.zero;
		((Component)this).transform.localScale = Vector3.one;
		if (!createMultiMaterialMesh)
		{
			CombineMeshesWithSingleMaterial(showCreatedMeshInfo);
		}
		else
		{
			CombineMeshesWithMutliMaterial(showCreatedMeshInfo);
		}
		((Component)this).transform.rotation = rotation;
		((Component)this).transform.position = position;
		((Component)this).transform.localScale = localScale2;
		((Component)this).transform.parent = parent;
		((Component)this).transform.SetSiblingIndex(siblingIndex);
		((Component)this).transform.localScale = localScale;
	}

	private MeshFilter[] GetMeshFiltersToCombine()
	{
		MeshFilter[] meshFilters = ((Component)this).GetComponentsInChildren<MeshFilter>(combineInactiveChildren);
		meshFiltersToSkip = meshFiltersToSkip.Where((MeshFilter meshFilter) => (Object)(object)meshFilter != (Object)(object)meshFilters[0]).ToArray();
		meshFiltersToSkip = meshFiltersToSkip.Where((MeshFilter meshFilter) => (Object)(object)meshFilter != (Object)null).ToArray();
		for (int i = 0; i < meshFiltersToSkip.Length; i++)
		{
			meshFilters = meshFilters.Where((MeshFilter meshFilter) => (Object)(object)meshFilter != (Object)(object)meshFiltersToSkip[i]).ToArray();
		}
		return meshFilters;
	}

	private void CombineMeshesWithSingleMaterial(bool showCreatedMeshInfo)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Expected O, but got Unknown
		MeshFilter[] meshFiltersToCombine = GetMeshFiltersToCombine();
		CombineInstance[] array = (CombineInstance[])(object)new CombineInstance[meshFiltersToCombine.Length - 1];
		long num = 0L;
		for (int i = 0; i < meshFiltersToCombine.Length - 1; i++)
		{
			((CombineInstance)(ref array[i])).subMeshIndex = 0;
			((CombineInstance)(ref array[i])).mesh = meshFiltersToCombine[i + 1].sharedMesh;
			((CombineInstance)(ref array[i])).transform = ((Component)meshFiltersToCombine[i + 1]).transform.localToWorldMatrix;
			num += ((CombineInstance)(ref array[i])).mesh.vertices.Length;
		}
		MeshRenderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<MeshRenderer>(combineInactiveChildren);
		if (componentsInChildren.Length >= 2)
		{
			((Renderer)componentsInChildren[0]).sharedMaterials = (Material[])(object)new Material[1];
			((Renderer)componentsInChildren[0]).sharedMaterial = ((Renderer)componentsInChildren[1]).sharedMaterial;
		}
		else
		{
			((Renderer)componentsInChildren[0]).sharedMaterials = (Material[])(object)new Material[0];
		}
		Mesh val = new Mesh();
		((Object)val).name = ((Object)this).name;
		if (num <= 65535)
		{
			val.CombineMeshes(array);
			GenerateUV(val);
			meshFiltersToCombine[0].sharedMesh = val;
			DeactivateCombinedGameObjects(meshFiltersToCombine);
			if (showCreatedMeshInfo)
			{
				Debug.Log((object)("<color=#00cc00><b>Mesh \"" + ((Object)this).name + "\" was created from " + array.Length + " children meshes and has " + num + " vertices.</b></color>"));
			}
		}
		else if (showCreatedMeshInfo)
		{
			Debug.Log((object)("<color=red><b>The mesh vertex limit is 65535! The created mesh had " + num + " vertices. Upgrade Unity version to 2017.3 or higher to avoid this limit (some old devices, like Android with Mali-400 GPU, do not support over 65535 vertices).</b></color>"));
		}
	}

	private void CombineMeshesWithMutliMaterial(bool showCreatedMeshInfo)
	{
		//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fb: Expected O, but got Unknown
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0186: Expected O, but got Unknown
		//IL_01a6: 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_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		MeshFilter[] meshFiltersToCombine = GetMeshFiltersToCombine();
		MeshRenderer[] array = (MeshRenderer[])(object)new MeshRenderer[meshFiltersToCombine.Length];
		array[0] = ((Component)this).GetComponent<MeshRenderer>();
		List<Material> list = new List<Material>();
		for (int i = 0; i < meshFiltersToCombine.Length - 1; i++)
		{
			array[i + 1] = ((Component)meshFiltersToCombine[i + 1]).GetComponent<MeshRenderer>();
			if (!((Object)(object)array[i + 1] != (Object)null))
			{
				continue;
			}
			Material[] sharedMaterials = ((Renderer)array[i + 1]).sharedMaterials;
			for (int j = 0; j < sharedMaterials.Length; j++)
			{
				if (!list.Contains(sharedMaterials[j]))
				{
					list.Add(sharedMaterials[j]);
				}
			}
		}
		List<CombineInstance> list2 = new List<CombineInstance>();
		long num = 0L;
		for (int k = 0; k < list.Count; k++)
		{
			List<CombineInstance> list3 = new List<CombineInstance>();
			for (int l = 0; l < meshFiltersToCombine.Length - 1; l++)
			{
				if (!((Object)(object)array[l + 1] != (Object)null))
				{
					continue;
				}
				Material[] sharedMaterials2 = ((Renderer)array[l + 1]).sharedMaterials;
				for (int m = 0; m < sharedMaterials2.Length; m++)
				{
					if ((Object)(object)list[k] == (Object)(object)sharedMaterials2[m])
					{
						CombineInstance item = default(CombineInstance);
						((CombineInstance)(ref item)).subMeshIndex = m;
						((CombineInstance)(ref item)).mesh = meshFiltersToCombine[l + 1].sharedMesh;
						((CombineInstance)(ref item)).transform = ((Component)meshFiltersToCombine[l + 1]).transform.localToWorldMatrix;
						list3.Add(item);
						num += ((CombineInstance)(ref item)).mesh.vertices.Length;
					}
				}
			}
			Mesh val = new Mesh();
			if (num <= 65535)
			{
				val.CombineMeshes(list3.ToArray(), true);
			}
			CombineInstance item2 = default(CombineInstance);
			((CombineInstance)(ref item2)).subMeshIndex = 0;
			((CombineInstance)(ref item2)).mesh = val;
			((CombineInstance)(ref item2)).transform = Matrix4x4.identity;
			list2.Add(item2);
		}
		((Renderer)array[0]).sharedMaterials = list.ToArray();
		Mesh val2 = new Mesh();
		((Object)val2).name = ((Object)this).name;
		if (num <= 65535)
		{
			val2.CombineMeshes(list2.ToArray(), false);
			GenerateUV(val2);
			meshFiltersToCombine[0].sharedMesh = val2;
			DeactivateCombinedGameObjects(meshFiltersToCombine);
			if (showCreatedMeshInfo)
			{
				Debug.Log((object)("<color=#00cc00><b>Mesh \"" + ((Object)this).name + "\" was created from " + (meshFiltersToCombine.Length - 1) + " children meshes and has " + list2.Count + " submeshes, and " + num + " vertices.</b></color>"));
			}
		}
		else if (showCreatedMeshInfo)
		{
			Debug.Log((object)("<color=red><b>The mesh vertex limit is 65535! The created mesh had " + num + " vertices. Upgrade Unity version to 2017.3 or higher to avoid this limit (some old devices, like Android with Mali-400 GPU, do not support over 65535 vertices).</b></color>"));
		}
	}

	private void DeactivateCombinedGameObjects(MeshFilter[] meshFilters)
	{
		for (int i = 0; i < meshFilters.Length - 1; i++)
		{
			if (!destroyCombinedChildren)
			{
				if (deactivateCombinedChildren)
				{
					((Component)meshFilters[i + 1]).gameObject.SetActive(false);
				}
				if (deactivateCombinedChildrenMeshRenderers)
				{
					MeshRenderer component = ((Component)meshFilters[i + 1]).gameObject.GetComponent<MeshRenderer>();
					if ((Object)(object)component != (Object)null)
					{
						((Renderer)component).enabled = false;
					}
				}
			}
			else
			{
				Object.DestroyImmediate((Object)(object)((Component)meshFilters[i + 1]).gameObject);
			}
		}
	}

	private void GenerateUV(Mesh combinedMesh)
	{
		//IL_000f: 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)
		if (generateUVMap)
		{
			UnwrapParam val = default(UnwrapParam);
			UnwrapParam.SetDefaults(ref val);
			Unwrapping.GenerateSecondaryUVSet(combinedMesh, val);
		}
	}
}
namespace SimpleLightProbePlacer
{
	[RequireComponent(typeof(LightProbeGroup))]
	[AddComponentMenu("Rendering/Light Probe Group Control")]
	public class LightProbeGroupControl : MonoBehaviour
	{
		[SerializeField]
		private float m_mergeDistance = 0.5f;

		[SerializeField]
		private bool m_usePointLights = true;

		[SerializeField]
		private float m_pointLightRange = 1f;

		private int m_mergedProbes;

		private LightProbeGroup m_lightProbeGroup;

		public float MergeDistance
		{
			get
			{
				return m_mergeDistance;
			}
			set
			{
				m_mergeDistance = value;
			}
		}

		public int MergedProbes => m_mergedProbes;

		public bool UsePointLights
		{
			get
			{
				return m_usePointLights;
			}
			set
			{
				m_usePointLights = value;
			}
		}

		public float PointLightRange
		{
			get
			{
				return m_pointLightRange;
			}
			set
			{
				m_pointLightRange = value;
			}
		}

		public LightProbeGroup LightProbeGroup
		{
			get
			{
				if ((Object)(object)m_lightProbeGroup != (Object)null)
				{
					return m_lightProbeGroup;
				}
				return m_lightProbeGroup = ((Component)this).GetComponent<LightProbeGroup>();
			}
		}

		public void DeleteAll()
		{
			LightProbeGroup.probePositions = null;
			m_mergedProbes = 0;
		}

		public void Create()
		{
			DeleteAll();
			List<Vector3> list = CreatePositions();
			list.AddRange(CreateAroundPointLights(m_pointLightRange));
			list = MergeClosestPositions(list, m_mergeDistance, out m_mergedProbes);
			ApplyPositions(list);
		}

		public void Merge()
		{
			if (LightProbeGroup.probePositions != null)
			{
				List<Vector3> source = MergeClosestPositions(LightProbeGroup.probePositions.ToList(), m_mergeDistance, out m_mergedProbes);
				source = source.Select((Vector3 x) => ((Component)this).transform.TransformPoint(x)).ToList();
				ApplyPositions(source);
			}
		}

		private void ApplyPositions(List<Vector3> positions)
		{
			LightProbeGroup.probePositions = positions.Select((Vector3 x) => ((Component)this).transform.InverseTransformPoint(x)).ToArray();
		}

		private static List<Vector3> CreatePositions()
		{
			LightProbeVolume[] array = Object.FindObjectsOfType<LightProbeVolume>();
			if (array.Length == 0)
			{
				return new List<Vector3>();
			}
			List<Vector3> list = new List<Vector3>();
			for (int i = 0; i < array.Length; i++)
			{
				list.AddRange(array[i].CreatePositions());
			}
			return list;
		}

		private static List<Vector3> CreateAroundPointLights(float range)
		{
			List<Light> list = (from x in Object.FindObjectsOfType<Light>()
				where (int)x.type == 2
				select x).ToList();
			if (list.Count == 0)
			{
				return new List<Vector3>();
			}
			List<Vector3> list2 = new List<Vector3>();
			for (int i = 0; i < list.Count; i++)
			{
				list2.AddRange(CreatePositionsAround(((Component)list[i]).transform, range));
			}
			return list2;
		}

		private static List<Vector3> MergeClosestPositions(List<Vector3> positions, float distance, out int mergedCount)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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)
			if (positions == null)
			{
				mergedCount = 0;
				return new List<Vector3>();
			}
			int count = positions.Count;
			bool flag = false;
			while (!flag)
			{
				Dictionary<Vector3, List<Vector3>> dictionary = new Dictionary<Vector3, List<Vector3>>();
				for (int i = 0; i < positions.Count; i++)
				{
					List<Vector3> list = positions.Where(delegate(Vector3 x)
					{
						//IL_0000: 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_0017: 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)
						Vector3 val2 = x - positions[i];
						return ((Vector3)(ref val2)).magnitude < distance;
					}).ToList();
					if (list.Count > 0 && !dictionary.ContainsKey(positions[i]))
					{
						dictionary.Add(positions[i], list);
					}
				}
				positions.Clear();
				List<Vector3> list2 = dictionary.Keys.ToList();
				for (int j = 0; j < list2.Count; j++)
				{
					Vector3 center = dictionary[list2[j]].Aggregate(Vector3.zero, (Vector3 result, Vector3 target) => result + target) / (float)dictionary[list2[j]].Count;
					if (!positions.Exists((Vector3 x) => x == center))
					{
						positions.Add(center);
					}
				}
				flag = positions.Select((Vector3 x) => positions.Where(delegate(Vector3 y)
				{
					//IL_0000: 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_0011: 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_0018: Unknown result type (might be due to invalid IL or missing references)
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					int result2;
					if (y != x)
					{
						Vector3 val = y - x;
						result2 = ((((Vector3)(ref val)).magnitude < distance) ? 1 : 0);
					}
					else
					{
						result2 = 0;
					}
					return (byte)result2 != 0;
				})).All((IEnumerable<Vector3> x) => !x.Any());
			}
			mergedCount = count - positions.Count;
			return positions;
		}

		public static List<Vector3> CreatePositionsAround(Transform transform, float range)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00f1: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] source = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(-0.5f, 0.5f, -0.5f),
				new Vector3(-0.5f, 0.5f, 0.5f),
				new Vector3(0.5f, 0.5f, 0.5f),
				new Vector3(0.5f, 0.5f, -0.5f),
				new Vector3(-0.5f, -0.5f, -0.5f),
				new Vector3(-0.5f, -0.5f, 0.5f),
				new Vector3(0.5f, -0.5f, 0.5f),
				new Vector3(0.5f, -0.5f, -0.5f)
			};
			return source.Select((Vector3 x) => transform.TransformPoint(x * range)).ToList();
		}
	}
	public enum LightProbeVolumeType
	{
		Fixed,
		Float
	}
	[AddComponentMenu("Rendering/Light Probe Volume")]
	public class LightProbeVolume : TransformVolume
	{
		[SerializeField]
		private LightProbeVolumeType m_type = LightProbeVolumeType.Fixed;

		[SerializeField]
		private Vector3 m_densityFixed = Vector3.one;

		[SerializeField]
		private Vector3 m_densityFloat = Vector3.one;

		public LightProbeVolumeType Type
		{
			get
			{
				return m_type;
			}
			set
			{
				m_type = value;
			}
		}

		public Vector3 Density
		{
			get
			{
				//IL_0018: 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_001d: 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)
				return (m_type != 0) ? m_densityFloat : m_densityFixed;
			}
			set
			{
				//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_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (m_type == LightProbeVolumeType.Fixed)
				{
					m_densityFixed = value;
				}
				else
				{
					m_densityFloat = value;
				}
			}
		}

		public static Color EditorColor => new Color(1f, 0.9f, 0.25f);

		public List<Vector3> CreatePositions()
		{
			return CreatePositions(m_type);
		}

		public List<Vector3> CreatePositions(LightProbeVolumeType type)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			return (type != 0) ? CreatePositionsFloat(((Component)this).transform, base.Origin, base.Size, Density) : CreatePositionsFixed(((Component)this).transform, base.Origin, base.Size, Density);
		}

		public static List<Vector3> CreatePositionsFixed(Transform volumeTransform, Vector3 origin, Vector3 size, Vector3 density)
		{
			//IL_0007: 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_004c: 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_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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Vector3 val = origin;
			float num = size.x / (float)Mathf.FloorToInt(density.x);
			float num2 = size.y / (float)Mathf.FloorToInt(density.y);
			float num3 = size.z / (float)Mathf.FloorToInt(density.z);
			val -= size * 0.5f;
			for (int i = 0; (float)i <= density.x; i++)
			{
				for (int j = 0; (float)j <= density.y; j++)
				{
					for (int k = 0; (float)k <= density.z; k++)
					{
						Vector3 val2 = val + new Vector3((float)i * num, (float)j * num2, (float)k * num3);
						val2 = volumeTransform.TransformPoint(val2);
						list.Add(val2);
					}
				}
			}
			return list;
		}

		public static List<Vector3> CreatePositionsFloat(Transform volumeTransform, Vector3 origin, Vector3 size, Vector3 density)
		{
			//IL_0007: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Vector3 val = origin;
			int num = Mathf.FloorToInt(size.x / density.x);
			int num2 = Mathf.FloorToInt(size.y / density.y);
			int num3 = Mathf.FloorToInt(size.z / density.z);
			val -= size * 0.5f;
			val.x += (size.x - (float)num * density.x) * 0.5f;
			val.y += (size.y - (float)num2 * density.y) * 0.5f;
			val.z += (size.z - (float)num3 * density.z) * 0.5f;
			for (int i = 0; i <= num; i++)
			{
				for (int j = 0; j <= num2; j++)
				{
					for (int k = 0; k <= num3; k++)
					{
						Vector3 val2 = val + new Vector3((float)i * density.x, (float)j * density.y, (float)k * density.z);
						val2 = volumeTransform.TransformPoint(val2);
						list.Add(val2);
					}
				}
			}
			return list;
		}
	}
	[AddComponentMenu("")]
	public class TransformVolume : MonoBehaviour
	{
		[SerializeField]
		private Volume m_volume = new Volume(Vector3.zero, Vector3.one);

		public Volume Volume
		{
			get
			{
				return m_volume;
			}
			set
			{
				m_volume = value;
			}
		}

		public Vector3 Origin => m_volume.Origin;

		public Vector3 Size => m_volume.Size;

		public bool IsInBounds(Vector3[] points)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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)
			Bounds bounds = GetBounds();
			return ((Bounds)(ref bounds)).Intersects(GetBounds(points));
		}

		public bool IsOnBorder(Vector3[] points)
		{
			if (points.All((Vector3 x) => !IsInVolume(x)))
			{
				return false;
			}
			return !points.All(IsInVolume);
		}

		public bool IsInVolume(Vector3[] points)
		{
			return points.All(IsInVolume);
		}

		public bool IsInVolume(Vector3 position)
		{
			//IL_000d: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			Plane val = default(Plane);
			for (int i = 0; i < 6; i++)
			{
				((Plane)(ref val))..ctor(GetSideDirection(i), GetSidePosition(i));
				if (((Plane)(ref val)).GetSide(position))
				{
					return false;
				}
			}
			return true;
		}

		public Vector3[] GetCorners()
		{
			//IL_001d: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0062: 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_0082: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(-0.5f, 0.5f, -0.5f),
				new Vector3(-0.5f, 0.5f, 0.5f),
				new Vector3(0.5f, 0.5f, 0.5f),
				new Vector3(0.5f, 0.5f, -0.5f),
				new Vector3(-0.5f, -0.5f, -0.5f),
				new Vector3(-0.5f, -0.5f, 0.5f),
				new Vector3(0.5f, -0.5f, 0.5f),
				new Vector3(0.5f, -0.5f, -0.5f)
			};
			for (int i = 0; i < array.Length; i++)
			{
				ref Vector3 reference = ref array[i];
				reference.x *= m_volume.Size.x;
				ref Vector3 reference2 = ref array[i];
				reference2.y *= m_volume.Size.y;
				ref Vector3 reference3 = ref array[i];
				reference3.z *= m_volume.Size.z;
				ref Vector3 reference4 = ref array[i];
				reference4 = ((Component)this).transform.TransformPoint(m_volume.Origin + array[i]);
			}
			return array;
		}

		public Bounds GetBounds()
		{
			//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 GetBounds(GetCorners());
		}

		public Bounds GetBounds(Vector3[] points)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = points.Aggregate(Vector3.zero, (Vector3 result, Vector3 point) => result + point) / (float)points.Length;
			Bounds result2 = default(Bounds);
			((Bounds)(ref result2))..ctor(val, Vector3.zero);
			for (int i = 0; i < points.Length; i++)
			{
				((Bounds)(ref result2)).Encapsulate(points[i]);
			}
			return result2;
		}

		public GameObject[] GetGameObjectsInBounds(LayerMask layerMask)
		{
			//IL_000e: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			MeshRenderer[] array = Object.FindObjectsOfType<MeshRenderer>();
			List<GameObject> list = new List<GameObject>();
			Bounds bounds = GetBounds();
			for (int i = 0; i < array.Length; i++)
			{
				if (!((Object)(object)((Component)array[i]).gameObject == (Object)(object)((Component)((Component)this).transform).gameObject) && !((Object)(object)((Component)array[i]).GetComponent<TransformVolume>() != (Object)null) && ((1 << ((Component)array[i]).gameObject.layer) & ((LayerMask)(ref layerMask)).value) != 0 && ((Bounds)(ref bounds)).Intersects(((Renderer)array[i]).bounds))
				{
					list.Add(((Component)array[i]).gameObject);
				}
			}
			return list.ToArray();
		}

		public Vector3 GetSideDirection(int side)
		{
			//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_000e: 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_0019: 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_0022: 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_002f: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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)
			Vector3[] array = (Vector3[])(object)new Vector3[6];
			Vector3 right = Vector3.right;
			Vector3 up = Vector3.up;
			Vector3 forward = Vector3.forward;
			array[0] = right;
			ref Vector3 reference = ref array[1];
			reference = -right;
			array[2] = up;
			ref Vector3 reference2 = ref array[3];
			reference2 = -up;
			array[4] = forward;
			ref Vector3 reference3 = ref array[5];
			reference3 = -forward;
			return ((Component)this).transform.TransformDirection(array[side]);
		}

		public Vector3 GetSidePosition(int side)
		{
			//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_000e: 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_0019: 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_0022: 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_002f: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[6];
			Vector3 right = Vector3.right;
			Vector3 up = Vector3.up;
			Vector3 forward = Vector3.forward;
			array[0] = right;
			ref Vector3 reference = ref array[1];
			reference = -right;
			array[2] = up;
			ref Vector3 reference2 = ref array[3];
			reference2 = -up;
			array[4] = forward;
			ref Vector3 reference3 = ref array[5];
			reference3 = -forward;
			return ((Component)this).transform.TransformPoint(array[side] * GetSizeAxis(side) + m_volume.Origin);
		}

		public float GetSizeAxis(int side)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			switch (side)
			{
			case 0:
			case 1:
				return m_volume.Size.x * 0.5f;
			case 2:
			case 3:
				return m_volume.Size.y * 0.5f;
			default:
				return m_volume.Size.z * 0.5f;
			}
		}

		public static Volume EditorVolumeControl(TransformVolume transformVolume, float handleSize, Color color)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0080: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//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_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: 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_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: 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_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			Vector3[] array = (Vector3[])(object)new Vector3[6];
			Transform transform = ((Component)transformVolume).transform;
			Handles.color = color;
			for (int i = 0; i < array.Length; i++)
			{
				ref Vector3 reference = ref array[i];
				reference = transformVolume.GetSidePosition(i);
			}
			ref Vector3 reference2 = ref array[0];
			reference2 = Handles.Slider(array[0], transform.right, handleSize, new CapFunction(Handles.DotHandleCap), 1f);
			ref Vector3 reference3 = ref array[1];
			reference3 = Handles.Slider(array[1], transform.right, handleSize, new CapFunction(Handles.DotHandleCap), 1f);
			ref Vector3 reference4 = ref array[2];
			reference4 = Handles.Slider(array[2], transform.up, handleSize, new CapFunction(Handles.DotHandleCap), 1f);
			ref Vector3 reference5 = ref array[3];
			reference5 = Handles.Slider(array[3], transform.up, handleSize, new CapFunction(Handles.DotHandleCap), 1f);
			ref Vector3 reference6 = ref array[4];
			reference6 = Handles.Slider(array[4], transform.forward, handleSize, new CapFunction(Handles.DotHandleCap), 1f);
			ref Vector3 reference7 = ref array[5];
			reference7 = Handles.Slider(array[5], transform.forward, handleSize, new CapFunction(Handles.DotHandleCap), 1f);
			Vector3 origin = default(Vector3);
			origin.x = transform.InverseTransformPoint((array[0] + array[1]) * 0.5f).x;
			origin.y = transform.InverseTransformPoint((array[2] + array[3]) * 0.5f).y;
			origin.z = transform.InverseTransformPoint((array[4] + array[5]) * 0.5f).z;
			Vector3 size = default(Vector3);
			size.x = transform.InverseTransformPoint(array[0]).x - transform.InverseTransformPoint(array[1]).x;
			size.y = transform.InverseTransformPoint(array[2]).y - transform.InverseTransformPoint(array[3]).y;
			size.z = transform.InverseTransformPoint(array[4]).z - transform.InverseTransformPoint(array[5]).z;
			return new Volume(origin, size);
		}
	}
	[Serializable]
	public struct Volume
	{
		[SerializeField]
		private Vector3 m_origin;

		[SerializeField]
		private Vector3 m_size;

		public Vector3 Origin => m_origin;

		public Vector3 Size => m_size;

		public Volume(Vector3 origin, Vector3 size)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			m_origin = origin;
			m_size = size;
		}

		public static bool operator ==(Volume left, Volume right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(Volume left, Volume right)
		{
			return !left.Equals(right);
		}

		public bool Equals(Volume other)
		{
			//IL_0002: 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_0019: 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)
			return Origin == other.Origin && Size == other.Size;
		}

		public override bool Equals(object obj)
		{
			if (object.ReferenceEquals(null, obj))
			{
				return false;
			}
			return obj is Volume && Equals((Volume)obj);
		}

		public override int GetHashCode()
		{
			//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_001d: 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)
			Vector3 origin = Origin;
			int num = ((object)(Vector3)(ref origin)).GetHashCode() * 397;
			Vector3 size = Size;
			return num ^ ((object)(Vector3)(ref size)).GetHashCode();
		}

		public override string ToString()
		{
			//IL_0007: 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)
			return $"Origin: {Origin}, Size: {Size}";
		}
	}
}
namespace nrgill28.AtlasSampleScene
{
	public class CTF_CaptureZone : MonoBehaviour
	{
		public CTF_Manager Manager;

		public CTF_Team Team;

		public void OnTriggerEnter(Collider other)
		{
			CTF_Flag component = ((Component)other).GetComponent<CTF_Flag>();
			if (Object.op_Implicit((Object)(object)component) && component.Team != Team)
			{
				Manager.FlagCaptured(component);
			}
		}
	}
	public class CTF_Flag : FVRPhysicalObject
	{
		[Header("Flag stuffs")]
		public CTF_Team Team;

		public float RespawnDelay = 10f;

		public Vector3 FloorOffset = new Vector3(0f, 0.25f, 0f);

		private Vector3 _resetPosition;

		private Quaternion _resetRotation;

		private Transform _followTransform;

		private bool _isHeld;

		private bool _isTaken;

		private float _timer;

		private CTF_Sosig _heldBy;

		public override void Awake()
		{
			//IL_000e: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			((FVRPhysicalObject)this).Awake();
			_resetPosition = ((Component)this).transform.position;
			_resetRotation = ((Component)this).transform.rotation;
		}

		private void Update()
		{
			if (_isTaken && !_isHeld)
			{
				_timer -= Time.deltaTime;
				if (_timer < 0f)
				{
					ReturnFlag();
				}
			}
		}

		public void Take()
		{
			_isHeld = true;
			_isTaken = true;
		}

		public void Drop()
		{
			//IL_001a: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			((FVRInteractiveObject)this).IsHeld = false;
			_timer = RespawnDelay;
			NavMeshHit val = default(NavMeshHit);
			NavMesh.SamplePosition(((Component)this).transform.position, ref val, 100f, -1);
			((Component)this).transform.position = ((NavMeshHit)(ref val)).position + FloorOffset;
			((Component)this).transform.rotation = Quaternion.identity;
		}

		public void ReturnFlag()
		{
			//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)
			if (((FVRInteractiveObject)this).IsHeld)
			{
				((FVRInteractiveObject)this).ForceBreakInteraction();
			}
			if (Object.op_Implicit((Object)(object)_heldBy))
			{
				_heldBy.HeldFlag = null;
			}
			((Component)this).transform.SetPositionAndRotation(_resetPosition, _resetRotation);
			_isTaken = false;
		}

		private void OnTriggerEnter(Collider other)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (_isHeld)
			{
				return;
			}
			CTF_Sosig componentInParent = ((Component)other).GetComponentInParent<CTF_Sosig>();
			if (Object.op_Implicit((Object)(object)componentInParent) && (int)componentInParent.Sosig.BodyState == 0)
			{
				if (componentInParent.Team == Team)
				{
					ReturnFlag();
					return;
				}
				_heldBy = componentInParent;
				componentInParent.HeldFlag = this;
				Take();
			}
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			((FVRPhysicalObject)this).BeginInteraction(hand);
			Take();
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			((FVRPhysicalObject)this).EndInteraction(hand);
			Drop();
		}
	}
	public class CTF_Manager : MonoBehaviour
	{
		[Header("References")]
		public Text[] ScoreTexts;

		public Transform[] AttackPoints;

		public Text StartButtonText;

		[Header("Red Team")]
		public CTF_Flag RedFlag;

		public int RedTeamSize;

		public Transform[] RedSpawns;

		public SosigEnemyID[] RedTeam;

		[Header("Blue Team")]
		public CTF_Flag BlueFlag;

		public int BlueTeamSize;

		public Transform[] BlueSpawns;

		public SosigEnemyID[] BlueTeam;

		private int _blueScore;

		private int _redScore;

		private bool _running;

		private readonly List<CTF_Sosig> _sosigs = new List<CTF_Sosig>();

		private readonly SpawnOptions _spawnOptions;

		public CTF_Manager()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			SpawnOptions val = new SpawnOptions();
			val.SpawnState = (SosigOrder)7;
			val.SpawnActivated = true;
			val.EquipmentMode = (EquipmentSlots)7;
			val.SpawnWithFullAmmo = true;
			_spawnOptions = val;
			((MonoBehaviour)this)..ctor();
		}

		private void Start()
		{
			UpdateScoreText();
		}

		public void ToggleGame()
		{
			if (_running)
			{
				EndGame();
				StartButtonText.text = "Start Game";
			}
			else
			{
				StartGame();
				StartButtonText.text = "Stop Game";
			}
		}

		private void StartGame()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			ResetGame();
			_running = true;
			GM.CurrentSceneSettings.SosigKillEvent += new SosigKill(CurrentSceneSettingsOnSosigKillEvent);
			((MonoBehaviour)this).StartCoroutine(DoInitialSpawns());
		}

		private void EndGame()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			GM.CurrentSceneSettings.SosigKillEvent -= new SosigKill(CurrentSceneSettingsOnSosigKillEvent);
			foreach (CTF_Sosig sosig in _sosigs)
			{
				sosig.Sosig.ClearSosig();
			}
			_running = false;
		}

		private void CurrentSceneSettingsOnSosigKillEvent(Sosig s)
		{
			CTF_Sosig cTF_Sosig = _sosigs.FirstOrDefault((CTF_Sosig x) => (Object)(object)x.Sosig == (Object)(object)s);
			if (Object.op_Implicit((Object)(object)cTF_Sosig))
			{
				((MonoBehaviour)this).StartCoroutine(RespawnSosig(cTF_Sosig));
			}
		}

		private void SpawnSosig(CTF_Team team)
		{
			//IL_001e: 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_0046: 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)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			_spawnOptions.IFF = (int)team;
			_spawnOptions.SosigTargetPosition = SodaliteUtils.GetRandom<Transform>((IList<Transform>)AttackPoints).position;
			Transform transform;
			SosigEnemyID random;
			if (team == CTF_Team.Red)
			{
				transform = ((Component)SodaliteUtils.GetRandom<Transform>((IList<Transform>)RedSpawns)).transform;
				random = SodaliteUtils.GetRandom<SosigEnemyID>((IList<SosigEnemyID>)RedTeam);
			}
			else
			{
				transform = ((Component)SodaliteUtils.GetRandom<Transform>((IList<Transform>)BlueSpawns)).transform;
				random = SodaliteUtils.GetRandom<SosigEnemyID>((IList<SosigEnemyID>)BlueTeam);
			}
			Sosig val = SosigAPI.Spawn(ManagerSingleton<IM>.Instance.odicSosigObjsByID[random], _spawnOptions, transform.position, transform.rotation);
			CTF_Sosig cTF_Sosig = ((Component)val).gameObject.AddComponent<CTF_Sosig>();
			_sosigs.Add(cTF_Sosig);
			cTF_Sosig.Sosig = val;
			cTF_Sosig.Team = team;
		}

		private IEnumerator DoInitialSpawns()
		{
			int i = 0;
			while (i < Mathf.Max(RedTeamSize, BlueTeamSize))
			{
				if (i < RedTeamSize)
				{
					SpawnSosig(CTF_Team.Red);
				}
				if (i < BlueTeamSize)
				{
					SpawnSosig(CTF_Team.Blue);
				}
				i++;
				yield return (object)new WaitForSeconds(2.5f);
			}
		}

		private IEnumerator RespawnSosig(CTF_Sosig sosig)
		{
			yield return (object)new WaitForSeconds(5f);
			sosig.Sosig.ClearSosig();
			_sosigs.Remove(sosig);
			yield return (object)new WaitForSeconds(5f);
			if (_running)
			{
				int sosigsLeft = _sosigs.Count((CTF_Sosig x) => x.Team == sosig.Team);
				int teamSize = ((sosig.Team != 0) ? BlueTeamSize : RedTeamSize);
				if (sosigsLeft < teamSize)
				{
					SpawnSosig(sosig.Team);
				}
			}
		}

		public void ResetGame()
		{
			_blueScore = 0;
			_redScore = 0;
			UpdateScoreText();
			if (Object.op_Implicit((Object)(object)RedFlag))
			{
				RedFlag.ReturnFlag();
			}
			if (Object.op_Implicit((Object)(object)BlueFlag))
			{
				BlueFlag.ReturnFlag();
			}
		}

		public void FlagCaptured(CTF_Flag flag)
		{
			if (flag.Team == CTF_Team.Red)
			{
				_blueScore++;
			}
			else
			{
				_redScore++;
			}
			UpdateScoreText();
			flag.ReturnFlag();
		}

		public void UpdateScoreText()
		{
			Text[] scoreTexts = ScoreTexts;
			foreach (Text val in scoreTexts)
			{
				val.text = "<color=red>" + _redScore + "</color> - <color=blue>" + _blueScore + "</color>";
			}
		}

		private void OnDrawGizmos()
		{
			//IL_0001: 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_003b: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Gizmos.color = Color.red;
			Transform[] redSpawns = RedSpawns;
			foreach (Transform val in redSpawns)
			{
				Gizmos.DrawSphere(val.position, 0.15f);
			}
			Gizmos.color = Color.blue;
			Transform[] blueSpawns = BlueSpawns;
			foreach (Transform val2 in blueSpawns)
			{
				Gizmos.DrawSphere(val2.position, 0.15f);
			}
			Gizmos.color = Color.green;
			Transform[] attackPoints = AttackPoints;
			foreach (Transform val3 in attackPoints)
			{
				Gizmos.DrawSphere(val3.position, 0.15f);
			}
		}
	}
	public class CTF_Sosig : MonoBehaviour
	{
		public CTF_Team Team;

		public CTF_Flag HeldFlag;

		public Sosig Sosig;

		private void Awake()
		{
			Sosig = ((Component)this).GetComponent<Sosig>();
		}

		private void Update()
		{
			//IL_001d: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)HeldFlag))
			{
				Vector3 val = ((Component)Sosig).transform.position - ((Component)Sosig).transform.forward * 0.1f;
				((Component)HeldFlag).transform.SetPositionAndRotation(val, ((Component)Sosig).transform.rotation);
			}
		}
	}
	public enum CTF_Team
	{
		Red,
		Blue
	}
	public class PopupTarget : MonoBehaviour, IFVRDamageable
	{
		[Flags]
		public enum TargetRange
		{
			Near = 1,
			Mid = 2,
			Far = 4,
			All = 7
		}

		public PopupTargetManager Manager;

		public TargetRange Range;

		public Transform Pivot;

		public Vector3 SetRotation;

		private Quaternion _startRotation;

		private Quaternion _endRotation;

		private bool _set;

		public bool Set
		{
			get
			{
				return _set;
			}
			set
			{
				//IL_003e: 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_0027: 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)
				if (_set != value)
				{
					_set = value;
					((MonoBehaviour)this).StartCoroutine((!_set) ? RotateTo(_endRotation, _startRotation) : RotateTo(_startRotation, _endRotation));
				}
			}
		}

		private void Awake()
		{
			//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_0014: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			_startRotation = Pivot.rotation;
			_endRotation = Quaternion.Euler(SetRotation + ((Quaternion)(ref _startRotation)).eulerAngles);
		}

		void IFVRDamageable.Damage(Damage dam)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			if (Set && (int)dam.Class == 1)
			{
				Set = false;
				Manager.TargetHit(this);
			}
		}

		private IEnumerator RotateTo(Quaternion from, Quaternion to)
		{
			//IL_0007: 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_000e: 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)
			float elapsed = 0f;
			while (elapsed < 0.25f)
			{
				yield return null;
				elapsed += Time.deltaTime;
				Pivot.localRotation = Quaternion.Slerp(from, to, elapsed / 0.25f);
			}
			Pivot.rotation = to;
		}
	}
	public class PopupTargetManager : MonoBehaviour
	{
		public List<PopupTarget> Targets;

		private readonly List<PopupTarget> _setTargets = new List<PopupTarget>();

		private void Awake()
		{
			((MonoBehaviour)this).StartCoroutine(StartSetAsync(3f, 8f, 5, PopupTarget.TargetRange.All));
		}

		private IEnumerator StartSetAsync(float minDelay, float maxDelay, int numTargets, PopupTarget.TargetRange ranges)
		{
			yield return (object)new WaitForSeconds(Random.Range(minDelay, maxDelay));
			IListExtensions.Shuffle<PopupTarget>((IList<PopupTarget>)Targets);
			_setTargets.Clear();
			foreach (PopupTarget target in Targets)
			{
				if ((target.Range & ranges) != 0)
				{
					target.Set = true;
					_setTargets.Add(target);
					numTargets--;
				}
				if (numTargets == 0)
				{
					break;
				}
			}
		}

		public void TargetHit(PopupTarget target)
		{
			if (_setTargets.Contains(target))
			{
				_setTargets.Remove(target);
				if (_setTargets.Count == 0)
				{
					((MonoBehaviour)this).StartCoroutine(StartSetAsync(3f, 8f, 5, PopupTarget.TargetRange.All));
				}
			}
		}
	}
}
public class CartWheelSpin : MonoBehaviour
{
	public PayloadCart cart;

	public Transform[] wheels;

	public float wheelRadius = 0.5f;

	private PayloadManager manager;

	private void Start()
	{
		manager = cart.plm;
	}

	private void Update()
	{
		//IL_0039: 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)
		float num = manager.currentSpeed * Time.deltaTime;
		float num2 = num / wheelRadius * 57.29578f;
		Transform[] array = wheels;
		foreach (Transform val in array)
		{
			val.Rotate(Vector3.right * num2, (Space)1);
		}
	}
}
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();
		}
	}
}
public class IffBasedTrigger : MonoBehaviour
{
	public bool isOnAtStart;

	public GameObject[] attackerGO;

	public GameObject[] defenderGO;

	private PayloadManager plm;

	[HideInInspector]
	public bool isOn;

	private void Start()
	{
		plm = Object.FindObjectOfType<PayloadManager>();
		plm.ifftriggers.Add(this);
	}

	public void IFFTrigger(bool _switch)
	{
		if (_switch)
		{
			if (attackerGO != null && GM.CurrentPlayerBody.GetPlayerIFF() == 0)
			{
				GameObject[] array = attackerGO;
				foreach (GameObject val in array)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.SetActive(true);
					}
				}
				GameObject[] array2 = defenderGO;
				foreach (GameObject val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						val2.SetActive(false);
					}
				}
			}
			if (defenderGO != null && GM.CurrentPlayerBody.GetPlayerIFF() == 1)
			{
				GameObject[] array3 = attackerGO;
				foreach (GameObject val3 in array3)
				{
					if ((Object)(object)val3 != (Object)null)
					{
						val3.SetActive(false);
					}
				}
				GameObject[] array4 = defenderGO;
				foreach (GameObject val4 in array4)
				{
					if ((Object)(object)val4 != (Object)null)
					{
						val4.SetActive(true);
					}
				}
			}
			isOn = true;
		}
		if (_switch)
		{
			return;
		}
		GameObject[] array5 = attackerGO;
		foreach (GameObject val5 in array5)
		{
			if ((Object)(object)val5 != (Object)null)
			{
				val5.SetActive(false);
			}
		}
		GameObject[] array6 = defenderGO;
		foreach (GameObject val6 in array6)
		{
			if ((Object)(object)val6 != (Object)null)
			{
				val6.SetActive(false);
			}
		}
		isOn = false;
	}
}
[RequireComponent(typeof(Rigidbody))]
public class PayloadCart : MonoBehaviour
{
	public Transform captureVolume;

	[HideInInspector]
	public PayloadManager plm;

	[HideInInspector]
	public Rigidbody rb;

	private void OnValidate()
	{
		rb = ((Component)this).GetComponent<Rigidbody>();
		if ((Object)(object)rb != (Object)null)
		{
			rb.isKinematic = true;
		}
	}

	private void Awake()
	{
		rb = ((Component)this).GetComponent<Rigidbody>();
		if ((Object)(object)rb == (Object)null)
		{
			Debug.LogError((object)(((object)this).GetType().Name + ": \"" + ((Object)((Component)this).gameObject).name + "\" failed to have a Rigidbody. If you're seeing this error... how?"));
		}
	}

	private void OnDrawGizmos()
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: 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_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_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)captureVolume != (Object)null)
		{
			Gizmos.color = new Color(0.72f, 0.23f, 0.31f, 0.6f);
			Matrix4x4 matrix = Gizmos.matrix;
			Gizmos.matrix = Matrix4x4.TRS(captureVolume.position, captureVolume.rotation, captureVolume.lossyScale);
			Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
			Gizmos.matrix = matrix;
		}
	}
}
public class PayloadDoor : MonoBehaviour
{
	[Tooltip("Can a sosig walk through this door?")]
	public bool sosigOpens = false;

	[Header("Door Settings")]
	public bool locked = false;

	public float doorSpeed = 4f;

	public Rigidbody door;

	public Transform doorOpenPosition;

	public Transform doorClosePosition;

	[Header("Audio")]
	public AudioSource audioSource;

	public AudioClip openSound;

	public AudioClip closeSound;

	public AudioClip lockedSound;

	private bool doorOpen = false;

	private bool doorTransision = false;

	[Header("Debug")]
	public bool debugToggle = false;

	private void Start()
	{
	}

	public void PlayOneShot(AudioClip clip, Vector3 position, float pitch = 1f)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		audioSource.Stop();
		audioSource.loop = false;
		((Component)audioSource).transform.position = position;
		audioSource.pitch = pitch;
		audioSource.clip = clip;
		audioSource.Play();
	}

	public void OpenDoor()
	{
		//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_0030: Unknown result type (might be due to invalid IL or missing references)
		doorOpen = true;
		if (Object.op_Implicit((Object)(object)openSound))
		{
			PlayOneShot(openSound, ((Component)this).transform.position + Vector3.up);
		}
		doorTransision = true;
	}

	public void CloseDoor()
	{
		//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_0030: Unknown result type (might be due to invalid IL or missing references)
		doorOpen = false;
		if (Object.op_Implicit((Object)(object)closeSound))
		{
			PlayOneShot(closeSound, ((Component)this).transform.position + Vector3.up);
		}
		doorTransision = true;
	}

	private void LockedDoor()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		if (Object.op_Implicit((Object)(object)lockedSound))
		{
			PlayOneShot(lockedSound, ((Component)this).transform.position + Vector3.up);
		}
	}

	private void Update()
	{
		//IL_0013: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: 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_0079: 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_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		if (debugToggle)
		{
			if (door.position == doorClosePosition.position)
			{
				OpenDoor();
			}
			else
			{
				CloseDoor();
			}
			debugToggle = false;
		}
		if (!doorTransision)
		{
			return;
		}
		if (doorOpen)
		{
			door.MovePosition(Vector3.MoveTowards(door.position, doorOpenPosition.position, Time.deltaTime * doorSpeed));
			if (door.position == doorOpenPosition.position)
			{
				doorTransision = false;
			}
		}
		else
		{
			door.MovePosition(Vector3.MoveTowards(door.position, doorClosePosition.position, Time.deltaTime * doorSpeed));
			if (door.position == doorClosePosition.position)
			{
				doorTransision = false;
			}
		}
	}

	private void OnTriggerEnter(Collider other)
	{
		Debug.Log((object)("Door Entered " + ((Object)this).name + " found: " + ((Object)((Component)other).gameObject).name));
		if (((Object)other).name.Contains("Controller ("))
		{
			if (!doorOpen && !locked)
			{
				OpenDoor();
			}
			else if (locked)
			{
				LockedDoor();
			}
		}
		else
		{
			SosigLink component = ((Component)other).gameObject.GetComponent<SosigLink>();
			if (sosigOpens && (Object)(object)component != (Object)null)
			{
				Debug.Log((object)("Sosig Found " + ((Object)this).name));
				OpenDoor();
			}
		}
	}

	private void OnTriggerExit(Collider other)
	{
		if (((Object)other).name.Contains("Controller ("))
		{
			if (doorOpen)
			{
				CloseDoor();
			}
			return;
		}
		Sosig component = ((Component)other).gameObject.GetComponent<Sosig>();
		if (sosigOpens && (Object)(object)component != (Object)null)
		{
			CloseDoor();
		}
	}
}
public class PayloadManager : MonoBehaviour
{
	public enum Behavior
	{
		Comparison,
		Deadstop
	}

	private enum CartMovement
	{
		None = 0,
		Forward = 100,
		Backward = 200,
		Sliding = 300
	}

	[Serializable]
	public class PlSosig
	{
		public Sosig sos;

		public bool isoncart;

		public bool isguard;

		public bool isflanker;

		public int iff;
	}

	[Header("Object Definitions")]
	public GameObject cartPrefab;

	[Header("Cart Config")]
	[Tooltip("The time in seconds that the match begins with")]
	public float startTime = 120f;

	[Tooltip("The length in seconds of the victory lap after a team wins")]
	public float victoryLapTime = 10f;

	[Tooltip("Comparison = cart is slowed by defenders\nDeadstop = cart comes to a deadstop if a defender is near it")]
	public Behavior cartBehavior = Behavior.Comparison;

	[Tooltip("If enabled, defenders can push the cart backwards same as the attackers can forwards")]
	public bool defendersCanPushCartBack = false;

	[Tooltip("The base speed at which the cart moves when being pushed by one attacker")]
	public float cartForwardBaseSpeed = 1f;

	[Tooltip("The percentage increase in speed per extra attacker on the cart")]
	public float attackerSpeedMultiplier = 0.1f;

	[Tooltip("The maximum ammount of attackers on the cart before the speed stops being affected")]
	public int maxAttackersPushing = 4;

	[Tooltip("The base speed at which the cart moves when being pushed back by one defender")]
	public float cartReverseBaseSpeed = 1f;

	[Tooltip("The percentage decrease in speed per extra defender on the cart")]
	public float defenderSpeedMultiplier = 0.1f;

	[Tooltip("The maximum ammount of defenders on the cart before the speed stops being affected")]
	public int maxDefendersPushing = 4;

	[Tooltip("Time cart is still before it starts sliding back (change to -1 to disable this functionality)")]
	public float timeBeforeFallback = 10f;

	[Tooltip("Speed at which the cart slides back (or forward?) when left unattended for the timeBeforeFallback")]
	public float fallbackSpeed = -0.5f;

	[Tooltip("Whether an overtime mechanic exists or not (eg: if the time runs out but there are attackers on the cart the game doesnt end till theyre cleared off)")]
	public bool doesOvertime = true;

	[Tooltip("Whether an attacker has to be on the cart when the time runs out to start overtime or not")]
	public bool doesOvertimeRequireAttackers = true;

	[Tooltip("How long the cart can be left unattended in seconds whilst in overtime before the game is lost for the attackers (leave 0 to disable this mechanic)")]
	public float overtimeLength = 5f;

	[Tooltip("Unity events that are called when the cart reaches the end of the track and the game ends")]
	public UnityEvent attackerWinEvent;

	[Tooltip("Unity events that are called when the time runs out without the attackers making it to the end and the game ends")]
	public UnityEvent defenderWinEvent;

	public UnityEvent playerWin;

	public UnityEvent playerLose;

	[Header("Track Points")]
	public PayloadTrackPoint[] trackPoints;

	[Tooltip("The height from the ground points are moved to when \"Put points on ground\" is pressed in editor")]
	public float CartVerticalOffset = 0f;

	[Header("Sosig Setup")]
	public SosigEnemyID[] attackerVanillaSosigs;

	public int maxAttackersAlive;

	public SosigEnemyID[] defenderVanillaSosigs;

	public int maxDefendersAlive;

	[Tooltip("How long a sosigs body will be kept before sploding after death")]
	public float timeBeforeSplodeAfterDeath = 3f;

	[Tooltip("The starting spawn points for the attacking team")]
	public Transform[] attackerSpawns;

	[Tooltip("The starting time in seconds between each spawn wave for the attackers")]
	public float attackerSpawnWaveFrequency = -1f;

	public Transform[] flankPoints;

	public float flankerSpawnChance = -1f;

	[Tooltip("The starting spawn points for the defending team")]
	public Transform[] defenderSpawns;

	[Tooltip("The starting time in seconds between each spawn wave for the defenders")]
	public float defenderSpawnWaveFrequency = -1f;

	public Transform[] guardPoints;

	public float guardSpawnChance = -1f;

	[Header("Player Settings")]
	[Tooltip("The starting health of the player")]
	public float playerHealth = 1000f;

	[Header("Button Setup")]
	public Text healthText;

	public Text timeMultiplierText;

	public Text maxDefenderText;

	public Text maxAttackerText;

	public Text defenderSpawnFrequencyText;

	public Text attackerSpawnFrequencyText;

	[Header("Editor Testing Options")]
	[Tooltip("Enable to be able to test the carts behaviour and the track in editor (MUST BE DISABLED FOR CART TO WORK IN GAME!)")]
	public bool isTestingCart = false;

	[Tooltip("Whether or not the cart controls its speed via the game logic or can have its speed set manually below in editor (MUST BE ENABLED FOR CART TO WORK IN GAME!)")]
	public bool isSpeedSetAutomatically = true;

	[Header("Values exposed for testing (only touch in play mode)")]
	public int currentIndex = 0;

	public float currentSpeed = 0f;

	public float cartPos = 0f;

	public bool isSliding;

	public float timeLeft;

	public bool isovertime;

	public float overtimeleft;

	public bool gameStart = false;

	public float fallbackTimer = 0f;

	private CartMovement MovementBehaviorVar = CartMovement.None;

	public int defendersOnCart = 0;

	public int attackersOnCart = 0;

	public int defendersAlive = 0;

	public int attackersAlive = 0;

	public int defendersToSpawn = 0;

	public int attackersToSpawn = 0;

	public float timeTillDefenderWave = 0f;

	public float timeTillAttackerWave = 0f;

	public GameObject cart;

	public Transform capturevol;

	public Rigidbody cartrb;

	public float timeMultiplier = 1f;

	private int forwardcounter;

	private int backwardcounter;

	private bool isplayeroncart;

	private int checkindex;

	private List<PlSosig> livesosigs = new List<PlSosig>();

	private bool hasPlayerDied;

	private float victorylaptimer;

	private float attackerSpawnWaveFrequencyMult = 1f;

	private float defenderSpawnWaveFrequencyMult = 1f;

	[HideInInspector]
	public List<IffBasedTrigger> ifftriggers = new List<IffBasedTrigger>();

	public List<Transform> tempattackerSpawns = new List<Transform>();

	public float tempattackerSpawnWaveFrequency = -1f;

	public List<Transform> tempflankPoints = new List<Transform>();

	public float tempflankerSpawnChance = -1f;

	public List<Transform> tempdefenderSpawns = new List<Transform>();

	public float tempdefenderSpawnWaveFrequency = -1f;

	public List<Transform> tempguardPoints = new List<Transform>();

	public float tempguardSpawnChance = -1f;

	private void OnValidate()
	{
		//IL_0089: 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)
		if (trackPoints == null)
		{
			return;
		}
		for (int i = 0; i < trackPoints.Length; i++)
		{
			if ((Object)(object)trackPoints[i] == (Object)null)
			{
				Debug.LogError((object)("Missing track point at index: " + i));
				break;
			}
			if (i < trackPoints.Length - 1 && (Object)(object)trackPoints[i] != (Object)null && (Object)(object)trackPoints[i + 1] != (Object)null && Vector3.Distance(((Component)trackPoints[i]).transform.position, ((Component)trackPoints[i + 1]).transform.position) < 0.01f)
			{
				Debug.LogError((object)("Track point at index: " + (i + 1) + " is too close to the track point at index: " + i));
			}
		}
	}

	private void Start()
	{
		UpdateMenuVis();
	}

	public void GameStart()
	{
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)cart == (Object)null)
		{
			cart = Object.Instantiate<GameObject>(cartPrefab);
			PayloadCart component = cart.GetComponent<PayloadCart>();
			if (!((Object)(object)component != (Object)null))
			{
				Object.Destroy((Object)(object)cart);
				Debug.LogError((object)"Assigned cart prefab is missing PayloadCart component on the main GameObject. Game will not start!");
				return;
			}
			component.plm = this;
			cartrb = component.rb;
			capturevol = component.captureVolume;
		}
		if ((Object)(object)cart != (Object)null)
		{
			PayloadCart component2 = cart.GetComponent<PayloadCart>();
			component2.plm = this;
			cartrb = component2.rb;
			capturevol = component2.captureVolume;
		}
		if (livesosigs != null)
		{
			foreach (PlSosig livesosig in livesosigs)
			{
				if ((Object)(object)livesosig.sos != (Object)null)
				{
					livesosig.sos.DeSpawnSosig();
				}
			}
			livesosigs.Clear();
		}
		cartrb.isKinematic = true;
		cartrb.position = ((Component)trackPoints[0]).transform.position;
		cartrb.rotation = ((Component)trackPoints[0]).transform.rotation;
		currentIndex = 0;
		cartPos = 0f;
		defendersOnCart = 0;
		attackersOnCart = 0;
		defendersAlive = 0;
		attackersAlive = 0;
		checkindex = 0;
		fallbackTimer = 0f;
		victorylaptimer = 0f;
		isSliding = false;
		isplayeroncart = false;
		gameStart = true;
		timeLeft = startTime * timeMultiplier;
		GM.CurrentPlayerBody.SetHealthThreshold(playerHealth);
		GM.CurrentPlayerBody.Health = playerHealth;
		if (ifftriggers != null)
		{
			foreach (IffBasedTrigger ifftrigger in ifftriggers)
			{
				if ((Object)(object)ifftrigger != (Object)null && ifftrigger.isOnAtStart)
				{
					ifftrigger.IFFTrigger(_switch: true);
				}
				else if ((Object)(object)ifftrigger != (Object)null)
				{
					ifftrigger.IFFTrigger(_switch: false);
				}
			}
		}
		tempattackerSpawns.Clear();
		if (attackerSpawns != null)
		{
			tempattackerSpawns.AddRange(attackerSpawns);
		}
		else if (trackPoints[0].attackerSpawnsOverride != null)
		{
			tempattackerSpawns.AddRange(trackPoints[0].attackerSpawnsOverride);
		}
		if (attackerSpawnWaveFrequency > -1f)
		{
			if (attackerSpawnWaveFrequency > 0f)
			{
				tempattackerSpawnWaveFrequency = attackerSpawnWaveFrequency / attackerSpawnWaveFrequencyMult;
			}
			else
			{
				tempattackerSpawnWaveFrequency = 0f;
			}
		}
		else if (trackPoints[0].attackerSpawnWaveFrequencyOverride > -1f)
		{
			if (attackerSpawnWaveFrequencyMult > 0f)
			{
				tempattackerSpawnWaveFrequency = trackPoints[0].attackerSpawnWaveFrequencyOverride / attackerSpawnWaveFrequencyMult;
			}
			else
			{
				tempattackerSpawnWaveFrequency = 0f;
			}
		}
		tempdefenderSpawns.Clear();
		if (defenderSpawns != null)
		{
			tempdefenderSpawns.AddRange(defenderSpawns);
		}
		else if (trackPoints[0].defenderSpawnsOverride != null)
		{
			tempdefenderSpawns.AddRange(trackPoints[0].defenderSpawnsOverride);
		}
		if (defenderSpawnWaveFrequency > -1f)
		{
			if (defenderSpawnWaveFrequencyMult > 0f)
			{
				tempdefenderSpawnWaveFrequency = defenderSpawnWaveFrequency / defenderSpawnWaveFrequencyMult;
			}
			else
			{
				tempdefenderSpawnWaveFrequency = 0f;
			}
		}
		else if (trackPoints[0].defenderSpawnWaveFrequencyOverride > -1f)
		{
			if (defenderSpawnWaveFrequencyMult > 0f)
			{
				tempdefenderSpawnWaveFrequency = trackPoints[0].defenderSpawnWaveFrequencyOverride / defenderSpawnWaveFrequencyMult;
			}
			else
			{
				tempdefenderSpawnWaveFrequency = 0f;
			}
		}
		Debug.Log((object)"Game Started!");
	}

	private void FixedUpdate()
	{
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		if (victorylaptimer > 0f)
		{
			victorylaptimer -= Time.deltaTime;
			if (victorylaptimer <= 0f)
			{
				GameCompleteEnd();
			}
		}
		if (!gameStart)
		{
			return;
		}
		if (!isTestingCart)
		{
			GameUpdate();
		}
		if (isSpeedSetAutomatically)
		{
			SetCartSpeed();
		}
		SetCartMovementBehavior();
		BlockPassingBackCheckpoint();
		MoveCart();
		CheckPointForward();
		if (currentIndex >= trackPoints.Length - 1)
		{
			GameEnd(0);
			return;
		}
		CheckPointBackwards();
		float num = InverseLerp(((Component)trackPoints[currentIndex]).transform.position, ((Component)trackPoints[currentIndex + 1]).transform.position, cartrb.position);
		cartPos = (float)currentIndex + num;
		if (!isTestingCart)
		{
			CheckPlayerDeath();
		}
		GameClock();
	}

	private void SetCartSpeed()
	{
		if (attackersOnCart < 0)
		{
			attackersOnCart = 0;
			foreach (PlSosig livesosig in livesosigs)
			{
				if (livesosig.iff == 0)
				{
					livesosig.isoncart = false;
				}
			}
			Debug.LogError((object)"Negative ammount of attackers on cart!?");
		}
		if (defendersOnCart < 0)
		{
			defendersOnCart = 0;
			foreach (PlSosig livesosig2 in livesosigs)
			{
				if (livesosig2.iff == 1)
				{
					livesosig2.isoncart = false;
				}
			}
			Debug.LogError((object)"Negative ammount of defenders on cart!?");
		}
		float num = 0f;
		if (attackersOnCart > 0)
		{
			isSliding = false;
			fallbackTimer = 0f;
		}
		if (trackPoints[currentIndex].pointIsLocked)
		{
			currentSpeed = 0f;
			return;
		}
		if (trackPoints[currentIndex].speedOverride != 0f)
		{
			currentSpeed = trackPoints[currentIndex].speedOverride;
			return;
		}
		if (isSliding)
		{
			num = ((trackPoints[currentIndex].slideSpeedOverride == 0f) ? fallbackSpeed : trackPoints[currentIndex].slideSpeedOverride);
			currentSpeed = num;
			return;
		}
		if (attackersOnCart == 1)
		{
			num += cartForwardBaseSpeed;
		}
		else if (attackersOnCart > 1 && attackersOnCart <= maxAttackersPushing)
		{
			num += cartForwardBaseSpeed * (1f + attackerSpeedMultiplier * (float)attackersOnCart);
		}
		else if (attackersOnCart > maxAttackersPushing)
		{
			num += cartForwardBaseSpeed * (1f + attackerSpeedMultiplier * (float)maxAttackersPushing);
		}
		switch (cartBehavior)
		{
		case Behavior.Comparison:
			if (defendersOnCart == 1)
			{
				num -= cartReverseBaseSpeed;
			}
			else if (defendersOnCart > 1 && defendersOnCart <= maxDefendersPushing)
			{
				num -= cartReverseBaseSpeed * (1f + defenderSpeedMultiplier * (float)defendersOnCart);
			}
			else if (defendersOnCart > maxDefendersPushing)
			{
				num -= cartReverseBaseSpeed * (1f + defenderSpeedMultiplier * (float)maxDefendersPushing);
			}
			break;
		case Behavior.Deadstop:
			if (defendersOnCart > 0)
			{
				num = 0f;
			}
			break;
		}
		if (!defendersCanPushCartBack && num < 0f)
		{
			num = 0f;
		}
		currentSpeed = num;
	}

	private void SetCartMovementBehavior()
	{
		if (!isSliding && currentSpeed == 0f)
		{
			MovementBehaviorVar = CartMovement.None;
		}
		if (!isSliding && currentSpeed > 0f)
		{
			MovementBehaviorVar = CartMovement.Forward;
		}
		if (!isSliding && currentSpeed < 0f)
		{
			MovementBehaviorVar = CartMovement.Backward;
		}
		if (isSliding)
		{
			MovementBehaviorVar = CartMovement.Sliding;
		}
	}

	private void MoveCart()
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: 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_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: 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_00e8: 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_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0205: Unknown result type (might be due to invalid IL or missing references)
		//IL_021e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0229: Unknown result type (might be due to invalid IL or missing references)
		//IL_0233: Unknown result type (might be due to invalid IL or missing references)
		//IL_025a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0271: Unknown result type (might be due to invalid IL or missing references)
		//IL_0283: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
		switch (MovementBehaviorVar)
		{
		case CartMovement.Forward:
			cartrb.MoveRotation(Quaternion.Lerp(((Component)trackPoints[currentIndex]).transform.rotation, ((Component)trackPoints[currentIndex + 1]).transform.rotation, InverseLerp(((Component)trackPoints[currentIndex]).transform.position, ((Component)trackPoints[currentIndex + 1]).transform.position, cartrb.position)));
			cartrb.MovePosition(Vector3.MoveTowards(cartrb.position, ((Component)trackPoints[currentIndex + 1]).transform.position, currentSpeed * Time.fixedDeltaTime));
			break;
		case CartMovement.Backward:
			cartrb.MoveRotation(Quaternion.Lerp(((Component)trackPoints[currentIndex]).transform.rotation, ((Component)trackPoints[currentIndex + 1]).transform.rotation, InverseLerp(((Component)trackPoints[currentIndex]).transform.position, ((Component)trackPoints[currentIndex + 1]).transform.position, cartrb.position)));
			cartrb.MovePosition(Vector3.MoveTowards(cartrb.position, ((Component)trackPoints[currentIndex]).transform.position, (0f - currentSpeed) * Time.fixedDeltaTime));
			break;
		case CartMovement.Sliding:
			cartrb.MoveRotation(Quaternion.Lerp(((Component)trackPoints[currentIndex]).transform.rotation, ((Component)trackPoints[currentIndex + 1]).transform.rotation, InverseLerp(((Component)trackPoints[currentIndex]).transform.position, ((Component)trackPoints[currentIndex + 1]).transform.position, cartrb.position)));
			if (currentSpeed < 0f)
			{
				cartrb.MovePosition(Vector3.MoveTowards(cartrb.position, ((Component)trackPoints[currentIndex]).transform.position, (0f - currentSpeed) * Time.fixedDeltaTime));
			}
			if (currentSpeed > 0f)
			{
				cartrb.MovePosition(Vector3.MoveTowards(cartrb.position, ((Component)trackPoints[currentIndex + 1]).transform.position, currentSpeed * Time.fixedDeltaTime));
			}
			break;
		case CartMovement.None:
			if (attackersOnCart <= 0 && !trackPoints[currentIndex].pointIsLocked)
			{
				if (trackPoints[currentIndex].isInstantSlidePoint)
				{
					isSliding = true;
				}
				else if (timeBeforeFallback > 0f && fallbackTimer < timeBeforeFallback)
				{
					fallbackTimer += Time.deltaTime;
				}
				else if (timeBeforeFallback > 0f && fallbackTimer >= timeBeforeFallback)
				{
					isSliding = true;
				}
			}
			break;
		}
	}

	private void BlockPassingBackCheckpoint()
	{
		//IL_0014: 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)
		if (InverseLerp(((Component)trackPoints[currentIndex]).transform.position, ((Component)trackPoints[currentIndex + 1]).transform.position, cartrb.position) < 0.01f && currentSpeed < 0f && trackPoints[currentIndex].isCheckpoint)
		{
			currentSpeed = 0f;
		}
	}

	private void CheckPointForward()
	{
		//IL_0051: 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_0075: Unknown result type (might be due to invalid IL or missing references)
		if (!trackPoints[currentIndex].pointIsLocked)
		{
			if (forwardcounter > 0)
			{
				forwardcounter--;
			}
			else if (InverseLerp(((Component)trackPoints[currentIndex]).transform.position, ((Component)trackPoints[currentIndex + 1]).transform.position, cartrb.position) > 0.99f && currentSpeed > 0f && (MovementBehaviorVar == CartMovement.Forward || MovementBehaviorVar == CartMovement.Sliding) && currentIndex < trackPoints.Length)
			{
				PointForward();
			}
		}
	}

	private void PointForward()
	{
		currentIndex++;
		backwardcounter = 1;
		if (trackPoints[currentIndex].passForwardEvent != null && (!trackPoints[currentIndex].onlyPlayPassEventsOnce || !trackPoints[currentIndex].haspassedforward))
		{
			trackPoints[currentIndex].passForwardEvent.Invoke();
			trackPoints[currentIndex].haspassedforward = true;
		}
		if (!trackPoints[currentIndex].timehasadded)
		{
			timeLeft += trackPoints[currentIndex].timeAdded * timeMultiplier;
		}
		if (trackPoints[currentIndex].attackerSpawnsOverride != null && trackPoints[currentIndex].attackerSpawnsOverride.Count() > 0)
		{
			tempattackerSpawns.Clear();
			tempattackerSpawns.AddRange(trackPoints[currentIndex].attackerSpawnsOverride);
		}
		if (trackPoints[currentIndex].attackerSpawnWaveFrequencyOverride > -1f)
		{
			if (attackerSpawnWaveFrequencyMult > 0f)
			{
				tempattackerSpawnWaveFrequency = trackPoints[currentIndex].attackerSpawnWaveFrequencyOverride / attackerSpawnWaveFrequencyMult;
			}
			else
			{
				tempattackerSpawnWaveFrequency = 0f;
			}
		}
		if (trackPoints[currentIndex].defenderSpawnsOverride != null && trackPoints[currentIndex].defenderSpawnsOverride.Count() > 0)
		{
			tempdefenderSpawns.Clear();
			tempdefenderSpawns.AddRange(trackPoints[currentIndex].defenderSpawnsOverride);
		}
		if (trackPoints[currentIndex].defenderSpawnWaveFrequencyOverride > -1f)
		{
			if (defenderSpawnWaveFrequencyMult > 0f)
			{
				tempdefenderSpawnWaveFrequency = trackPoints[currentIndex].defenderSpawnWaveFrequencyOverride / defenderSpawnWaveFrequencyMult;
			}
			else
			{
				tempdefenderSpawnWaveFrequency = 0f;
			}
		}
	}

	private void CheckPointBackwards()
	{
		//IL_0051: 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_0075: Unknown result type (might be due to invalid IL or missing references)
		if (!trackPoints[currentIndex].pointIsLocked)
		{
			if (backwardcounter > 0)
			{
				backwardcounter--;
			}
			else if (InverseLerp(((Component)trackPoints[currentIndex]).transform.position, ((Component)trackPoints[currentIndex + 1]).transform.position, cartrb.position) < 0.01f && currentSpeed < 0f && !trackPoints[currentIndex].isCheckpoint && (MovementBehaviorVar == CartMovement.Backward || MovementBehaviorVar == CartMovement.Sliding) && currentIndex > 0)
			{
				PointBackwards();
			}
		}
	}

	private void PointBackwards()
	{
		currentIndex--;
		forwardcounter = 1;
		if (trackPoints[currentIndex + 1].passBackwardsEvent != null && (!trackPoints[currentIndex + 1].onlyPlayPassEventsOnce || !trackPoints[currentIndex + 1].haspassedbackwards))
		{
			trackPoints[currentIndex + 1].passBackwardsEvent.Invoke();
			trackPoints[currentIndex + 1].haspassedbackwards = true;
		}
	}

	private void GameClock()
	{
		if (timeLeft > 0f)
		{
			timeLeft -= Time.deltaTime;
			isovertime = false;
		}
		else if (timeLeft <= 0f && !doesOvertime)
		{
			GameEnd(1);
		}
		else
		{
			if (!(timeLeft <= 0f) || !doesOvertime)
			{
				return;
			}
			if (isovertime && attackersOnCart <= 0 && overtimeleft > 0f)
			{
				overtimeleft -= Time.deltaTime;