using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
public class HypeTrainTester : MonoBehaviour
{
	[SerializeField]
	private string[] m_names = new string[0];

	[SerializeField]
	private HypeTrain m_hypeTrainPrototype;

	[SerializeField]
	private Transform m_startTransform;

	[SerializeField]
	private Transform m_endTransform;

	[SerializeField]
	private Transform m_playerTransform;

	private HypeTrain m_createdHypeTrain;

	private void Start()
	{
		((MonoBehaviour)this).StartCoroutine(StartTest());
	}

	private IEnumerator StartTest()
	{
		yield return (object)new WaitForSeconds(0.5f);
		m_createdHypeTrain = Object.Instantiate<HypeTrain>(m_hypeTrainPrototype);
		m_createdHypeTrain.OnFinishedEvent.AddListener(new UnityAction(ResetTest));
		HypeTrainBoxData[] array = new HypeTrainBoxData[m_names.Length];
		for (int i = 0; i < m_names.Length; i++)
		{
			array[i] = new HypeTrainBoxData
			{
				name = m_names[i],
				box_color = Color.HSVToRGB(Random.value, 1f, 1f),
				box_color_rate = ((((uint)i & (true ? 1u : 0u)) != 0) ? ((Random.Range(0, 1) == 0) ? (-0.2f) : 1f) : 0f),
				bit_amount = ((i % 4 == 0) ? Random.Range(1, 1000000) : 0),
				name_color = Color.HSVToRGB(Random.value, 1f, 1f)
			};
		}
		m_createdHypeTrain.StartHypeTrain(m_startTransform.position, m_endTransform.position, array, m_playerTransform);
	}

	private void ResetTest()
	{
		if ((Object)null != (Object)(object)m_createdHypeTrain)
		{
			Object.Destroy((Object)(object)((Component)m_createdHypeTrain).gameObject);
			m_createdHypeTrain = null;
		}
		((MonoBehaviour)this).StartCoroutine(StartTest());
	}
}
public class HypeTrainBit : MonoBehaviour
{
	[SerializeField]
	private Animator m_animator;

	[SerializeField]
	private int m_bitValue;

	[SerializeField]
	private Rigidbody m_rigidbody;

	[SerializeField]
	private Collider m_collider;

	[SerializeField]
	private float m_lifeTime = 20f;

	private IEnumerator m_deathCoroutine;

	private static readonly int s_deathTrigger = Animator.StringToHash("Death");

	public int BitValue => m_bitValue;

	public Rigidbody Rigidbody => m_rigidbody;

	public Collider Collider => m_collider;

	public float LifeTime
	{
		get
		{
			return m_lifeTime;
		}
		set
		{
			m_lifeTime = value;
		}
	}

	private void Awake()
	{
		m_animator.StopPlayback();
	}

	public void StartDeathCountdown()
	{
		if (m_deathCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(m_deathCoroutine);
			m_deathCoroutine = null;
		}
		m_deathCoroutine = Death();
		((MonoBehaviour)this).StartCoroutine(m_deathCoroutine);
	}

	private IEnumerator Death()
	{
		yield return (object)new WaitForSeconds(m_lifeTime);
		m_animator.Play(s_deathTrigger, 0, 0f);
	}

	private void Kill()
	{
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}
}
public class HypeTrain : MonoBehaviour
{
	[SerializeField]
	private Rigidbody m_rigidBody;

	[SerializeField]
	private HypeTrainCarAudio m_carWheelsAudio;

	[SerializeField]
	private HypeTrainLocomotive m_locomotive;

	[SerializeField]
	private HypeTrainBox m_boxPrototype;

	[SerializeField]
	private HypeTrainBitBox m_bitboxPrototype;

	[SerializeField]
	private float m_distancePerSecond = 4f;

	[SerializeField]
	private HypeTrainBit[] m_bitPrototypes = new HypeTrainBit[0];

	[SerializeField]
	private bool m_keepAliveOnFinish;

	private UnityEvent m_onFinishedEvent = new UnityEvent();

	private List<HypeTrainBox> m_activeBoxes = new List<HypeTrainBox>();

	private Queue<HypeTrainBox> m_availableBoxes = new Queue<HypeTrainBox>();

	private Queue<HypeTrainBitBox> m_availableBitBoxes = new Queue<HypeTrainBitBox>();

	private Vector3 m_startPosition = Vector3.zero;

	private Vector3 m_stopPosition = Vector3.zero;

	private Vector3 m_direction = Vector3.zero;

	private float m_trackDistance;

	private Transform m_playerRoot;

	private int m_nextBoxIndexToSpawn;

	private float m_nextBoxOffset;

	private HypeTrainBoxData[] m_boxData;

	public UnityEvent OnFinishedEvent => m_onFinishedEvent;

	private void Awake()
	{
		//IL_004b: 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)
		m_bitPrototypes = m_bitPrototypes.OrderByDescending((HypeTrainBit bit) => bit.BitValue).ToArray();
		((Component)m_locomotive).transform.localPosition = -m_locomotive.FrontLoc.localPosition;
		((UnityEvent<HypeTrainCar, HypeTrainCar.Visibility>)m_locomotive.OnVisibilityChangedEvent).AddListener((UnityAction<HypeTrainCar, HypeTrainCar.Visibility>)OnLocomotiveFinished);
		StopHypeTrain();
		((Component)m_boxPrototype).gameObject.SetActive(false);
		((Component)m_bitboxPrototype).gameObject.SetActive(false);
	}

	private void FixedUpdate()
	{
		//IL_0019: 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_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		float num = Time.deltaTime * m_distancePerSecond;
		m_rigidBody.MovePosition(m_rigidBody.position + m_direction * num);
		m_locomotive.UpdateCar(Time.deltaTime, num);
		foreach (HypeTrainBox activeBox in m_activeBoxes)
		{
			activeBox.UpdateCar(Time.deltaTime, num);
		}
		m_carWheelsAudio.UpdateAudio(Time.deltaTime, num, m_locomotive, m_activeBoxes, m_playerRoot);
	}

	public void StartHypeTrain(Vector3 startWorldPosition, Vector3 stopWorldPosition, HypeTrainBoxData[] boxData, Transform playerRoot = null, HypeTrainOptions options = null)
	{
		//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)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: 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_014d: 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_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: 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_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_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		StopHypeTrain();
		m_startPosition = startWorldPosition;
		m_stopPosition = stopWorldPosition;
		Vector3 val = m_stopPosition - m_startPosition;
		m_trackDistance = ((Vector3)(ref val)).magnitude;
		m_direction = ((Vector3)(ref val)).normalized;
		m_boxData = boxData;
		m_playerRoot = playerRoot;
		m_nextBoxIndexToSpawn = 0;
		m_nextBoxOffset = 0f - m_locomotive.CalculateCarLength();
		m_distancePerSecond = ((options != null && options.distance_per_second.HasValue) ? options.distance_per_second.Value : m_distancePerSecond);
		m_keepAliveOnFinish = ((options != null && options.keep_alive_on_finish.HasValue) ? options.keep_alive_on_finish.Value : m_keepAliveOnFinish);
		if (options != null && options.train_layer.HasValue)
		{
			SetLayerRecursive(((Component)this).gameObject, options.train_layer.Value);
			HypeTrainBit[] bitPrototypes = m_bitPrototypes;
			foreach (HypeTrainBit hypeTrainBit in bitPrototypes)
			{
				SetLayerRecursive(((Component)hypeTrainBit).gameObject, options.train_layer.Value);
			}
		}
		if (options != null && options.volume.HasValue)
		{
			SetVolume(options.volume.Value);
		}
		Transform transform = ((Component)this).transform;
		Vector3 position = (m_rigidBody.position = startWorldPosition);
		transform.position = position;
		Transform transform2 = ((Component)this).transform;
		Quaternion rotation = (m_rigidBody.rotation = Quaternion.LookRotation(m_direction));
		transform2.rotation = rotation;
		int num = Mathf.Min(Mathf.CeilToInt((m_trackDistance + m_boxPrototype.CalculateCarLength()) / m_boxPrototype.CalculateCarLength()), boxData.Length);
		for (int j = 0; j < num; j++)
		{
			HypeTrainBox hypeTrainBox = Object.Instantiate<HypeTrainBox>(m_boxPrototype, ((Component)m_boxPrototype).transform.parent, false);
			((UnityEvent<HypeTrainCar, HypeTrainCar.Visibility>)hypeTrainBox.OnVisibilityChangedEvent).AddListener((UnityAction<HypeTrainCar, HypeTrainCar.Visibility>)OnBoxFinished);
			m_availableBoxes.Enqueue(hypeTrainBox);
		}
		num = Mathf.Min(Mathf.CeilToInt((m_trackDistance + m_bitboxPrototype.CalculateCarLength()) / m_bitboxPrototype.CalculateCarLength()), boxData.Length);
		for (int k = 0; k < num; k++)
		{
			HypeTrainBitBox hypeTrainBitBox = Object.Instantiate<HypeTrainBitBox>(m_bitboxPrototype, ((Component)m_bitboxPrototype).transform.parent, false);
			hypeTrainBitBox.Init(m_bitPrototypes, playerRoot, options?.player_collider_radius, options?.max_bits_per_car, options?.bit_lifetime_in_seconds);
			((UnityEvent<HypeTrainCar, HypeTrainCar.Visibility>)hypeTrainBitBox.OnVisibilityChangedEvent).AddListener((UnityAction<HypeTrainCar, HypeTrainCar.Visibility>)OnBoxFinished);
			m_availableBitBoxes.Enqueue(hypeTrainBitBox);
		}
		m_carWheelsAudio.StartPersistentSounds();
		((Component)m_locomotive).gameObject.SetActive(true);
		m_locomotive.Engage(0f, m_trackDistance + m_locomotive.CalculateCarLength(), 0);
		FlushAvailableBoxes();
	}

	public void StopHypeTrain()
	{
		m_carWheelsAudio.StopPersistentSounds();
		foreach (HypeTrainBox availableBox in m_availableBoxes)
		{
			Object.Destroy((Object)(object)((Component)availableBox).gameObject);
		}
		m_availableBoxes.Clear();
		foreach (HypeTrainBitBox availableBitBox in m_availableBitBoxes)
		{
			Object.Destroy((Object)(object)((Component)availableBitBox).gameObject);
		}
		m_availableBitBoxes.Clear();
		foreach (HypeTrainBox activeBox in m_activeBoxes)
		{
			Object.Destroy((Object)(object)((Component)activeBox).gameObject);
		}
		m_activeBoxes.Clear();
		((Component)m_locomotive).gameObject.SetActive(false);
	}

	public void SetDistancePerSecond(float distancePerSecond)
	{
		m_distancePerSecond = distancePerSecond;
	}

	public void SetKeepAliveOnFinish(bool keepAlive)
	{
		m_keepAliveOnFinish = keepAlive;
	}

	public void SetVolume(float volume)
	{
		m_locomotive.SetBaseVolume(volume);
		m_carWheelsAudio.SetBaseVolume(volume);
	}

	private void OnLocomotiveFinished(HypeTrainCar car, HypeTrainCar.Visibility visibility)
	{
		if (visibility == HypeTrainCar.Visibility.Hidden)
		{
			FlushAvailableBoxes();
		}
	}

	private void OnBoxFinished(HypeTrainCar car, HypeTrainCar.Visibility visibility)
	{
		if (visibility == HypeTrainCar.Visibility.Hidden)
		{
			m_activeBoxes.Remove((HypeTrainBox)car);
			if (((object)car).GetType() == typeof(HypeTrainBitBox))
			{
				HypeTrainBitBox item = (HypeTrainBitBox)car;
				m_availableBitBoxes.Enqueue(item);
			}
			else
			{
				m_availableBoxes.Enqueue((HypeTrainBox)car);
			}
			FlushAvailableBoxes();
		}
	}

	private void FlushAvailableBoxes()
	{
		//IL_003e: 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_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		while (m_nextBoxIndexToSpawn < m_boxData.Length && m_availableBoxes.Count != 0)
		{
			HypeTrainBoxData hypeTrainBoxData = m_boxData[m_nextBoxIndexToSpawn];
			HypeTrainBox hypeTrainBox = null;
			hypeTrainBox = ((hypeTrainBoxData.bit_amount <= 0) ? m_availableBoxes.Dequeue() : m_availableBitBoxes.Dequeue());
			((Component)hypeTrainBox).transform.localPosition = Vector3.forward * m_nextBoxOffset - hypeTrainBox.FrontLoc.localPosition;
			float num = hypeTrainBox.CalculateCarLength();
			float num2 = Mathf.Abs(m_nextBoxOffset);
			Vector3 val = ((Component)this).transform.position - m_startPosition;
			float num3 = num2 - ((Vector3)(ref val)).magnitude;
			hypeTrainBox.Engage(hypeTrainBoxData, num3, num3 + m_trackDistance + num, m_nextBoxIndexToSpawn + 1);
			m_activeBoxes.Add(hypeTrainBox);
			m_nextBoxIndexToSpawn++;
			m_nextBoxOffset -= num;
		}
		bool flag = false;
		flag |= ((Component)m_locomotive).gameObject.activeSelf;
		foreach (HypeTrainBox activeBox in m_activeBoxes)
		{
			flag |= ((Component)activeBox).gameObject.activeSelf;
		}
		if (!flag)
		{
			OnFinishedEvent.Invoke();
			StopHypeTrain();
			if (!m_keepAliveOnFinish)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}

	private void SetLayerRecursive(GameObject go, int layer)
	{
		go.layer = layer;
		for (int i = 0; i < go.transform.childCount; i++)
		{
			SetLayerRecursive(((Component)go.transform.GetChild(i)).gameObject, layer);
		}
	}
}
public class HypeTrainBitBox : HypeTrainBox
{
	[SerializeField]
	private BoxCollider m_bitSpawnZone;

	[SerializeField]
	private int m_maxBitBreaks = 100;

	[SerializeField]
	private TextMeshPro[] m_bitsTexts = (TextMeshPro[])(object)new TextMeshPro[0];

	[SerializeField]
	private HypeTrainBitBoxPlayerCollider m_playerCollider;

	private List<HypeTrainBit> m_createdBits = new List<HypeTrainBit>();

	private HypeTrainBit[] m_bitPrototypes;

	private int? m_maxBitsToSpawn;

	private float? m_bitLifetimeInSeconds;

	public void Init(HypeTrainBit[] bitPrototypes, Transform playerRoot, float? playerColliderRadius = null, int? maxBitsToSpawn = null, float? bitLifetimeInSeconds = null)
	{
		m_bitPrototypes = bitPrototypes;
		m_maxBitsToSpawn = maxBitsToSpawn;
		m_bitLifetimeInSeconds = bitLifetimeInSeconds;
		m_playerCollider.Init(this, playerRoot, playerColliderRadius);
	}

	public override void Engage(HypeTrainBoxData data, float distanceToStart, float distanceToStop, int index)
	{
		base.Engage(data, distanceToStart, distanceToStop, index);
		TextMeshPro[] bitsTexts = m_bitsTexts;
		for (int i = 0; i < bitsTexts.Length; i++)
		{
			((TMP_Text)bitsTexts[i]).SetText($"BITS: {data.bit_amount}", true);
		}
		SpawnBits(data.bit_amount);
	}

	public void SpawnBits(int amount)
	{
		//IL_008b: 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_00c2: 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_010f: Unknown result type (might be due to invalid IL or missing references)
		RelinquishCreatedBits();
		if (m_bitPrototypes == null)
		{
			return;
		}
		int num = (m_maxBitsToSpawn.HasValue ? m_maxBitsToSpawn.Value : amount);
		int num2 = m_maxBitBreaks;
		Vector3 localPosition = default(Vector3);
		while (amount > 0 && num > 0)
		{
			int num3 = amount;
			if (0 < num2)
			{
				num3 = Random.Range(1, amount + 1);
			}
			amount -= num3;
			while (0 < num3 && num > 0)
			{
				HypeTrainBit[] bitPrototypes = m_bitPrototypes;
				foreach (HypeTrainBit hypeTrainBit in bitPrototypes)
				{
					if (hypeTrainBit.BitValue <= num3)
					{
						num3 -= hypeTrainBit.BitValue;
						num--;
						((Vector3)(ref localPosition))..ctor(Random.Range((0f - m_bitSpawnZone.size.x) * 0.5f, m_bitSpawnZone.size.x * 0.5f), 0f, Random.Range((0f - m_bitSpawnZone.size.z) * 0.5f, m_bitSpawnZone.size.z * 0.5f));
						HypeTrainBit hypeTrainBit2 = Object.Instantiate<HypeTrainBit>(hypeTrainBit, ((Component)m_bitSpawnZone).transform, false);
						((Component)hypeTrainBit2).transform.localPosition = localPosition;
						hypeTrainBit2.Rigidbody.isKinematic = true;
						hypeTrainBit2.Collider.enabled = true;
						m_createdBits.Add(hypeTrainBit2);
					}
				}
			}
			num2--;
		}
	}

	protected override void OnShowFinished()
	{
		base.OnShowFinished();
		if (m_createdBits.Count == 0)
		{
			SpawnBits(100);
		}
	}

	protected override void OnHideFinished()
	{
		base.OnHideFinished();
		foreach (HypeTrainBit createdBit in m_createdBits)
		{
			Object.Destroy((Object)(object)((Component)createdBit).gameObject);
		}
		m_createdBits.Clear();
	}

	public void RelinquishCreatedBits()
	{
		foreach (HypeTrainBit createdBit in m_createdBits)
		{
			createdBit.Rigidbody.isKinematic = false;
			createdBit.Collider.enabled = true;
			((Component)createdBit).transform.SetParent((Transform)null, true);
			if (m_bitLifetimeInSeconds.HasValue)
			{
				createdBit.LifeTime = m_bitLifetimeInSeconds.Value;
			}
			createdBit.StartDeathCountdown();
		}
		m_createdBits.Clear();
	}
}
public class HypeTrainBitBoxPlayerCollider : MonoBehaviour
{
	[SerializeField]
	private SphereCollider m_collider;

	private HypeTrainBitBox m_owner;

	private Transform m_playerRoot;

	public void Init(HypeTrainBitBox owner, Transform playerRoot, float? playerColliderRadius = null)
	{
		m_owner = owner;
		m_playerRoot = playerRoot;
		if (playerColliderRadius.HasValue)
		{
			m_collider.radius = playerColliderRadius.Value;
		}
	}

	private void OnCollisionEnter(Collision other)
	{
		if ((Object)null != (Object)(object)m_owner && (Object)(object)other.transform == (Object)(object)m_playerRoot)
		{
			m_owner.RelinquishCreatedBits();
		}
	}

	private void OnTriggerEnter(Collider other)
	{
		if ((Object)null != (Object)(object)m_owner && (Object)(object)((Component)other).transform == (Object)(object)m_playerRoot)
		{
			m_owner.RelinquishCreatedBits();
		}
	}
}
public class HypeTrainBox : HypeTrainCar
{
	[SerializeField]
	private TextMeshPro[] m_nameTexts;

	private Material m_carMaterial;

	private Color m_carColor;

	private float m_carColorRate;

	private static int s_trimColorMaterialPropertyID = Shader.PropertyToID("_TrimColor");

	public virtual void Engage(HypeTrainBoxData data, float distanceToStart, float distanceToStop, int index)
	{
		//IL_0012: 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)
		Engage(distanceToStart, distanceToStop, index);
		SetName(data.name, data.name_color);
		SetBoxColor(data.box_color, data.box_color_rate);
	}

	public override void UpdateCar(float dt, float delta)
	{
		//IL_0016: 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)
		base.UpdateCar(dt, delta);
		if (m_carColorRate != 0f)
		{
			float num2 = default(float);
			float num3 = default(float);
			float num = default(float);
			Color.RGBToHSV(m_carColor, ref num, ref num2, ref num3);
			for (num += m_carColorRate * delta; num > 1f; num -= 1f)
			{
			}
			for (; num < 0f; num += 1f)
			{
			}
			SetBoxColor(Color.HSVToRGB(num, num2, num3), m_carColorRate);
		}
	}

	public void SetName(string name, Color nameColor)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		TextMeshPro[] nameTexts = m_nameTexts;
		foreach (TextMeshPro obj in nameTexts)
		{
			((TMP_Text)obj).SetText(name, true);
			((Graphic)obj).color = nameColor;
		}
	}

	public void SetBoxColor(Color color, float carColorRate)
	{
		//IL_004a: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected O, but got Unknown
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)null == (Object)(object)m_carMaterial)
		{
			m_carMaterial = new Material(((Renderer)base.Meshes[0]).material);
			MeshRenderer[] meshes = base.Meshes;
			for (int i = 0; i < meshes.Length; i++)
			{
				((Renderer)meshes[i]).material = m_carMaterial;
			}
		}
		m_carColor = color;
		if ((Object)null != (Object)(object)m_carMaterial)
		{
			m_carMaterial.SetColor(s_trimColorMaterialPropertyID, color);
		}
		m_carColorRate = carColorRate;
	}
}
[Serializable]
public class HypeTrainBoxData
{
	public string name = "";

	public Color name_color = new Color(1f, 1f, 1f);

	public Color box_color = new Color(0.3803921f, 0.7960785f, 0.545098f);

	public float box_color_rate;

	public int bit_amount;
}
public class HypeTrainCar : MonoBehaviour
{
	public enum Visibility
	{
		Visible,
		Hidden
	}

	public class VisibilityChangedEvent : UnityEvent<HypeTrainCar, Visibility>
	{
	}

	[SerializeField]
	private Animator m_animatorRoot;

	[SerializeField]
	private Animator m_animatorCar;

	[SerializeField]
	private Transform m_frontLoc;

	[SerializeField]
	private Transform m_backLoc;

	[SerializeField]
	private MeshRenderer[] m_meshes = (MeshRenderer[])(object)new MeshRenderer[0];

	private VisibilityChangedEvent m_onVisibilityChangedEvent = new VisibilityChangedEvent();

	private float m_distanceToStart;

	private float m_distanceToStop;

	private static readonly int s_animShowTag = Animator.StringToHash("Show");

	private static readonly int s_animHideTag = Animator.StringToHash("Hide");

	private static readonly int s_animWobbleTag = Animator.StringToHash("Wobble");

	protected MeshRenderer[] Meshes => m_meshes;

	public Transform FrontLoc => m_frontLoc;

	public Transform BackLoc => m_backLoc;

	public VisibilityChangedEvent OnVisibilityChangedEvent => m_onVisibilityChangedEvent;

	public void Engage(float distanceToStart, float distanceToStop, int index)
	{
		m_distanceToStart = distanceToStart;
		m_distanceToStop = distanceToStop;
		if (m_distanceToStart <= 0f)
		{
			Show();
			float num = 5f;
			m_animatorCar.Play(s_animWobbleTag, 0, (float)index % (num + 1f) / num);
		}
		if (m_distanceToStop <= 0f)
		{
			Hide();
		}
	}

	public virtual void UpdateCar(float dt, float delta)
	{
		if (m_distanceToStart > 0f)
		{
			m_distanceToStart -= delta;
			if (m_distanceToStart <= 0f)
			{
				m_distanceToStart = 0f;
				Show();
			}
		}
		if (m_distanceToStop > 0f)
		{
			m_distanceToStop -= delta;
			if (m_distanceToStop <= 0f)
			{
				m_distanceToStop = 0f;
				Hide();
			}
		}
	}

	public virtual void Show()
	{
		((Component)this).gameObject.SetActive(true);
		m_animatorRoot.Play(s_animShowTag, 0, 0f);
	}

	public virtual void Hide()
	{
		m_animatorRoot.Play(s_animHideTag, 0, 0f);
	}

	public float CalculateCarLength()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = m_frontLoc.localPosition - m_backLoc.localPosition;
		return ((Vector3)(ref val)).magnitude;
	}

	protected virtual void OnShowFinished()
	{
		((UnityEvent<HypeTrainCar, Visibility>)m_onVisibilityChangedEvent).Invoke(this, Visibility.Visible);
	}

	protected virtual void OnHideFinished()
	{
		((Component)this).gameObject.SetActive(false);
		((UnityEvent<HypeTrainCar, Visibility>)m_onVisibilityChangedEvent).Invoke(this, Visibility.Hidden);
	}
}
public class HypeTrainCarAudio : MonoBehaviour
{
	[SerializeField]
	private AudioSource m_carWheelsAudio;

	[SerializeField]
	private AudioSource m_carWheelsClankAudio;

	[SerializeField]
	private AudioClip[] m_carWheelsClankAudioClips = (AudioClip[])(object)new AudioClip[0];

	[SerializeField]
	private int m_maxSimultaneousClanks = 3;

	[SerializeField]
	private float m_clankMinInterval = 0.1f;

	[SerializeField]
	private float m_clankMaxInterval = 0.5f;

	private float m_nextClankTimer;

	private float[] m_clankTimers;

	private float m_wheelVolume = 1f;

	private float m_baseVolume = 1f;

	private void Awake()
	{
		m_clankTimers = new float[m_maxSimultaneousClanks];
	}

	public void StartPersistentSounds()
	{
		m_carWheelsAudio.Play();
	}

	public void StopPersistentSounds()
	{
		m_carWheelsAudio.Stop();
	}

	public void UpdateAudio(float dt, float delta, HypeTrainLocomotive locomotive, List<HypeTrainBox> activeBoxes, Transform playerRoot)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: 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_002c: 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_0032: 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_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		Vector3 position = ((Component)locomotive).transform.position;
		float x = ((Component)locomotive).transform.lossyScale.x;
		if ((Object)null != (Object)(object)playerRoot)
		{
			float num = Vector3.SqrMagnitude(playerRoot.position - position);
			foreach (HypeTrainBox activeBox in activeBoxes)
			{
				float num2 = Vector3.SqrMagnitude(playerRoot.position - ((Component)activeBox).transform.position);
				if (num2 < num)
				{
					num = num2;
					position = ((Component)activeBox).transform.position;
					x = ((Component)activeBox).transform.lossyScale.x;
				}
			}
		}
		position.y += 0.75f;
		((Component)this).transform.position = Vector3.MoveTowards(((Component)m_carWheelsAudio).transform.position, position, delta * 4f);
		m_wheelVolume = Mathf.MoveTowards(m_wheelVolume, x, dt * 2f);
		AudioSource carWheelsAudio = m_carWheelsAudio;
		float volume = (m_carWheelsClankAudio.volume = m_baseVolume * m_wheelVolume);
		carWheelsAudio.volume = volume;
		if (m_nextClankTimer > 0f)
		{
			m_nextClankTimer -= dt;
			if (m_nextClankTimer <= 0f)
			{
				for (int i = 0; i < m_maxSimultaneousClanks; i++)
				{
					if (m_clankTimers[i] <= 0f)
					{
						AudioClip val = m_carWheelsClankAudioClips[Random.Range(0, m_carWheelsClankAudioClips.Length)];
						m_clankTimers[i] = val.length;
						m_carWheelsClankAudio.PlayOneShot(val);
						break;
					}
				}
			}
		}
		for (int j = 0; j < m_maxSimultaneousClanks; j++)
		{
			m_clankTimers[j] -= dt;
			if (m_clankTimers[j] <= 0f)
			{
				while (m_nextClankTimer <= 0f)
				{
					m_nextClankTimer += Random.Range(m_clankMinInterval, m_clankMaxInterval);
				}
			}
		}
	}

	public void SetBaseVolume(float volume)
	{
		m_baseVolume = volume;
		AudioSource carWheelsAudio = m_carWheelsAudio;
		float volume2 = (m_carWheelsClankAudio.volume = m_baseVolume * m_wheelVolume);
		carWheelsAudio.volume = volume2;
	}
}
public class HypeTrainLocomotive : HypeTrainCar
{
	[SerializeField]
	private AudioSource m_audioSource;

	private float m_baseVolume = 1f;

	public override void Show()
	{
		base.Show();
		m_audioSource.Play();
	}

	protected override void OnHideFinished()
	{
		base.OnHideFinished();
		m_audioSource.Stop();
	}

	public override void UpdateCar(float dt, float delta)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		base.UpdateCar(dt, delta);
		m_audioSource.volume = m_baseVolume * Mathf.Clamp01(((Component)this).transform.lossyScale.x);
	}

	public void SetBaseVolume(float volume)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		m_baseVolume = volume;
		m_audioSource.volume = m_baseVolume * Mathf.Clamp01(((Component)this).transform.lossyScale.x);
	}
}
[Serializable]
public class HypeTrainOptions
{
	public int? train_layer;

	public float? distance_per_second;

	public float? player_collider_radius;

	public int? max_bits_per_car;

	public float? bit_lifetime_in_seconds;

	public float? volume;

	public bool? keep_alive_on_finish;
}