Decompiled source of GR8 Recoilless Rifle v1.0.2

GR8_Recoilless_Rifle.dll

Decompiled a week ago
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using H3VRUtils;
using HarmonyLib;
using OpenScripts2;
using OtherLoader;
using UnityEngine;
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 ShermanJumbo
{
	public class CannonballSecondaryRenderer : MonoBehaviour
	{
		public Renderer Rend;

		public CannonBall Cannonball;

		private void Update()
		{
			if (Cannonball.TurnsOffRends && !Cannonball.hasTurnedOffRends)
			{
				Rend.enabled = false;
			}
		}
	}
	public class ChamberDependentParticlesAndSounds : MonoBehaviour
	{
		public FVRFireArmChamber ChamberToRead;

		public ParticleSystem ParticlesToEnable;

		public AudioSource SoundsToEnable;

		private void Update()
		{
			if (ChamberToRead.IsFull)
			{
				if (!ParticlesToEnable.isPlaying)
				{
					ParticlesToEnable.Play();
				}
				if (!SoundsToEnable.isPlaying)
				{
					SoundsToEnable.Play();
				}
			}
			else
			{
				ParticlesToEnable.Stop();
				SoundsToEnable.Stop();
			}
		}
	}
	public class FirearmSpinnyBarrels : MonoBehaviour
	{
		public FVRFireArm Gun;

		public GameObject SpinningBarrels;

		public float SpinRate;

		public dirType DirectionOfSpin;

		public float DecelerationRate = 0.5f;

		public float TriggerDeadzone = 0.01f;

		private float currentSpinSpeed = 0f;

		private bool TriggerPulled = false;

		public AudioSource SpinnySounds;

		public float SpinnySoundsVolume = 0.4f;

		private void Awake()
		{
			SpinnySounds.volume = 0f;
		}

		private void Update()
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected I4, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)SpinnySounds != (Object)null)
			{
				SpinnySounds.volume = currentSpinSpeed / SpinRate * SpinnySoundsVolume;
			}
			if ((Object)(object)Gun != (Object)null && (Object)(object)((FVRInteractiveObject)Gun).m_hand != (Object)null)
			{
				float triggerFloat = ((FVRInteractiveObject)Gun).m_hand.Input.TriggerFloat;
				if (triggerFloat >= TriggerDeadzone)
				{
					if (!TriggerPulled)
					{
						TriggerPulled = true;
					}
					currentSpinSpeed = SpinRate;
				}
				else if (TriggerPulled)
				{
					TriggerPulled = false;
				}
			}
			if (!TriggerPulled && currentSpinSpeed > 0f)
			{
				currentSpinSpeed -= DecelerationRate * Time.deltaTime;
				if (currentSpinSpeed < 0f)
				{
					currentSpinSpeed = 0f;
				}
			}
			if (currentSpinSpeed > 0f && (Object)(object)SpinningBarrels != (Object)null)
			{
				Vector3 zero = Vector3.zero;
				int num = (int)DirectionOfSpin;
				if (num >= 0 && num <= 2)
				{
					((Vector3)(ref zero))[num] = currentSpinSpeed * Time.deltaTime;
					SpinningBarrels.transform.Rotate(zero);
				}
				else
				{
					Debug.LogWarning((object)"Invalid DirectionOfSpin value!");
				}
			}
		}
	}
}
[ExecuteInEditMode]
public class HolographicSight : MonoBehaviour
{
	public Transform VirtualQuad;

	public float Scale = 1f;

	public bool SizeCompensation = true;

	private MaterialPropertyBlock m_block;

	private void OnEnable()
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		m_block = new MaterialPropertyBlock();
		((Component)this).GetComponent<Renderer>().SetPropertyBlock(m_block);
	}

	private void OnWillRenderObject()
	{
		//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)
		//IL_0028: 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)
		Vector3 val = ((Component)this).transform.InverseTransformPoint(((Component)VirtualQuad).transform.position);
		m_block.SetVector("_Offset", Vector4.op_Implicit(val));
		m_block.SetFloat("_Scale", Scale);
		m_block.SetFloat("_SizeCompensation", (!SizeCompensation) ? 0f : 1f);
		((Component)this).GetComponent<Renderer>().SetPropertyBlock(m_block);
	}
}
namespace ShermanJumbo
{
	public class LAPDLaserAsAttachment : MonoBehaviour
	{
		public LAPD2019Laser Laser;

		private void Awake()
		{
			Laser.m_isOn = true;
		}
	}
}
namespace ShermanJumbo.GR8_Recoilless_Rifle
{
	[BepInPlugin("ShermanJumbo.GR8_Recoilless_Rifle", "GR8_Recoilless_Rifle", "1.0.2")]
	[BepInProcess("h3vr.exe")]
	[Description("Built with MeatKit")]
	[BepInDependency("h3vr.otherloader", "1.3.0")]
	public class GR8_Recoilless_RiflePlugin : 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(), "ShermanJumbo.GR8_Recoilless_Rifle");
			OtherLoader.RegisterDirectLoad(BasePath, "ShermanJumbo.GR8_Recoilless_Rifle", "", "", "shermanjumbo_gr8recoillessrifle", "");
		}
	}
}
namespace ShermanJumbo
{
	public class OpenBoltFakeChamberDisplay : MonoBehaviour
	{
		public OpenBoltReceiver Gun;

		public OpenBoltReceiverBolt Bolt;

		public GameObject DisplayRound;

		private void Update()
		{
			//IL_0032: 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_0048: Invalid comparison between Unknown and I4
			if ((Object)(object)((FVRFireArm)Gun).Magazine != (Object)null && ((FVRFireArm)Gun).Magazine.HasARound() && (int)Bolt.CurPos != 0 && (int)Bolt.CurPos != 1)
			{
				DisplayRound.SetActive(true);
			}
			else
			{
				DisplayRound.SetActive(false);
			}
		}
	}
	public class DoubleBarrelClosedBoltWeaponBolt : FVRInteractiveObject
	{
		public enum BoltPos
		{
			Forward,
			ForwardToMid,
			Locked,
			LockedToRear,
			Rear
		}

		[Header("Bolt")]
		public DoubleBarreledClosedBoltWeapon Weapon;

		public float Speed_Forward;

		public float Speed_Rearward;

		public float Speed_Held;

		public float SpringStiffness = 5f;

		public BoltPos CurPos;

		public BoltPos LastPos;

		public Transform Point_Bolt_Forward;

		public Transform Point_Bolt_LockPoint;

		public Transform Point_Bolt_Rear;

		public Transform Point_Bolt_SafetyLock;

		public bool HasLastRoundBoltHoldOpen = true;

		public bool UsesAKSafetyLock;

		public bool DoesClipHoldBoltOpen = true;

		private float m_curBoltSpeed;

		private float m_boltZ_current;

		private float m_boltZ_heldTarget;

		private float m_boltZ_forward;

		private float m_boltZ_lock;

		private float m_boltZ_rear;

		private float m_boltZ_safetylock;

		private bool m_isBoltLocked;

		private bool m_isHandleHeld;

		private float m_handleLerp;

		public bool HasBoltCatchReleaseButton;

		private bool m_isBoltCatchHeldOnHandle;

		private bool m_isReleaseCatchHeldOnHandle;

		[Header("Reciprocating Barrel")]
		public bool HasReciprocatingBarrel;

		public Transform Barrel;

		public Vector3 BarrelForward;

		public Vector3 BarrelRearward;

		private bool m_isBarrelReciprocating;

		[Header("Hammer")]
		public bool HasHammer;

		public Transform Hammer;

		public Vector3 HammerForward;

		public Vector3 HammerRearward;

		[Header("Rotating Bit")]
		public bool HasRotatingPart;

		public Transform RotatingPart;

		public Vector3 RotatingPartNeutralEulers;

		public Vector3 RotatingPartLeftEulers;

		public Vector3 RotatingPartRightEulers;

		[Header("Z Rot Part")]
		public bool HasZRotPart;

		public Transform ZRotPiece;

		public AnimationCurve ZRotCurve;

		public Vector2 ZAngles;

		public bool ZRotPieceDips;

		public float DipMagnitude;

		public bool ZRotPieceLags;

		public float LagMagnitude;

		[Header("Z Scale Part")]
		public bool HasZScalePart;

		public Transform ZScalePiece;

		public AnimationCurve ZScaleCurve;

		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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			((FVRInteractiveObject)this).Awake();
			m_boltZ_current = ((Component)this).transform.localPosition.z;
			m_boltZ_forward = Point_Bolt_Forward.localPosition.z;
			m_boltZ_lock = Point_Bolt_LockPoint.localPosition.z;
			m_boltZ_rear = Point_Bolt_Rear.localPosition.z;
			if (UsesAKSafetyLock)
			{
				m_boltZ_safetylock = Point_Bolt_SafetyLock.localPosition.z;
			}
		}

		public float GetBoltLerpBetweenLockAndFore()
		{
			return Mathf.InverseLerp(m_boltZ_lock, m_boltZ_forward, m_boltZ_current);
		}

		public float GetBoltLerpBetweenRearAndFore()
		{
			return Mathf.InverseLerp(m_boltZ_rear, m_boltZ_forward, m_boltZ_current);
		}

		public void LockBolt()
		{
			if (!m_isBoltLocked)
			{
				m_isBoltLocked = true;
			}
		}

		public void ReleaseBolt()
		{
			if (m_isBoltLocked)
			{
				if (!((FVRInteractiveObject)this).IsHeld)
				{
					((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)8, 1f);
				}
				m_isBoltLocked = false;
			}
		}

		public void SnapToRear()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			CurPos = BoltPos.Rear;
			m_boltZ_current = m_boltZ_rear;
			((Component)this).transform.localPosition = Point_Bolt_Rear.localPosition;
		}

		public bool IsBoltLocked()
		{
			return m_isBoltLocked;
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_003d: 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_0078: 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_0106: 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_0144: 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)
			((FVRInteractiveObject)this).UpdateInteraction(hand);
			if (HasRotatingPart)
			{
				Vector3 val = ((Component)this).transform.position - base.m_hand.PalmTransform.position;
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				if (Vector3.Dot(normalized, ((Component)this).transform.right) > 0f)
				{
					RotatingPart.localEulerAngles = RotatingPartLeftEulers;
				}
				else
				{
					RotatingPart.localEulerAngles = RotatingPartRightEulers;
				}
			}
			if (hand.IsInStreamlinedMode)
			{
				if (hand.Input.AXButtonDown && HasBoltCatchReleaseButton)
				{
					m_isBoltCatchHeldOnHandle = true;
					((FVRInteractiveObject)this).ForceBreakInteraction();
				}
				else if (hand.Input.BYButtonDown && HasBoltCatchReleaseButton)
				{
					m_isReleaseCatchHeldOnHandle = true;
					((FVRInteractiveObject)this).ForceBreakInteraction();
				}
			}
			else if (hand.Input.TouchpadDown)
			{
				if (Vector2.Angle(hand.Input.TouchpadAxes, Vector2.down) < 45f && HasBoltCatchReleaseButton)
				{
					m_isBoltCatchHeldOnHandle = true;
					((FVRInteractiveObject)this).ForceBreakInteraction();
				}
				else if (Vector2.Angle(hand.Input.TouchpadAxes, Vector2.up) < 45f && HasBoltCatchReleaseButton)
				{
					m_isReleaseCatchHeldOnHandle = true;
					((FVRInteractiveObject)this).ForceBreakInteraction();
				}
			}
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (HasRotatingPart)
			{
				RotatingPart.localEulerAngles = RotatingPartNeutralEulers;
			}
			if (!m_isBoltLocked)
			{
				m_curBoltSpeed = Speed_Forward;
			}
			if (CurPos > BoltPos.Forward)
			{
				((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)8, 1f);
			}
			if (m_isBoltCatchHeldOnHandle)
			{
				m_isBoltCatchHeldOnHandle = false;
				if (CurPos >= BoltPos.Locked)
				{
					LockBolt();
				}
			}
			if (m_isReleaseCatchHeldOnHandle)
			{
				m_isReleaseCatchHeldOnHandle = false;
				ReleaseBolt();
			}
			((FVRInteractiveObject)this).EndInteraction(hand);
		}

		public void UpdateHandleHeldState(bool state, float lerp)
		{
			m_isHandleHeld = state;
			if (state)
			{
				m_handleLerp = lerp;
			}
		}

		public void ImpartFiringImpulse()
		{
			m_curBoltSpeed = Speed_Rearward;
			if (CurPos == BoltPos.Forward)
			{
				m_isBarrelReciprocating = true;
			}
		}

		public bool IsBoltForwardOfSafetyLock()
		{
			return m_boltZ_current > m_boltZ_safetylock;
		}

		public void UpdateBolt()
		{
			//IL_0030: 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_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)
			//IL_0055: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (((FVRInteractiveObject)this).IsHeld || m_isHandleHeld)
			{
				flag = true;
			}
			if (((FVRInteractiveObject)this).IsHeld)
			{
				Vector3 closestValidPoint = ((FVRInteractiveObject)this).GetClosestValidPoint(Point_Bolt_Forward.position, Point_Bolt_Rear.position, ((HandInput)(ref base.m_hand.Input)).Pos);
				m_boltZ_heldTarget = ((Component)Weapon).transform.InverseTransformPoint(closestValidPoint).z;
			}
			else if (m_isHandleHeld)
			{
				m_boltZ_heldTarget = Mathf.Lerp(m_boltZ_forward, m_boltZ_rear, m_handleLerp);
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(m_boltZ_rear, m_boltZ_forward);
			if (m_boltZ_current <= m_boltZ_lock && m_isBoltLocked)
			{
				((Vector2)(ref val))..ctor(m_boltZ_rear, m_boltZ_lock);
			}
			if (UsesAKSafetyLock && Weapon.IsWeaponOnSafe() && m_boltZ_current <= m_boltZ_safetylock)
			{
				((Vector2)(ref val))..ctor(m_boltZ_safetylock, m_boltZ_forward);
			}
			if (DoesClipHoldBoltOpen && (Object)(object)((FVRFireArm)Weapon).Clip != (Object)null)
			{
				((Vector2)(ref val))..ctor(m_boltZ_rear, m_boltZ_lock);
			}
			if (flag)
			{
				m_curBoltSpeed = 0f;
			}
			else if ((CurPos < BoltPos.LockedToRear && m_curBoltSpeed >= 0f) || LastPos >= BoltPos.Rear)
			{
				m_curBoltSpeed = Mathf.MoveTowards(m_curBoltSpeed, Speed_Forward, Time.deltaTime * SpringStiffness);
			}
			float boltZ_current = m_boltZ_current;
			float boltZ_current2 = m_boltZ_current;
			if (flag)
			{
				boltZ_current2 = m_boltZ_heldTarget;
				boltZ_current = Mathf.MoveTowards(m_boltZ_current, boltZ_current2, Speed_Held * Time.deltaTime);
			}
			else
			{
				boltZ_current = m_boltZ_current + m_curBoltSpeed * Time.deltaTime;
			}
			boltZ_current = Mathf.Clamp(boltZ_current, val.x, val.y);
			if (Mathf.Abs(boltZ_current - m_boltZ_current) > Mathf.Epsilon)
			{
				m_boltZ_current = boltZ_current;
				((Component)this).transform.localPosition = new Vector3(((Component)this).transform.localPosition.x, ((Component)this).transform.localPosition.y, m_boltZ_current);
				if (HasReciprocatingBarrel && m_isBarrelReciprocating)
				{
					float num = 1f - GetBoltLerpBetweenLockAndFore();
					Barrel.localPosition = Vector3.Lerp(BarrelForward, BarrelRearward, num);
				}
				if (HasZRotPart)
				{
					float num2 = 1f - GetBoltLerpBetweenLockAndFore();
					float num3 = ZRotCurve.Evaluate(num2);
					ZRotPiece.localEulerAngles = new Vector3(0f, 0f, Mathf.Lerp(ZAngles.x, ZAngles.y, num3));
					if (ZRotPieceDips || ZRotPieceLags)
					{
						Vector3 zero = Vector3.zero;
						if (ZRotPieceDips)
						{
							zero.y = Mathf.Lerp(0f, 0f - DipMagnitude, num2);
						}
						if (ZRotPieceLags)
						{
							float num4 = Mathf.Abs(m_boltZ_forward - m_boltZ_current);
							zero.z = Mathf.Clamp(num4, 0f, LagMagnitude);
						}
						ZRotPiece.localPosition = zero;
					}
				}
				if (HasZScalePart)
				{
					float num5 = 1f - GetBoltLerpBetweenLockAndFore();
					float num6 = ZScaleCurve.Evaluate(num5);
					ZScalePiece.localScale = new Vector3(1f, 1f, num6);
				}
			}
			else
			{
				m_curBoltSpeed = 0f;
			}
			if (HasHammer)
			{
				if (Weapon.IsHammerCocked)
				{
					Hammer.localEulerAngles = HammerRearward;
				}
				else
				{
					float boltLerpBetweenLockAndFore = GetBoltLerpBetweenLockAndFore();
					Hammer.localEulerAngles = Vector3.Lerp(HammerRearward, HammerForward, boltLerpBetweenLockAndFore);
				}
			}
			BoltPos curPos = CurPos;
			curPos = ((!(Mathf.Abs(m_boltZ_current - m_boltZ_forward) < 0.001f)) ? ((Mathf.Abs(m_boltZ_current - m_boltZ_lock) < 0.001f) ? BoltPos.Locked : ((Mathf.Abs(m_boltZ_current - m_boltZ_rear) < 0.001f) ? BoltPos.Rear : ((m_boltZ_current > m_boltZ_lock) ? BoltPos.ForwardToMid : BoltPos.LockedToRear))) : BoltPos.Forward);
			int curPos2 = (int)CurPos;
			CurPos = curPos;
			if (CurPos >= BoltPos.ForwardToMid)
			{
				((FVRFireArm)Weapon).IsBreachOpenForGasOut = true;
			}
			else
			{
				((FVRFireArm)Weapon).IsBreachOpenForGasOut = false;
			}
			if (CurPos == BoltPos.Rear && LastPos != BoltPos.Rear)
			{
				BoltEvent_SmackRear();
			}
			if (CurPos == BoltPos.Locked && LastPos != BoltPos.Locked)
			{
				BoltEvent_BoltCaught();
			}
			if (CurPos >= BoltPos.Locked && LastPos < BoltPos.Locked)
			{
				BoltEvent_EjectRound();
			}
			if (CurPos < BoltPos.Locked && LastPos > BoltPos.ForwardToMid)
			{
				BoltEvent_ExtractRoundFromMag();
			}
			if (CurPos == BoltPos.Forward && LastPos != 0)
			{
				BoltEvent_ArriveAtFore();
			}
			if (CurPos >= BoltPos.Locked && ((HasLastRoundBoltHoldOpen && (Object)(object)((FVRFireArm)Weapon).Magazine != (Object)null && !((FVRFireArm)Weapon).Magazine.HasARound() && !Weapon.Chamber.IsFull) || Weapon.IsBoltCatchButtonHeld))
			{
				LockBolt();
			}
			LastPos = CurPos;
		}

		private void BoltEvent_ArriveAtFore()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Weapon.ChamberRound();
			if (HasReciprocatingBarrel && m_isBarrelReciprocating)
			{
				m_isBarrelReciprocating = false;
				Barrel.localPosition = BarrelForward;
			}
			if (((FVRInteractiveObject)this).IsHeld)
			{
				((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)2, 1f);
			}
			else
			{
				((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)0, 1f);
			}
		}

		private void BoltEvent_EjectRound()
		{
			Weapon.EjectExtractedRound();
			bool playPrefireSound = false;
			if (((FVRInteractiveObject)this).IsHeld || m_isHandleHeld)
			{
				playPrefireSound = true;
			}
			Weapon.CockHammer(playPrefireSound);
		}

		private void BoltEvent_ExtractRoundFromMag()
		{
			Weapon.BeginChamberingRound();
		}

		private void BoltEvent_BoltCaught()
		{
			if (m_isBoltLocked)
			{
				((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)4, 1f);
			}
		}

		private void BoltEvent_SmackRear()
		{
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Invalid comparison between Unknown and I4
			if ((((FVRInteractiveObject)this).IsHeld || m_isHandleHeld) && (!Weapon.BoltLocksWhenNoMagazineFound || (Object)(object)((FVRFireArm)Weapon).Magazine != (Object)null))
			{
				ReleaseBolt();
			}
			if (Weapon.EjectsMagazineOnEmpty && (Object)(object)((FVRFireArm)Weapon).Magazine != (Object)null && !((FVRFireArm)Weapon).Magazine.HasARound())
			{
				((FVRFireArm)Weapon).EjectMag(false);
			}
			if (Weapon.BoltLocksWhenNoMagazineFound && (Object)(object)((FVRFireArm)Weapon).Magazine == (Object)null)
			{
				LockBolt();
			}
			if (((FVRInteractiveObject)this).IsHeld || ((((Object)(object)Weapon.Handle != (Object)null && ((FVRInteractiveObject)Weapon.Handle).IsHeld) || ((Object)(object)Weapon.ForeHandle != (Object)null && (int)Weapon.ForeHandle.Mode == 1 && ((FVRInteractiveObject)Weapon.ForeHandle).IsHeld)) && ((FVRFireArm)Weapon).AudioClipSet.BoltSlideBackHeld.Clips.Count > 0))
			{
				((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)3, 1f);
			}
			else
			{
				((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)1, 1f);
			}
		}
	}
	public class DoubleBarreledClosedBoltWeapon : FVRFireArm
	{
		public enum FireSelectorModeType
		{
			Safe,
			Single,
			Burst,
			FullAuto,
			SuperFastBurst
		}

		public class FireSelectorMode
		{
			public float SelectorPosition;

			public FireSelectorModeType ModeType;

			public int BurstAmount = 3;

			public bool ARStyleBurst;

			public float EngagementDelay;
		}

		[Header("ClosedBoltWeapon Config")]
		public bool HasFireSelectorButton = true;

		public bool HasMagReleaseButton = true;

		public bool HasBoltReleaseButton = true;

		public bool HasBoltCatchButton = true;

		public bool HasHandle = true;

		public bool HasForeHandle;

		public bool HasWrap;

		[Header("Component Connections")]
		public DoubleBarrelClosedBoltWeaponBolt Bolt;

		public ClosedBoltHandle Handle;

		public ClosedBoltForeHandle ForeHandle;

		public ClosedBoltCarrierWrap CarrierWrap;

		public FVRFireArmChamber Chamber;

		public Transform Trigger;

		public Transform FireSelectorSwitch;

		public Transform FireSelectorSwitch2;

		[Header("Round Positions")]
		public Transform RoundPos_Ejecting;

		public Transform RoundPos_Ejection;

		public Transform RoundPos_MagazinePos;

		private FVRFirearmMovingProxyRound m_proxy;

		public Vector3 EjectionSpeed = new Vector3(4f, 2.5f, -1.2f);

		public Vector3 EjectionSpin = new Vector3(20f, 180f, 30f);

		public bool UsesDelinker;

		public ParticleSystem DelinkerSystem;

		[Header("Trigger Config")]
		public bool HasTrigger;

		public float TriggerFiringThreshold = 0.8f;

		public float TriggerResetThreshold = 0.4f;

		public float TriggerDualStageThreshold = 0.95f;

		public float Trigger_ForwardValue;

		public float Trigger_RearwardValue;

		public Axis TriggerAxis;

		public InterpStyle TriggerInterpStyle = (InterpStyle)1;

		public bool UsesDualStageFullAuto;

		private float m_triggerFloat;

		private bool m_hasTriggerReset;

		private int m_CamBurst;

		private bool m_isHammerCocked;

		private float m_engagementDelay;

		private int m_fireSelectorMode;

		[Header("Fire Selector Config")]
		public InterpStyle FireSelector_InterpStyle = (InterpStyle)1;

		public Axis FireSelector_Axis;

		public FireSelectorMode[] FireSelector_Modes;

		[Header("Secondary Fire Selector Config")]
		public InterpStyle FireSelector_InterpStyle2 = (InterpStyle)1;

		public Axis FireSelector_Axis2;

		public FireSelectorMode[] FireSelector_Modes2;

		[Header("Magazine Release Button")]
		public Transform MagazineReleaseButton;

		public InterpStyle MagReleaseInterp;

		public Vector3 MagReleaseUnpressed;

		public Vector3 MagReleasePressed;

		private bool WasMagReleaseHeldDown;

		[Header("Bolt Release Button")]
		public bool HasBoltReleaseVisual;

		public Transform BoltCatch;

		public InterpStyle BoltCatchInterp;

		public Vector3 BoltCatch_Caught;

		public Vector3 BoltCatch_Released;

		private bool wasBoltCaught;

		[Header("SpecialFeatures")]
		public bool EjectsMagazineOnEmpty;

		public bool BoltLocksWhenNoMagazineFound;

		public bool BoltDropsWhenMagazineInserted;

		public bool BoltDropsWhenEmptyMagazineEjected;

		public bool DoesClipEntryRequireBoltBack = true;

		public bool UsesMagMountTransformOverride;

		public Transform MagMountTransformOverride;

		public bool ReciprocatesOnShot = true;

		[Header("StickySystem")]
		public bool UsesStickyDetonation;

		public AudioEvent StickyDetonateSound;

		public Transform StickyTrigger;

		public Vector2 StickyRotRange = new Vector2(0f, 20f);

		private float m_stickyChargeUp;

		public float StickyChargeUpSpeed = 1f;

		public AudioSource m_chargeSound;

		public Renderer StickyScreen;

		public float StickyMaxMultBonus = 1.3f;

		public float StickyForceMult = 1f;

		[HideInInspector]
		public bool IsMagReleaseButtonHeld;

		[HideInInspector]
		public bool IsBoltReleaseButtonHeld;

		[HideInInspector]
		public bool IsBoltCatchButtonHeld;

		private float m_timeSinceFiredShot = 1f;

		private bool m_hasStickTriggerDown;

		private List<MF2_StickyBomb> m_primedBombs = new List<MF2_StickyBomb>();

		[Header("Double Barrel Config")]
		public FVRFireArmChamber Chamber2;

		public Transform SecondMuzzle;

		[Header("Round 2 Positions")]
		public Transform RoundPos_Ejecting2;

		public Transform RoundPos_Ejection2;

		public Transform RoundPos_MagazinePos2;

		private FVRFirearmMovingProxyRound m_proxy2;

		public Vector3 EjectionSpeed2 = new Vector3(4f, 2.5f, -1.2f);

		public Vector3 EjectionSpin2 = new Vector3(20f, 180f, 30f);

		public bool IsHammerCocked => m_isHammerCocked;

		public int FireSelectorModeIndex => m_fireSelectorMode;

		public void NukeShadows()
		{
			m_proxy.NukeShadowCasting();
			((Renderer)Chamber.ProxyRenderer).shadowCastingMode = (ShadowCastingMode)0;
			m_proxy2.NukeShadowCasting();
			((Renderer)Chamber2.ProxyRenderer).shadowCastingMode = (ShadowCastingMode)0;
		}

		public bool HasExtractedRound()
		{
			return m_proxy.IsFull;
		}

		public override void Awake()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			((FVRFireArm)this).Awake();
			base.FChambers.Add(Chamber);
			base.FChambers.Add(Chamber2);
			m_CamBurst = 0;
			ResetCamBurst();
			GameObject val = new GameObject("m_proxyRound");
			m_proxy = val.AddComponent<FVRFirearmMovingProxyRound>();
			m_proxy.Init(((Component)this).transform);
			GameObject val2 = new GameObject("m_proxyRound2");
			m_proxy2 = val2.AddComponent<FVRFirearmMovingProxyRound>();
			m_proxy2.Init(((Component)this).transform);
		}

		public void SecondaryFireSelectorClicked()
		{
			((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)15, 1f);
		}

		public void CockHammer(bool playPrefireSound = false)
		{
			if (!m_isHammerCocked)
			{
				m_isHammerCocked = true;
				if (playPrefireSound)
				{
					((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)7, 1f);
				}
			}
		}

		public void DropHammer()
		{
			if (m_isHammerCocked)
			{
				m_isHammerCocked = false;
				((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)6, 1f);
				Fire();
			}
		}

		public bool IsWeaponOnSafe()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			return FireSelector_Modes.Length != 0 && (int)FireSelector_Modes[m_fireSelectorMode].ModeType == 0;
		}

		public void ResetCamBurst()
		{
			FireSelectorMode val = FireSelector_Modes[m_fireSelectorMode];
			m_CamBurst = val.BurstAmount;
			m_engagementDelay = 0f;
		}

		protected virtual void ToggleFireSelector()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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_0149: 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)
			if (FireSelector_Modes.Length > 1)
			{
				if (Bolt.UsesAKSafetyLock && !Bolt.IsBoltForwardOfSafetyLock())
				{
					int num = m_fireSelectorMode + 1;
					if (num >= FireSelector_Modes.Length)
					{
						num -= FireSelector_Modes.Length;
					}
					if ((int)FireSelector_Modes[num].ModeType == 0)
					{
						return;
					}
				}
				m_fireSelectorMode++;
				if (m_fireSelectorMode >= FireSelector_Modes.Length)
				{
					m_fireSelectorMode -= FireSelector_Modes.Length;
				}
				FireSelectorMode val = FireSelector_Modes[m_fireSelectorMode];
				if (m_triggerFloat < 0.1f)
				{
					m_CamBurst = val.BurstAmount;
					m_engagementDelay = 0f;
				}
				((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)15, 1f);
				if ((Object)(object)FireSelectorSwitch != (Object)null)
				{
					((FVRPhysicalObject)this).SetAnimatedComponent(FireSelectorSwitch, val.SelectorPosition, FireSelector_InterpStyle, FireSelector_Axis);
				}
				if ((Object)(object)FireSelectorSwitch2 != (Object)null)
				{
					FireSelectorMode val2 = FireSelector_Modes2[m_fireSelectorMode];
					((FVRPhysicalObject)this).SetAnimatedComponent(FireSelectorSwitch2, val2.SelectorPosition, FireSelector_InterpStyle2, FireSelector_Axis2);
				}
				if (HasWrap)
				{
					CarrierWrap.OnFireModeChanged();
				}
			}
			ResetCamBurst();
		}

		public void EjectExtractedRound()
		{
			//IL_001e: 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_0039: 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_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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_00df: 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_0114: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_015a: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			if (Chamber.IsFull)
			{
				Chamber.EjectRound(RoundPos_Ejection.position, ((Component)this).transform.right * EjectionSpeed.x + ((Component)this).transform.up * EjectionSpeed.y + ((Component)this).transform.forward * EjectionSpeed.z, ((Component)this).transform.right * EjectionSpin.x + ((Component)this).transform.up * EjectionSpin.y + ((Component)this).transform.forward * EjectionSpin.z, RoundPos_Ejection.position, RoundPos_Ejection.rotation, false);
			}
			if (Chamber2.IsFull)
			{
				Chamber2.EjectRound(RoundPos_Ejection2.position, ((Component)this).transform.right * EjectionSpeed2.x + ((Component)this).transform.up * EjectionSpeed2.y + ((Component)this).transform.forward * EjectionSpeed2.z, ((Component)this).transform.right * EjectionSpin2.x + ((Component)this).transform.up * EjectionSpin2.y + ((Component)this).transform.forward * EjectionSpin2.z, RoundPos_Ejection2.position, RoundPos_Ejection2.rotation, false);
			}
		}

		public void BeginChamberingRound()
		{
			bool flag = false;
			GameObject fromPrefabReference = null;
			bool flag2 = false;
			GameObject fromPrefabReference2 = null;
			if (base.HasBelt && !m_proxy.IsFull && base.BeltDD.HasARound())
			{
				flag = true;
				fromPrefabReference = base.BeltDD.RemoveRound(false);
			}
			if (!m_proxy.IsFull && (Object)(object)base.Magazine != (Object)null && !base.Magazine.IsBeltBox && base.Magazine.HasARound())
			{
				flag = true;
				fromPrefabReference = base.Magazine.RemoveRound(false);
			}
			if (flag)
			{
				if (flag)
				{
					m_proxy.SetFromPrefabReference(fromPrefabReference);
				}
				if (!m_proxy2.IsFull && (Object)(object)base.Magazine != (Object)null && !base.Magazine.IsBeltBox && base.Magazine.HasARound())
				{
					flag2 = true;
					fromPrefabReference2 = base.Magazine.RemoveRound(false);
				}
				if (flag2 && flag2)
				{
					m_proxy2.SetFromPrefabReference(fromPrefabReference2);
				}
			}
		}

		public bool ChamberRound()
		{
			if (m_proxy.IsFull && !Chamber.IsFull)
			{
				Chamber.SetRound(m_proxy.Round, false);
				m_proxy.ClearProxy();
			}
			if (m_proxy2.IsFull && !Chamber2.IsFull)
			{
				Chamber2.SetRound(m_proxy2.Round, false);
				m_proxy2.ClearProxy();
				return true;
			}
			return false;
		}

		public override Transform GetMagMountingTransform()
		{
			if (UsesMagMountTransformOverride)
			{
				return MagMountTransformOverride;
			}
			return ((FVRFireArm)this).GetMagMountingTransform();
		}

		public override void FVRFixedUpdate()
		{
			//IL_002a: 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_0039: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_0074: 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)
			//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)
			((FVRFireArm)this).FVRFixedUpdate();
			if (UsesStickyDetonation && m_stickyChargeUp > 0f)
			{
				Rigidbody rootRigidbody = ((FVRPhysicalObject)this).RootRigidbody;
				rootRigidbody.velocity += Random.onUnitSphere * 0.2f * m_stickyChargeUp * StickyForceMult;
				Rigidbody rootRigidbody2 = ((FVRPhysicalObject)this).RootRigidbody;
				rootRigidbody2.angularVelocity += Random.onUnitSphere * 1f * m_stickyChargeUp * StickyForceMult;
			}
		}

		public bool Fire()
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Invalid comparison between Unknown and I4
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			if (!Chamber.Fire())
			{
				return false;
			}
			m_timeSinceFiredShot = 0f;
			float num = 1f;
			if (UsesStickyDetonation)
			{
				num = 1f + Mathf.Lerp(0f, StickyMaxMultBonus, m_stickyChargeUp);
			}
			((FVRFireArm)this).Fire(Chamber, ((FVRFireArm)this).GetMuzzle(), true, num, -1f);
			if (Chamber2.Fire())
			{
				((FVRFireArm)this).Fire(Chamber2, SecondMuzzle, false, num, -1f);
			}
			bool flag = ((FVRFireArm)this).IsTwoHandStabilized();
			bool flag2 = (Object)(object)((FVRPhysicalObject)this).AltGrip != (Object)null;
			bool flag3 = ((FVRFireArm)this).IsShoulderStabilized();
			((FVRFireArm)this).Recoil(flag, flag2, flag3, (FVRFireArmRecoilProfile)null, 1f);
			bool flag4 = false;
			FireSelectorMode val = FireSelector_Modes[m_fireSelectorMode];
			if ((int)val.ModeType == 4)
			{
				for (int i = 0; i < val.BurstAmount - 1; i++)
				{
					if (base.Magazine.HasARound())
					{
						base.Magazine.RemoveRound();
						((FVRFireArm)this).Fire(Chamber, ((FVRFireArm)this).GetMuzzle(), false, 1f, -1f);
						flag4 = true;
						((FVRFireArm)this).Recoil(flag, flag2, flag3, (FVRFireArmRecoilProfile)null, 1f);
					}
				}
			}
			((FVRFireArm)this).FireMuzzleSmoke();
			if (UsesDelinker && base.HasBelt)
			{
				DelinkerSystem.Emit(1);
			}
			if (base.HasBelt)
			{
				base.BeltDD.PopEjectFlaps();
				base.BeltDD.AddJitter();
			}
			if (flag4)
			{
				((FVRFireArm)this).PlayAudioGunShot(false, Chamber.GetRound().TailClass, Chamber.GetRound().TailClassSuppressed, GM.CurrentPlayerBody.GetCurrentSoundEnvironment());
			}
			else
			{
				((FVRFireArm)this).PlayAudioGunShot(Chamber.GetRound(), GM.CurrentPlayerBody.GetCurrentSoundEnvironment(), 1f);
			}
			if (ReciprocatesOnShot && (!HasForeHandle || (int)ForeHandle.Mode == 0))
			{
				Bolt.ImpartFiringImpulse();
			}
			return true;
		}

		public override void FVRUpdate()
		{
			((FVRFireArm)this).FVRUpdate();
			UpdateComponents();
			if (m_engagementDelay > 0f)
			{
				m_engagementDelay -= Time.deltaTime;
			}
			if (HasHandle)
			{
				Handle.UpdateHandle();
				Bolt.UpdateHandleHeldState(Handle.ShouldControlBolt(), 1f - Handle.GetBoltLerpBetweenLockAndFore());
			}
			if (HasWrap)
			{
				CarrierWrap.UpdateWrap();
			}
			Bolt.UpdateBolt();
			if (base.UsesClips && DoesClipEntryRequireBoltBack)
			{
				if (Bolt.CurPos >= DoubleBarrelClosedBoltWeaponBolt.BoltPos.Locked)
				{
					if (!base.ClipTrigger.activeSelf)
					{
						base.ClipTrigger.SetActive(true);
					}
				}
				else if (base.ClipTrigger.activeSelf)
				{
					base.ClipTrigger.SetActive(false);
				}
			}
			UpdateDisplayRoundPositions();
			if (m_timeSinceFiredShot < 1f)
			{
				m_timeSinceFiredShot += Time.deltaTime;
			}
		}

		public override void LoadMag(FVRFireArmMagazine mag)
		{
			((FVRFireArm)this).LoadMag(mag);
			if ((BoltLocksWhenNoMagazineFound || (BoltDropsWhenMagazineInserted && mag.HasARound())) && (Object)(object)mag != (Object)null && Bolt.IsBoltLocked())
			{
				Bolt.ReleaseBolt();
			}
		}

		public override void EjectMag(bool PhysicalRelease = false)
		{
			bool flag = false;
			if ((Object)(object)base.Magazine != (Object)null && !base.Magazine.HasARound())
			{
				flag = true;
			}
			((FVRFireArm)this).EjectMag(PhysicalRelease);
			if (Bolt.IsBoltLocked() && flag && BoltDropsWhenEmptyMagazineEjected)
			{
				Bolt.ReleaseBolt();
			}
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			((FVRPhysicalObject)this).UpdateInteraction(hand);
			UpdateInputAndAnimate(hand);
		}

		private void UpdateInputAndAnimate(FVRViveHand hand)
		{
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: 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_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: 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_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_062f: Invalid comparison between Unknown and I4
			//IL_063f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Invalid comparison between Unknown and I4
			//IL_0662: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Invalid comparison between Unknown and I4
			IsBoltReleaseButtonHeld = false;
			IsBoltCatchButtonHeld = false;
			IsMagReleaseButtonHeld = false;
			if (((FVRPhysicalObject)this).IsAltHeld)
			{
				return;
			}
			if (((FVRInteractiveObject)this).m_hasTriggeredUpSinceBegin && m_engagementDelay <= 0f)
			{
				m_triggerFloat = hand.Input.TriggerFloat;
			}
			else
			{
				m_triggerFloat = 0f;
			}
			if (!m_hasTriggerReset && m_triggerFloat <= TriggerResetThreshold)
			{
				m_hasTriggerReset = true;
				if (FireSelector_Modes.Length > 0)
				{
					if (FireSelector_Modes[m_fireSelectorMode].ARStyleBurst && m_CamBurst <= 0)
					{
						m_CamBurst = FireSelector_Modes[m_fireSelectorMode].BurstAmount;
					}
					else if (!FireSelector_Modes[m_fireSelectorMode].ARStyleBurst)
					{
						m_CamBurst = FireSelector_Modes[m_fireSelectorMode].BurstAmount;
					}
					m_engagementDelay = FireSelector_Modes[m_fireSelectorMode].EngagementDelay;
				}
				((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)16, 1f);
			}
			if (hand.IsInStreamlinedMode)
			{
				if (hand.Input.BYButtonDown)
				{
					if (Bolt.IsBoltLocked() && HasBoltReleaseButton)
					{
						Bolt.ReleaseBolt();
					}
					else
					{
						ToggleFireSelector();
					}
					if (UsesStickyDetonation)
					{
						Detonate();
					}
				}
				if (hand.Input.AXButtonDown && HasMagReleaseButton && (!EjectsMagazineOnEmpty || (Bolt.CurPos >= DoubleBarrelClosedBoltWeaponBolt.BoltPos.Locked && ((FVRInteractiveObject)Bolt).IsHeld && !m_proxy.IsFull)))
				{
					ReleaseMag();
				}
				if (hand.Input.AXButtonPressed && HasMagReleaseButton)
				{
					IsMagReleaseButtonHeld = true;
				}
				if (UsesStickyDetonation)
				{
					if (hand.Input.BYButtonDown)
					{
						((FVRPhysicalObject)this).SetAnimatedComponent(StickyTrigger, StickyRotRange.y, (InterpStyle)1, (Axis)0);
					}
					else if (hand.Input.BYButtonUp)
					{
						((FVRPhysicalObject)this).SetAnimatedComponent(StickyTrigger, StickyRotRange.x, (InterpStyle)1, (Axis)0);
					}
				}
			}
			else
			{
				Vector2 touchpadAxes = hand.Input.TouchpadAxes;
				if (hand.Input.TouchpadDown)
				{
					if (UsesStickyDetonation)
					{
						Detonate();
					}
					if (((Vector2)(ref touchpadAxes)).magnitude > 0.2f)
					{
						if (Vector2.Angle(touchpadAxes, Vector2.left) <= 45f)
						{
							ToggleFireSelector();
						}
						else if (Vector2.Angle(touchpadAxes, Vector2.up) <= 45f)
						{
							if (HasBoltReleaseButton)
							{
								Bolt.ReleaseBolt();
							}
						}
						else if (Vector2.Angle(touchpadAxes, Vector2.down) <= 45f && HasMagReleaseButton && (!EjectsMagazineOnEmpty || (Bolt.CurPos >= DoubleBarrelClosedBoltWeaponBolt.BoltPos.Locked && ((FVRInteractiveObject)Bolt).IsHeld && !m_proxy.IsFull)))
						{
							ReleaseMag();
						}
					}
				}
				if (UsesStickyDetonation)
				{
					if (hand.Input.TouchpadDown)
					{
						((FVRPhysicalObject)this).SetAnimatedComponent(StickyTrigger, StickyRotRange.y, (InterpStyle)1, (Axis)0);
					}
					else if (hand.Input.TouchpadUp)
					{
						((FVRPhysicalObject)this).SetAnimatedComponent(StickyTrigger, StickyRotRange.x, (InterpStyle)1, (Axis)0);
					}
				}
				if (hand.Input.TouchpadPressed && ((Vector2)(ref touchpadAxes)).magnitude > 0.2f)
				{
					if (Vector2.Angle(touchpadAxes, Vector2.up) <= 45f)
					{
						if (HasBoltReleaseButton)
						{
							IsBoltReleaseButtonHeld = true;
						}
					}
					else if (Vector2.Angle(touchpadAxes, Vector2.right) <= 45f)
					{
						if (HasBoltCatchButton)
						{
							IsBoltCatchButtonHeld = true;
						}
					}
					else if (Vector2.Angle(touchpadAxes, Vector2.down) <= 45f && HasMagReleaseButton)
					{
						IsMagReleaseButtonHeld = true;
					}
				}
			}
			FireSelectorModeType modeType = FireSelector_Modes[m_fireSelectorMode].ModeType;
			if ((int)modeType == 0 || !((FVRInteractiveObject)this).m_hasTriggeredUpSinceBegin)
			{
				return;
			}
			if (UsesStickyDetonation)
			{
				if (Bolt.CurPos != 0 || !Chamber.IsFull || Chamber.IsSpent)
				{
					return;
				}
				if (hand.Input.TriggerPressed && m_hasTriggerReset)
				{
					m_hasStickTriggerDown = true;
					m_stickyChargeUp += Time.deltaTime * 0.25f * StickyChargeUpSpeed;
					m_stickyChargeUp = Mathf.Clamp(m_stickyChargeUp, 0f, 1f);
					if (m_stickyChargeUp > 0.05f && !m_chargeSound.isPlaying)
					{
						m_chargeSound.Play();
					}
				}
				else
				{
					if (m_chargeSound.isPlaying)
					{
						m_chargeSound.Stop();
					}
					m_stickyChargeUp = 0f;
				}
				if (m_hasStickTriggerDown && (hand.Input.TriggerUp || m_stickyChargeUp >= 1f))
				{
					m_hasStickTriggerDown = false;
					DropHammer();
					EndStickyCharge();
				}
			}
			else if (m_triggerFloat >= TriggerFiringThreshold && Bolt.CurPos == DoubleBarrelClosedBoltWeaponBolt.BoltPos.Forward && (m_hasTriggerReset || ((int)modeType == 3 && !UsesDualStageFullAuto) || ((int)modeType == 3 && UsesDualStageFullAuto && m_triggerFloat > TriggerDualStageThreshold) || ((int)modeType == 2 && m_CamBurst > 0)))
			{
				DropHammer();
				m_hasTriggerReset = false;
				if (m_CamBurst > 0)
				{
					m_CamBurst--;
				}
			}
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			if (UsesStickyDetonation)
			{
				EndStickyCharge();
			}
			((FVRFireArm)this).EndInteraction(hand);
		}

		private void EndStickyCharge()
		{
			m_chargeSound.Stop();
			m_stickyChargeUp = 0f;
		}

		private void UpdateComponents()
		{
			//IL_002c: 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_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			if (HasTrigger)
			{
				((FVRPhysicalObject)this).SetAnimatedComponent(Trigger, Mathf.Lerp(Trigger_ForwardValue, Trigger_RearwardValue, m_triggerFloat), TriggerInterpStyle, TriggerAxis);
			}
			if (HasMagReleaseButton && (Object)(object)MagazineReleaseButton != (Object)null)
			{
				float num = 0f;
				if (IsMagReleaseButtonHeld)
				{
					num = 1f;
				}
				Vector3 val = Vector3.Lerp(MagReleaseUnpressed, MagReleasePressed, num);
				if (WasMagReleaseHeldDown != IsMagReleaseButtonHeld)
				{
					WasMagReleaseHeldDown = IsMagReleaseButtonHeld;
					((FVRPhysicalObject)this).SetAnimatedComponent(MagazineReleaseButton, val, MagReleaseInterp);
				}
			}
			if (HasBoltReleaseVisual)
			{
				bool flag = false;
				if (Bolt.IsBoltLocked())
				{
					flag = true;
				}
				if (wasBoltCaught != flag)
				{
					wasBoltCaught = flag;
					if (flag)
					{
						((FVRPhysicalObject)this).SetAnimatedComponent(BoltCatch, BoltCatch_Caught, BoltCatchInterp);
					}
					else
					{
						((FVRPhysicalObject)this).SetAnimatedComponent(BoltCatch, BoltCatch_Released, BoltCatchInterp);
					}
				}
			}
			if (UsesStickyDetonation)
			{
				float num2 = Mathf.Clamp((float)m_primedBombs.Count / 8f, 0f, 1f);
				float num3 = Mathf.Lerp(0.56f, 0.23f, num2);
				float num4 = Mathf.Lerp(5f, 15f, num2);
				StickyScreen.material.SetTextureOffset("_IncandescenceMap", new Vector2(0f, num3));
			}
		}

		private void UpdateDisplayRoundPositions()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0070: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00e4: 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_0117: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_018b: 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_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			float boltLerpBetweenLockAndFore = Bolt.GetBoltLerpBetweenLockAndFore();
			if (Chamber.IsFull)
			{
				Chamber.ProxyRound.position = Vector3.Lerp(RoundPos_Ejecting.position, ((Component)Chamber).transform.position, boltLerpBetweenLockAndFore);
				Chamber.ProxyRound.rotation = Quaternion.Slerp(RoundPos_Ejecting.rotation, ((Component)Chamber).transform.rotation, boltLerpBetweenLockAndFore);
			}
			if (m_proxy.IsFull)
			{
				m_proxy.ProxyRound.position = Vector3.Lerp(RoundPos_MagazinePos.position, ((Component)Chamber).transform.position, boltLerpBetweenLockAndFore);
				m_proxy.ProxyRound.rotation = Quaternion.Slerp(RoundPos_MagazinePos.rotation, ((Component)Chamber).transform.rotation, boltLerpBetweenLockAndFore);
			}
			if (Chamber2.IsFull)
			{
				Chamber2.ProxyRound.position = Vector3.Lerp(RoundPos_Ejecting2.position, ((Component)Chamber2).transform.position, boltLerpBetweenLockAndFore);
				Chamber2.ProxyRound.rotation = Quaternion.Slerp(RoundPos_Ejecting2.rotation, ((Component)Chamber2).transform.rotation, boltLerpBetweenLockAndFore);
			}
			if (m_proxy2.IsFull)
			{
				m_proxy2.ProxyRound.position = Vector3.Lerp(RoundPos_MagazinePos2.position, ((Component)Chamber2).transform.position, boltLerpBetweenLockAndFore);
				m_proxy2.ProxyRound.rotation = Quaternion.Slerp(RoundPos_MagazinePos2.rotation, ((Component)Chamber2).transform.rotation, boltLerpBetweenLockAndFore);
			}
		}

		public void ReleaseMag()
		{
			if ((Object)(object)base.Magazine != (Object)null)
			{
				((FVRFireArm)this).EjectMag(false);
			}
		}

		public void RegisterStickyBomb(MF2_StickyBomb sb)
		{
			if ((Object)(object)sb != (Object)null)
			{
				m_primedBombs.Add(sb);
			}
		}

		public void Detonate()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (m_primedBombs.Count > 0)
			{
				for (int num = m_primedBombs.Count - 1; num >= 0; num--)
				{
					if ((Object)(object)m_primedBombs[num] != (Object)null && m_primedBombs[num].m_hasStuck && !m_primedBombs[num].m_hasExploded)
					{
						flag = true;
						m_primedBombs[num].Detonate();
						m_primedBombs.RemoveAt(num);
					}
				}
			}
			if (flag)
			{
				SM.PlayCoreSound((FVRPooledAudioType)10, StickyDetonateSound, ((Component)this).transform.position);
			}
		}

		public override List<FireArmRoundClass> GetChamberRoundList()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (Chamber.IsFull && !Chamber.IsSpent)
			{
				List<FireArmRoundClass> list = new List<FireArmRoundClass>();
				list.Add(Chamber.GetRound().RoundClass);
				return list;
			}
			return null;
		}

		public override void SetLoadedChambers(List<FireArmRoundClass> rounds)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (rounds.Count > 0)
			{
				Chamber.Autochamber(rounds[0]);
			}
		}

		public override void ConfigureFromFlagDic(Dictionary<string, string> f)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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)
			string empty = string.Empty;
			string empty2 = string.Empty;
			empty = "HammerState";
			if (f.ContainsKey(empty))
			{
				empty2 = f[empty];
				if (empty2 == "Cocked")
				{
					m_isHammerCocked = true;
				}
			}
			if (FireSelector_Modes.Length > 1)
			{
				empty = "FireSelectorState";
				if (f.ContainsKey(empty))
				{
					empty2 = f[empty];
					int.TryParse(empty2, out m_fireSelectorMode);
				}
				if ((Object)(object)FireSelectorSwitch != (Object)null)
				{
					FireSelectorMode val = FireSelector_Modes[m_fireSelectorMode];
					((FVRPhysicalObject)this).SetAnimatedComponent(FireSelectorSwitch, val.SelectorPosition, FireSelector_InterpStyle, FireSelector_Axis);
				}
				if ((Object)(object)FireSelectorSwitch2 != (Object)null)
				{
					FireSelectorMode val2 = FireSelector_Modes2[m_fireSelectorMode];
					((FVRPhysicalObject)this).SetAnimatedComponent(FireSelectorSwitch2, val2.SelectorPosition, FireSelector_InterpStyle2, FireSelector_Axis2);
				}
			}
			((FVRFireArm)this).ConfigureFromFlagDic(f);
		}

		public override Dictionary<string, string> GetFlagDic()
		{
			Dictionary<string, string> flagDic = ((FVRFireArm)this).GetFlagDic();
			string key = "HammerState";
			string value = "Uncocked";
			if (m_isHammerCocked)
			{
				value = "Cocked";
			}
			flagDic.Add(key, value);
			if (FireSelector_Modes.Length > 1)
			{
				key = "FireSelectorState";
				value = m_fireSelectorMode.ToString();
				flagDic.Add(key, value);
			}
			return flagDic;
		}
	}
	public class GR8RecoillessRifle : FVRFireArm
	{
		public FVRFireArmChamber Chamber;

		public GR8ShellInsertEject ShellInsertEject;

		public GR8TailLatch TailLatch;

		private float m_curZ;

		private float m_tarZ;

		public float ZThreshold = 0.01f;

		public Transform Trigger;

		public float TriggerFiringThreshold = 0.8f;

		public float TriggerResetThreshold = 0.4f;

		public float Trigger_ForwardValue;

		public float Trigger_RearwardValue;

		private float m_triggerFloat;

		private float m_lastTriggerFloat;

		private bool m_hasTriggerReset;

		public AudioEvent AudEvent_BackSound;

		public Transform COM;

		public override void Awake()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			((FVRFireArm)this).Awake();
			base.FChambers.Add(Chamber);
			((FVRPhysicalObject)this).RootRigidbody.centerOfMass = COM.localPosition;
		}

		public void FixCOM()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			((FVRPhysicalObject)this).RootRigidbody.centerOfMass = COM.localPosition;
		}

		public override void FVRUpdate()
		{
			((FVRFireArm)this).FVRUpdate();
			if (TailLatch.LState == GR8TailLatch.CGLatchState.Open)
			{
				Chamber.IsAccessible = true;
			}
			else
			{
				Chamber.IsAccessible = false;
			}
			if (Mathf.Abs(m_triggerFloat - m_lastTriggerFloat) > 0.0001f)
			{
				m_lastTriggerFloat = m_triggerFloat;
				((FVRPhysicalObject)this).SetAnimatedComponent(Trigger, Mathf.Lerp(Trigger_ForwardValue, Trigger_RearwardValue, m_triggerFloat), (InterpStyle)1, (Axis)0);
			}
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			((FVRPhysicalObject)this).UpdateInteraction(hand);
			if (((FVRPhysicalObject)this).IsAltHeld)
			{
				m_triggerFloat = 0f;
				return;
			}
			if (((FVRInteractiveObject)this).m_hasTriggeredUpSinceBegin)
			{
				m_triggerFloat = hand.Input.TriggerFloat;
			}
			else
			{
				m_triggerFloat = 0f;
			}
			if (!m_hasTriggerReset && m_triggerFloat <= TriggerResetThreshold)
			{
				m_hasTriggerReset = true;
				((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)16, 1f);
			}
			if (((FVRInteractiveObject)this).m_hasTriggeredUpSinceBegin && m_triggerFloat >= TriggerFiringThreshold && TailLatch.LState == GR8TailLatch.CGLatchState.Closed && m_hasTriggerReset)
			{
				m_hasTriggerReset = false;
				TryToFire();
			}
		}

		private void TryToFire()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)6, 1f);
			if (Chamber.Fire())
			{
				((FVRFireArm)this).PlayAudioGunShot(Chamber.GetRound(), GM.CurrentPlayerBody.GetCurrentSoundEnvironment(), 1f);
				((FVRFireArm)this).Fire(Chamber, ((FVRFireArm)this).GetMuzzle(), true, 1f, -1f);
				((FVRFireArm)this).FireMuzzleSmoke();
				SM.PlayCoreSound((FVRPooledAudioType)5, AudEvent_BackSound, ((Component)TailLatch).transform.position);
				bool flag = ((FVRFireArm)this).IsTwoHandStabilized();
				bool flag2 = (Object)(object)((FVRPhysicalObject)this).AltGrip != (Object)null;
				bool flag3 = ((FVRFireArm)this).IsShoulderStabilized();
				((FVRFireArm)this).Recoil(flag, flag2, flag3, (FVRFireArmRecoilProfile)null, 1f);
			}
		}
	}
	public class GR8ShellInsertEject : FVRInteractiveObject
	{
		public enum ChamberSlideState
		{
			In,
			Middle,
			Out
		}

		public GR8RecoillessRifle CG;

		public AudioEvent AudEvent_ShellInStart;

		public AudioEvent AudEvent_ShellIn;

		public AudioEvent AudEvent_ShellOutStart;

		public AudioEvent AudEvent_ShellOut;

		public Transform ChamberPoint_Back;

		public Transform ChamberPoint_Forward;

		public Collider Col;

		public ChamberSlideState CSState = ChamberSlideState.Out;

		private float m_curZ;

		private float m_tarZ;

		public float ZThreshold = 0.02f;

		private float m_timeHeld;

		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)
			((FVRInteractiveObject)this).Awake();
			m_curZ = ChamberPoint_Back.localPosition.z;
			m_tarZ = m_curZ;
		}

		public override bool IsInteractable()
		{
			return CG.Chamber.IsFull && CG.TailLatch.LState == GR8TailLatch.CGLatchState.Open;
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			//IL_0019: 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_0023: 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_0044: 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)
			((FVRInteractiveObject)this).UpdateInteraction(hand);
			float tarZ = Mathf.Clamp(((Component)CG).transform.InverseTransformPoint(((HandInput)(ref hand.Input)).Pos).z, ChamberPoint_Back.localPosition.z, ChamberPoint_Forward.localPosition.z);
			m_tarZ = tarZ;
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			//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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			((FVRInteractiveObject)this).EndInteraction(hand);
			float num = Mathf.Abs(m_curZ - ChamberPoint_Back.localPosition.z);
			float num2 = Mathf.Abs(m_curZ - ChamberPoint_Forward.localPosition.z);
			if (num < ZThreshold * 2f)
			{
				m_tarZ = ChamberPoint_Back.localPosition.z;
			}
			else if (num2 < ZThreshold * 2f)
			{
				m_tarZ = ChamberPoint_Forward.localPosition.z;
			}
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			((FVRInteractiveObject)this).BeginInteraction(hand);
			m_timeHeld = 0f;
		}

		public override void FVRUpdate()
		{
			//IL_0078: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c3: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			((FVRInteractiveObject)this).FVRUpdate();
			m_timeHeld += Time.deltaTime;
			if (!(Mathf.Abs(m_curZ - m_tarZ) > 0.001f))
			{
				return;
			}
			m_curZ = Mathf.MoveTowards(m_curZ, m_tarZ, Time.deltaTime * 1f);
			((Component)CG.Chamber).transform.localPosition = new Vector3(((Component)CG.Chamber).transform.localPosition.x, ((Component)CG.Chamber).transform.localPosition.y, m_curZ);
			float num = Mathf.Abs(m_curZ - ChamberPoint_Back.localPosition.z);
			float num2 = Mathf.Abs(m_curZ - ChamberPoint_Forward.localPosition.z);
			ChamberSlideState cSState = CSState;
			if (num < ZThreshold)
			{
				CSState = ChamberSlideState.Out;
			}
			else if (num2 < ZThreshold)
			{
				CSState = ChamberSlideState.In;
			}
			else
			{
				CSState = ChamberSlideState.Middle;
			}
			if (CSState == ChamberSlideState.Out && cSState != ChamberSlideState.Out)
			{
				((FVRFireArm)CG).PlayAudioAsHandling(AudEvent_ShellOut, ((Component)this).transform.position);
				if (m_timeHeld > 0.2f)
				{
					FVRFireArmRound val = CG.Chamber.EjectRound(((Component)ChamberPoint_Back).transform.position, ChamberPoint_Back.forward * 0.1f, Vector3.zero, false);
					if (((FVRInteractiveObject)this).IsHeld)
					{
						FVRViveHand hand = base.m_hand;
						hand.ForceSetInteractable((FVRInteractiveObject)(object)val);
						((FVRInteractiveObject)val).BeginInteraction(hand);
					}
					CG.FixCOM();
				}
			}
			else if (CSState == ChamberSlideState.In && cSState != 0)
			{
				((FVRFireArm)CG).PlayAudioAsHandling(AudEvent_ShellIn, ((Component)this).transform.position);
				((FVRInteractiveObject)this).ForceBreakInteraction();
				CG.FixCOM();
			}
			else if (CSState == ChamberSlideState.Middle && cSState == ChamberSlideState.In)
			{
				((FVRFireArm)CG).PlayAudioAsHandling(AudEvent_ShellOutStart, ((Component)this).transform.position);
			}
			else if (CSState == ChamberSlideState.Middle && cSState == ChamberSlideState.Out)
			{
				((FVRFireArm)CG).PlayAudioAsHandling(AudEvent_ShellInStart, ((Component)this).transform.position);
			}
		}
	}
	public class GR8TailLatch : FVRInteractiveObject
	{
		public enum CGLatchType
		{
			Main,
			Lock
		}

		public enum CGLatchState
		{
			Closed,
			Middle,
			Open
		}

		public GR8RecoillessRifle CG;

		public CGLatchType LType;

		public CGLatchState LState;

		public float RotMin;

		public float RotMax;

		public bool IsMinOpen;

		public AudioEvent AudEvent_Open;

		public AudioEvent AudEvent_Close;

		public Transform BaseZeroDir;

		private float m_curRot;

		private float m_tarRot;

		public bool DisablesUseWhenNotInGivenState = true;

		public GR8TailLatch RestrictingLatch;

		public CGLatchState RequiredState = CGLatchState.Open;

		public bool DoesPartialChamberingBlock;

		public bool IsOpen()
		{
			return LState == CGLatchState.Open;
		}

		public override bool IsInteractable()
		{
			return (!DoesPartialChamberingBlock || !CG.Chamber.IsFull || CG.ShellInsertEject.CSState == GR8ShellInsertEject.ChamberSlideState.In) && (!DisablesUseWhenNotInGivenState || RestrictingLatch.LState == RequiredState) && ((FVRInteractiveObject)this).IsInteractable();
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			//IL_000e: 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_001e: 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_0024: 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)
			//IL_0035: 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_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)
			((FVRInteractiveObject)this).UpdateInteraction(hand);
			Vector3 val = ((HandInput)(ref hand.Input)).Pos - ((Component)this).transform.position;
			val = Vector3.ProjectOnPlane(val, BaseZeroDir.up);
			float signedAngle = GetSignedAngle(val, BaseZeroDir.forward, BaseZeroDir.up);
			signedAngle = Mathf.Clamp(signedAngle, RotMin, RotMax);
			m_tarRot = signedAngle;
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			((FVRInteractiveObject)this).EndInteraction(hand);
			float num = Mathf.Abs(m_curRot - RotMin);
			float num2 = Mathf.Abs(m_curRot - RotMax);
			if (num < num2)
			{
				m_tarRot = RotMin;
			}
			else
			{
				m_tarRot = RotMax;
			}
		}

		public override void FVRUpdate()
		{
			//IL_005c: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			((FVRInteractiveObject)this).FVRUpdate();
			if (!(Mathf.Abs(m_curRot - m_tarRot) > 0.001f))
			{
				return;
			}
			m_curRot = Mathf.MoveTowards(m_curRot, m_tarRot, Time.deltaTime * 900f);
			((Component)this).transform.localEulerAngles = new Vector3(0f, m_curRot, 0f);
			float num = Mathf.Abs(m_curRot - RotMin);
			float num2 = Mathf.Abs(m_curRot - RotMax);
			CGLatchState lState = LState;
			if (num < 1f)
			{
				if (IsMinOpen)
				{
					LState = CGLatchState.Open;
				}
				else
				{
					LState = CGLatchState.Closed;
				}
			}
			else if (num2 < 1f)
			{
				if (IsMinOpen)
				{
					LState = CGLatchState.Closed;
				}
				else
				{
					LState = CGLatchState.Open;
				}
			}
			else
			{
				LState = CGLatchState.Middle;
			}
			if (LState == CGLatchState.Closed && lState != 0)
			{
				((FVRFireArm)CG).PlayAudioAsHandling(AudEvent_Close, ((Component)this).transform.position);
			}
			else if (LState == CGLatchState.Open && lState != CGLatchState.Open)
			{
				((FVRFireArm)CG).PlayAudioAsHandling(AudEvent_Open, ((Component)this).transform.position);
			}
		}

		public float GetSignedAngle(Vector3 from, Vector3 to, Vector3 axis)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_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_001a: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.ProjectOnPlane(from, axis);
			from = ((Vector3)(ref val)).normalized;
			Vector3 val2 = Vector3.Cross(axis, to);
			float num = Mathf.Sign(Vector3.Dot(from, val2));
			float num2 = Vector3.Angle(from, to);
			return num2 * num;
		}
	}
	[RequireComponent(typeof(FirearmHeatingEffect))]
	public class OverheatingWeapon : MonoBehaviour
	{
		public FirearmHeatingEffect HeatingEffect;

		[Tooltip("If enabled, the firearm will have unlimited ammunition but will deplete its magazine (heatsink) if it hits maximum heat to force a reload. Swapping sinks after hitting max heat will instantly reset the heat to zero. If disabled, the gun + magazine will function conventionally, but hitting max heat will force the gun into an overheat state where it can't fire until it cools down completely.")]
		public bool UsesHeatsinkBehavior;

		[Tooltip("If enabled, and if this also uses heatsink behavior, the gun will automatically eject its mag (heatsink) when it burns out.")]
		public bool AutoEjectsSpentHeatsink;

		[Tooltip("If enabled, automatically cycle the bolt when the gun cools down completely after overheating. If this UsesHeatsinkBehavior, it auto-racks the bolt when a new heatsink is inserted. Only works for Open Bolts, Closed Bolts, and Handguns.")]
		public bool AutoCycleBoltOnCooldown;

		private bool IsCoolingToZero;

		private FVRFireArm Weapon;

		private float CurrentHeat;

		private Handgun hg;

		private ClosedBoltWeapon cbw;

		private OpenBoltReceiver obr;

		[Tooltip("When cooling down from overheated, the cooldown rate is multiplied by this number.")]
		public float OverheatCooldownMultiplier = 1f;

		private float BaseCooldownRate;

		[Tooltip("Optional. When overheated, play these particle systems until the gun has cooled down fully.")]
		public ParticleSystem[] OverheatedParticles;

		public AudioEvent OverheatSound;

		public AudioEvent CoolingSound;

		private void Start()
		{
			Weapon = HeatingEffect.FireArm;
			BaseCooldownRate = HeatingEffect.CooldownRate;
			if (AutoCycleBoltOnCooldown)
			{
				if (Weapon is Handgun)
				{
					ref Handgun reference = ref hg;
					FVRFireArm weapon = Weapon;
					reference = (Handgun)(object)((weapon is Handgun) ? weapon : null);
				}
				if (Weapon is ClosedBoltWeapon)
				{
					ref ClosedBoltWeapon reference2 = ref cbw;
					FVRFireArm weapon2 = Weapon;
					reference2 = (ClosedBoltWeapon)(object)((weapon2 is ClosedBoltWeapon) ? weapon2 : null);
				}
				if (Weapon is OpenBoltReceiver)
				{
					ref OpenBoltReceiver reference3 = ref obr;
					FVRFireArm weapon3 = Weapon;
					reference3 = (OpenBoltReceiver)(object)((weapon3 is OpenBoltReceiver) ? weapon3 : null);
				}
			}
			StopOverheatedParticles();
		}

		private void Update()
		{
			CurrentHeat = HeatingEffect.Heat;
			FVRFireArmMagazine magazine = Weapon.Magazine;
			if (!((Object)(object)magazine == (Object)null))
			{
				if (UsesHeatsinkBehavior)
				{
					HandleHeatsinkBehavior(magazine);
				}
				else
				{
					HandleStandardOverheat(magazine);
				}
			}
		}

		private void HandleHeatsinkBehavior(FVRFireArmMagazine mag)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if (CurrentHeat >= 1f && !IsCoolingToZero)
			{
				IsCoolingToZero = true;
				mag.IsInfinite = false;
				mag.ForceEmpty();
				SM.PlayCoreSound((FVRPooledAudioType)0, OverheatSound, ((Component)this).transform.position);
				HeatingEffect.CooldownRate = BaseCooldownRate * OverheatCooldownMultiplier;
				if (AutoEjectsSpentHeatsink)
				{
					Weapon.EjectMag(false);
				}
				PlayOverheatedParticles();
			}
			if (!IsCoolingToZero)
			{
				mag.IsInfinite = true;
			}
			if (IsCoolingToZero && (Object)(object)mag != (Object)null && mag.HasARound() && mag.IsExtractable)
			{
				HeatingEffect.Heat = 0f;
				IsCoolingToZero = false;
				mag.IsInfinite = true;
				HeatingEffect.CooldownRate = BaseCooldownRate;
				SM.PlayCoreSound((FVRPooledAudioType)0, CoolingSound, ((Component)this).transform.position);
				AutoCycleBolt();
				StopOverheatedParticles();
			}
		}

		private void HandleStandardOverheat(FVRFireArmMagazine mag)
		{
			//IL_0050: 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)
			if (CurrentHeat >= 1f && !IsCoolingToZero)
			{
				IsCoolingToZero = true;
				mag.IsExtractable = false;
				HeatingEffect.CooldownRate = BaseCooldownRate * OverheatCooldownMultiplier;
				SM.PlayCoreSound((FVRPooledAudioType)0, OverheatSound, ((Component)this).transform.position);
				PlayOverheatedParticles();
			}
			if (!IsCoolingToZero)
			{
				mag.IsExtractable = true;
			}
			if (IsCoolingToZero && CurrentHeat <= 0f)
			{
				IsCoolingToZero = false;
				mag.IsExtractable = true;
				HeatingEffect.CooldownRate = BaseCooldownRate;
				SM.PlayCoreSound((FVRPooledAudioType)0, CoolingSound, ((Component)this).transform.position);
				AutoCycleBolt();
				StopOverheatedParticles();
			}
		}

		private void PlayOverheatedParticles()
		{
			if (OverheatedParticles == null)
			{
				return;
			}
			ParticleSystem[] overheatedParticles = OverheatedParticles;
			foreach (ParticleSystem val in overheatedParticles)
			{
				if ((Object)(object)val != (Object)null && !val.isPlaying)
				{
					val.Play();
				}
			}
		}

		private void StopOverheatedParticles()
		{
			if (OverheatedParticles == null)
			{
				return;
			}
			ParticleSystem[] overheatedParticles = OverheatedParticles;
			foreach (ParticleSystem val in overheatedParticles)
			{
				if ((Object)(object)val != (Object)null && val.isPlaying)
				{
					val.Stop();
				}
			}
		}

		private void AutoCycleBolt()
		{
			if ((Object)(object)hg != (Object)null)
			{
				hg.Slide.ImpartFiringImpulse();
			}
			if ((Object)(object)cbw != (Object)null)
			{
				cbw.Bolt.ImpartFiringImpulse();
			}
			if ((Object)(object)obr != (Object)null)
			{
				obr.Bolt.ImpartFiringImpulse();
			}
		}
	}
}
public class DynamicBoneDemo1 : MonoBehaviour
{
	public GameObject m_Player;

	private float m_weight = 1f;

	private void Update()
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: 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_006a: Unknown result type (might be due to invalid IL or missing references)
		m_Player.transform.Rotate(new Vector3(0f, Input.GetAxis("Horizontal") * Time.deltaTime * 200f, 0f));
		m_Player.transform.Translate(((Component)this).transform.forward * Input.GetAxis("Vertical") * Time.deltaTime * 4f);
	}

	private void OnGUI()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		GUI.Label(new Rect(50f, 50f, 200f, 24f), "Press arrow key to move");
		Animation componentInChildren = m_Player.GetComponentInChildren<Animation>();
		((Behaviour)componentInChildren).enabled = GUI.Toggle(new Rect(50f, 70f, 200f, 24f), ((Behaviour)componentInChildren).enabled, "Play Animation");
		DynamicBone[] components = m_Player.GetComponents<DynamicBone>();
		GUI.Label(new Rect(50f, 100f, 200f, 24f), "Choose dynamic bone:");
		DynamicBone obj = components[0];
		bool enabled = GUI.Toggle(new Rect(50f, 120f, 100f, 24f), ((Behaviour)components[0]).enabled, "Breasts");
		((Behaviour)components[1]).enabled = enabled;
		((Behaviour)obj).enabled = enabled;
		((Behaviour)components[2]).enabled = GUI.Toggle(new Rect(50f, 140f, 100f, 24f), ((Behaviour)components[2]).enabled, "Tail");
		GUI.Label(new Rect(50f, 160f, 200f, 24f), "Weight");
		m_weight = GUI.HorizontalSlider(new Rect(100f, 160f, 100f, 24f), m_weight, 0f, 1f);
		DynamicBone[] array = components;
		foreach (DynamicBone dynamicBone in array)
		{
			dynamicBone.SetWeight(m_weight);
		}
	}
}
[AddComponentMenu("Dynamic Bone/Dynamic Bone")]
public class DynamicBone : MonoBehaviour
{
	public enum UpdateMode
	{
		Normal,
		AnimatePhysics,
		UnscaledTime
	}

	public enum FreezeAxis
	{
		None,
		X,
		Y,
		Z
	}

	private class Particle
	{
		public Transform m_Transform = null;

		public int m_ParentIndex = -1;

		public float m_Damping = 0f;

		public float m_Elasticity = 0f;

		public float m_Stiffness = 0f;

		public float m_Inert = 0f;

		public float m_Friction = 0f;

		public float m_Radius = 0f;

		public float m_BoneLength = 0f;

		public bool m_isCollide = false;

		public Vector3 m_Position = Vector3.zero;

		public Vector3 m_PrevPosition = Vector3.zero;

		public Vector3 m_EndOffset = Vector3.zero;

		public Vector3 m_InitLocalPosition = Vector3.zero;

		public Quaternion m_InitLocalRotation = Quaternion.identity;
	}

	[Tooltip("The root of the transform hierarchy to apply physics.")]
	public Transform m_Root = null;

	[Tooltip("Internal physics simulation rate.")]
	public float m_UpdateRate = 60f;

	public UpdateMode m_UpdateMode = UpdateMode.Normal;

	[Tooltip("How much the bones slowed down.")]
	[Range(0f, 1f)]
	public float m_Damping = 0.1f;

	public AnimationCurve m_DampingDistrib = null;

	[Tooltip("How much the force applied to return each bone to original orientation.")]
	[Range(0f, 1f)]
	public float m_Elasticity = 0.1f;

	public AnimationCurve m_ElasticityDistrib = null;

	[Tooltip("How much bone's original orientation are preserved.")]
	[Range(0f, 1f)]
	public float m_Stiffness = 0.1f;

	public AnimationCurve m_StiffnessDistrib = null;

	[Tooltip("How much character's position change is ignored in physics simulation.")]
	[Range(0f, 1f)]
	public float m_Inert = 0f;

	public AnimationCurve m_InertDistrib = null;

	[Tooltip("How much the bones slowed down when collide.")]
	public float m_Friction = 0f;

	public AnimationCurve m_FrictionDistrib = null;

	[Tooltip("Each bone can be a sphere to collide with colliders. Radius describe sphere's size.")]
	public float m_Radius = 0f;

	public AnimationCurve m_RadiusDistrib = null;

	[Tooltip("If End Length is not zero, an extra bone is generated at the end of transform hierarchy.")]
	public float m_EndLength = 0f;

	[Tooltip("If End Offset is not zero, an extra bone is generated at the end of transform hierarchy.")]
	public Vector3 m_EndOffset = Vector3.zero;

	[Tooltip("The force apply to bones. Partial force apply to character's initial pose is cancelled out.")]
	public Vector3 m_Gravity = Vector3.zero;

	[Tooltip("The force apply to bones.")]
	public Vector3 m_Force = Vector3.zero;

	[Tooltip("Collider objects interact with the bones.")]
	public List<DynamicBoneColliderBase> m_Colliders = null;

	[Tooltip("Bones exclude from physics simulation.")]
	public List<Transform> m_Exclusions = null;

	[Tooltip("Constrain bones to move on specified plane.")]
	public FreezeAxis m_FreezeAxis = FreezeAxis.None;

	[Tooltip("Disable physics simulation automatically if character is far from camera or player.")]
	public bool m_DistantDisable = false;

	public Transform m_ReferenceObject = null;

	public float m_DistanceToObject = 20f;

	private Vector3 m_LocalGravity = Vector3.zero;

	private Vector3 m_ObjectMove = Vector3.zero;

	private Vector3 m_ObjectPrevPosition = Vector3.zero;

	private float m_BoneTotalLength = 0f;

	private float m_ObjectScale = 1f;

	private float m_Time = 0f;

	private float m_Weight = 1f;

	private bool m_DistantDisabled = false;

	private List<Particle> m_Particles = new List<Particle>();

	private void Start()
	{
		SetupParticles();
	}

	private void FixedUpdate()
	{
		if (m_UpdateMode == UpdateMode.AnimatePhysics)
		{
			PreUpdate();
		}
	}

	private void Update()
	{
		if (m_UpdateMode != UpdateMode.AnimatePhysics)
		{
			PreUpdate();
		}
	}

	private void LateUpdate()
	{
		if (m_DistantDisable)
		{
			CheckDistance();
		}
		if (m_Weight > 0f && (!m_DistantDisable || !m_DistantDisabled))
		{
			float t = ((m_UpdateMode != UpdateMode.UnscaledTime) ? Time.deltaTime : Time.unscaledDeltaTime);
			UpdateDynamicBones(t);
		}
	}

	private void PreUpdate()
	{
		if (m_Weight > 0f && (!m_DistantDisable || !m_DistantDisabled))
		{
			InitTransforms();
		}
	}

	private void CheckDistance()
	{
		//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_004d: 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)
		Transform val = m_ReferenceObject;
		if ((Object)(object)val == (Object)null && (Object)(object)Camera.main != (Object)null)
		{
			val = ((Component)Camera.main).transform;
		}
		if (!((Object)(object)val != (Object)null))
		{
			return;
		}
		Vector3 val2 = val.position - ((Component)this).transform.position;
		float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
		bool flag = sqrMagnitude > m_DistanceToObject * m_DistanceToObject;
		if (flag != m_DistantDisabled)
		{
			if (!flag)
			{
				ResetParticlesPosition();
			}
			m_DistantDisabled = flag;
		}
	}

	private void OnEnable()
	{
		ResetParticlesPosition();
	}

	private void OnDisable()
	{
		InitTransforms();
	}

	private void OnValidate()
	{
		m_UpdateRate = Mathf.Max(m_UpdateRate, 0f);
		m_Damping = Mathf.Clamp01(m_Damping);
		m_Elasticity = Mathf.Clamp01(m_Elasticity);
		m_Stiffness = Mathf.Clamp01(m_Stiffness);
		m_Inert = Mathf.Clamp01(m_Inert);
		m_Friction = Mathf.Clamp01(m_Friction);
		m_Radius = Mathf.Max(m_Radius, 0f);
		if (Application.isEditor && Application.isPlaying)
		{
			InitTransforms();
			SetupParticles();
		}
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0054: 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_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		if (!((Behaviour)this).enabled || (Object)(object)m_Root == (Object)null)
		{
			return;
		}
		if (Application.isEditor && !Application.isPlaying && ((Component)this).transform.hasChanged)
		{
			InitTransforms();
			SetupParticles();
		}
		Gizmos.color = Color.white;
		for (int i = 0; i < m_Particles.Count; i++)
		{
			Particle particle = m_Particles[i];
			if (particle.m_ParentIndex >= 0)
			{
				Particle particle2 = m_Particles[particle.m_ParentIndex];
				Gizmos.DrawLine(particle.m_Position, particle2.m_Position);
			}
			if (particle.m_Radius > 0f)
			{
				Gizmos.DrawWireSphere(particle.m_Position, particle.m_Radius * m_ObjectScale);
			}
		}
	}

	public void SetWeight(float w)
	{
		if (m_Weight != w)
		{
			if (w == 0f)
			{
				InitTransforms();
			}
			else if (m_Weight == 0f)
			{
				ResetParticlesPosition();
			}
			m_Weight = w;
		}
	}

	public float GetWeight()
	{
		return m_Weight;
	}

	private void UpdateDynamicBones(float t)
	{
		//IL_001e: 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_003c: 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_0047: 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_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_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)m_Root == (Object)null)
		{
			return;
		}
		m_ObjectScale = Mathf.Abs(((Component)this).transform.lossyScale.x);
		m_ObjectMove = ((Component)this).transform.position - m_ObjectPrevPosition;
		m_ObjectPrevPosition = ((Component)this).transform.position;
		int num = 1;
		if (m_UpdateRate > 0f)
		{
			float num2 = 1f / m_UpdateRate;
			m_Time += t;
			num = 0;
			while (m_Time >= num2)
			{
				m_Time -= num2;
				if (++num >= 3)
				{
					m_Time = 0f;
					break;
				}
			}
		}
		if (num > 0)
		{
			for (int i = 0; i < num; i++)
			{
				UpdateParticles1();
				UpdateParticles2();
				m_ObjectMove = Vector3.zero;
			}
		}
		else
		{
			SkipUpdateParticles();
		}
		ApplyParticlesToTransforms();
	}

	private void SetupParticles()
	{
		//IL_002a: 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_0045: 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_0069: 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)
		m_Particles.Clear();
		if (!((Object)(object)m_Root == (Object)null))
		{
			m_LocalGravity = m_Root.InverseTransformDirection(m_Gravity);
			m_ObjectScale = Mathf.Abs(((Component)this).transform.lossyScale.x);
			m_ObjectPrevPosition = ((Component)this).transform.position;
			m_ObjectMove = Vector3.zero;
			m_BoneTotalLength = 0f;
			AppendParticles(m_Root, -1, 0f);
			UpdateParameters();
		}
	}

	private void AppendParticles(Transform b, int parentIndex, float boneLength)
	{
		//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)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: 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_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: 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_0124: 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_00d9: 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_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: 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_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: 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_0234: Unknown result type (might be due to invalid IL or missing references)
		//IL_0239: Unknown result type (might be due to invalid IL or missing references)
		Particle particle = new Particle();
		particle.m_Transform = b;
		particle.m_ParentIndex = parentIndex;
		Vector3 val;
		if ((Object)(object)b != (Object)null)
		{
			val = (particle.m_Position = (particle.m_PrevPosition = b.position));
			particle.m_InitLocalPosition = b.localPosition;
			particle.m_InitLocalRotation = b.localRotation;
		}
		else
		{
			Transform transform = m_Particles[parentIndex].m_Transform;
			if (m_EndLength > 0f)
			{
				Transform parent = transform.parent;
				if ((Object)(object)parent != (Object)null)
				{
					particle.m_EndOffset = transform.InverseTransformPoint(transform.position * 2f - parent.position) * m_EndLength;
				}
				else
				{
					particle.m_EndOffset = new Vector3(m_EndLength, 0f, 0f);
				}
			}
			else
			{
				particle.m_EndOffset = transform.InverseTransformPoint(((Component)this).transform.TransformDirection(m_EndOffset) + transform.position);
			}
			val = (particle.m_Position = (particle.m_PrevPosition = transform.TransformPoint(particle.m_EndOffset)));
		}
		if (parentIndex >= 0)
		{
			float num = boneLength;
			val = m_Particles[parentIndex].m_Transform.position - particle.m_Position;
			boneLength = num + ((Vector3)(ref val)).magnitude;
			particle.m_BoneLength = boneLength;
			m_BoneTotalLength = Mathf.Max(m_BoneTotalLength, boneLength);
		}
		int count = m_Particles.Count;
		m_Particles.Add(particle);
		if (!((Object)(object)b != (Object)null))
		{
			return;
		}
		for (int i = 0; i < b.childCount; i++)
		{
			bool flag = false;
			if (m_Exclusions != null)
			{
				for (int j = 0; j < m_Exclusions.Count; j++)
				{
					Transform val2 = m_Exclusions[j];
					if ((Object)(object)val2 == (Object)(object)b.GetChild(i))
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				AppendParticles(b.GetChild(i), count, boneLength);
			}
			else if (m_EndLength > 0f || m_EndOffset != Vector3.zero)
			{
				AppendParticles(null, count, boneLength);
			}
		}
		if (b.childCount == 0 && (m_EndLength > 0f || m_EndOffset != Vector3.zero))
		{
			AppendParticles(null, count, boneLength);
		}
	}

	public void UpdateParameters()
	{
		//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)(object)m_Root == (Object)null)
		{
			return;
		}
		m_LocalGravity = m_Root.InverseTransformDirection(m_Gravity);
		for (int i = 0; i < m_Particles.Count; i++)
		{
			Particle particle = m_Particles[i];
			particle.m_Damping = m_Damping;
			particle.m_Elasticity = m_Elasticity;
			particle.m_Stiffness = m_Stiffness;
			particle.m_Inert = m_Inert;
			particle.m_Friction = m_Friction;
			particle.m_Radius = m_Radius;
			if (m_BoneTotalLength > 0f)
			{
				float num = particle.m_BoneLength / m_BoneTotalLength;
				if (m_DampingDistrib != null && m_DampingDistrib.keys.Length > 0)
				{
					particle.m_Damping *= m_DampingDistrib.Evaluate(num);
				}
				if (m_ElasticityDistrib != null && m_ElasticityDistrib.keys.Length > 0)
				{
					particle.m_Elasticity *= m_ElasticityDistrib.Evaluate(num);
				}
				if (m_StiffnessDistrib != null && m_StiffnessDistrib.keys.Length > 0)
				{
					particle.m_Stiffness *= m_StiffnessDistrib.Evaluate(num);
				}
				if (m_InertDistrib != null && m_InertDistrib.keys.Length > 0)
				{
					particle.m_Inert *= m_InertDistrib.Evaluate(num);
				}
				if (m_FrictionDistrib != null && m_FrictionDistrib.keys.Length > 0)
				{
					particle.m_Friction *= m_FrictionDistrib.Evaluate(num);
				}
				if (m_RadiusDistrib != null && m_RadiusDistrib.keys.Length > 0)
				{
					particle.m_Radius *= m_RadiusDistrib.Evaluate(num);
				}
			}
			particle.m_Damping = Mathf.Clamp01(particle.m_Damping);
			particle.m_Elasticity = Mathf.Clamp01(particle.m_Elasticity);
			particle.m_Stiffness = Mathf.Clamp01(particle.m_Stiffness);
			particle.m_Inert = Mathf.Clamp01(particle.m_Inert);
			particle.m_Friction = Mathf.Clamp01(particle.m_Friction);
			particle.m_Radius = Mathf.Max(particle.m_Radius, 0f);
		}
	}

	private void InitTransforms()
	{
		//IL_002f: 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)
		for (int i = 0; i < m_Particles.Count; i++)
		{
			Particle particle = m_Particles[i];
			if ((Object)(object)particle.m_Transform != (Object)null)
			{
				particle.m_Transform.localPosition = particle.m_InitLocalPosition;
				particle.m_Transfor