using System;
using System.Collections;
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 BallisticProjectileKillIfBelowSpeed : MonoBehaviour
	{
		public BallisticProjectile Projectile;

		public float KillIfVelBelowThisMagnitude = 20f;

		private void Update()
		{
			//IL_0023: 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)
			if (((Vector3)(ref Projectile.m_velocity)).magnitude <= KillIfVelBelowThisMagnitude)
			{
				Projectile.m_velocity = Vector3.zero;
			}
		}
	}
	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 ClosedBoltBeltFedDualFeedFix : MonoBehaviour
	{
		public ClosedBoltWeapon Weapon;

		public ClosedBoltMagEjectionTrigger MagGrabTrigger;

		public Vector3 TriggerPosForBeltBox;

		public Vector3 ScaleForBeltBoxTrigger;

		private Vector3 TriggerPosForMag;

		private Vector3 ScaleForMagTrigger;

		private void Start()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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)
			TriggerPosForMag = ((FVRInteractiveObject)MagGrabTrigger).Transform.localPosition;
			ScaleForMagTrigger = ((FVRInteractiveObject)MagGrabTrigger).Transform.localScale;
		}

		private void Update()
		{
			//IL_0044: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			FVRFireArmMagazine magazine = ((FVRFireArm)Weapon).Magazine;
			ClosedBoltMagEjectionTrigger magGrabTrigger = MagGrabTrigger;
			if ((Object)(object)magazine == (Object)null)
			{
				return;
			}
			if (!magazine.IsBeltBox)
			{
				((Component)magGrabTrigger).gameObject.SetActive(true);
				((FVRInteractiveObject)magGrabTrigger).Transform.localPosition = TriggerPosForMag;
				((FVRInteractiveObject)magGrabTrigger).Transform.localScale = ScaleForMagTrigger;
			}
			if (magazine.IsBeltBox)
			{
				if (!((FVRFireArm)Weapon).ConnectedToBox)
				{
					((Component)magGrabTrigger).gameObject.SetActive(true);
					((FVRInteractiveObject)magGrabTrigger).Transform.localPosition = TriggerPosForBeltBox;
					((FVRInteractiveObject)magGrabTrigger).Transform.localScale = ScaleForBeltBoxTrigger;
				}
				else
				{
					((Component)MagGrabTrigger).gameObject.SetActive(false);
				}
			}
		}
	}
	public class ClosedBoltPokeToChamberRound : FVRInteractiveObject
	{
		public ClosedBoltWeapon Weapon;

		public FVRFireArmChamber Chamber;

		public override void Poke(FVRViveHand hand)
		{
			if (((Object)(object)((FVRInteractiveObject)Weapon).m_hand == (Object)null || (Object)(object)hand != (Object)(object)((FVRInteractiveObject)Weapon).m_hand) && !Chamber.IsFull)
			{
				Weapon.Bolt.ImpartFiringImpulse();
			}
		}
	}
	public class DisableIfCurrentMagIsBeltBox : MonoBehaviour
	{
		public FVRFireArm Firearm;

		public GameObject GameObjectToDisable;

		private void Update()
		{
			GameObjectToDisable.SetActive(true);
		}
	}
	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!");
				}
			}
		}
	}
	public class GrenadeParticlesIfArmed : MonoBehaviour
	{
		public PinnedGrenade Grenade;

		public ParticleSystem[] Particles;

		public AudioSource ArmedSounds;

		public bool ReleaseLeverOnPinPull = true;

		private bool m_hasReleasedLever = false;

		private bool m_hasArmed = false;

		private bool m_hasExploded = false;

		private void Start()
		{
			StopParticles();
			ArmedSounds.Stop();
		}

		private void Update()
		{
			if ((Object)(object)Grenade == (Object)null || Particles == null || (Object)(object)ArmedSounds == (Object)null)
			{
				return;
			}
			bool isPinPulled = Grenade.m_isPinPulled;
			bool isLeverReleased = Grenade.m_isLeverReleased;
			bool hasSploded = Grenade.m_hasSploded;
			if (ReleaseLeverOnPinPull && isPinPulled && !m_hasReleasedLever)
			{
				m_hasReleasedLever = true;
				Grenade.ReleaseLever();
			}
			if (isLeverReleased && !m_hasArmed)
			{
				m_hasArmed = true;
				PlayParticles();
				if (!ArmedSounds.isPlaying)
				{
					ArmedSounds.Play();
				}
			}
			if (hasSploded && !m_hasExploded)
			{
				m_hasExploded = true;
				StopParticles();
				if (ArmedSounds.isPlaying)
				{
					ArmedSounds.Stop();
				}
			}
		}

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

		private void StopParticles()
		{
			if (Particles == null)
			{
				return;
			}
			ParticleSystem[] particles = Particles;
			foreach (ParticleSystem val in particles)
			{
				if ((Object)(object)val != (Object)null && val.isPlaying)
				{
					val.Stop();
				}
			}
		}
	}
}
[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;
		}
	}
	public class MagazineDeleteIfEmpty : MonoBehaviour
	{
		public FVRFireArmMagazine Magazine;

		private void Update()
		{
			if (!((Object)(object)Magazine.FireArm == (Object)null) && !Magazine.HasARound())
			{
				FVRFireArmMagazine magazine = Magazine;
				Magazine.FireArm.EjectMag(false);
				Object.Destroy((Object)(object)((Component)magazine).gameObject);
			}
		}
	}
}
namespace ShermanJumbo.PLAS39_Accelerator_Rifle
{
	[BepInPlugin("ShermanJumbo.PLAS39_Accelerator_Rifle", "PLAS39_Accelerator_Rifle", "1.0.0")]
	[BepInProcess("h3vr.exe")]
	[Description("Built with MeatKit")]
	[BepInDependency("h3vr.otherloader", "1.3.0")]
	public class PLAS39_Accelerator_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.PLAS39_Accelerator_Rifle");
			OtherLoader.RegisterDirectLoad(BasePath, "ShermanJumbo.PLAS39_Accelerator_Rifle", "", "", "shermanjumbo_plas39acceleratorrifle", "");
		}
	}
}
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;
		}
	}
	public class OpenBoltRackBoltPokeableButton : FVRInteractiveObject
	{
		public OpenBoltReceiver Weapon;

		public AudioEvent PokeSound;

		public override void Poke(FVRViveHand hand)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)(object)((FVRInteractiveObject)Weapon).m_hand == (Object)null || (Object)(object)hand != (Object)(object)((FVRInteractiveObject)Weapon).m_hand) && (int)Weapon.Bolt.CurPos == 0 && (Object)(object)((FVRFireArm)Weapon).Magazine != (Object)null && ((FVRFireArm)Weapon).Magazine.HasARound())
			{
				Weapon.Bolt.ImpartFiringImpulse();
				SM.PlayCoreSound((FVRPooledAudioType)0, PokeSound, ((Component)this).transform.position);
			}
		}
	}
	[RequireComponent(typeof(FirearmHeatingEffect))]
	public class OverheatingWeapon : MonoBehaviour
	{
		public enum ManualCooldownButton
		{
			AOrTouchpadDown,
			BOrTouchpadUp
		}

		[Header("General Stuff (read the tooltips!)")]
		public FirearmHeatingEffect HeatingEffect;

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

		[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;

		public bool OnlyCoolsDownIfBoltActionBoltIsOpen;

		public BoltActionRifle_Handle BoltHandle;

		[Header("Manual Cooldown")]
		[Tooltip("If enabled, pressing a button on your controller (choose which one below) will manually trigger the cooldown state, even if the gun isn't completely overheated. Only works if the gun doesn't UseHeatsinkBehavior, obviously. Just eject the magazine, silly.")]
		public bool CanManuallyTriggerCooldown;

		public ManualCooldownButton CooldownButton;

		[Tooltip("The minimum heat at which it is possible to manually trigger the cooldown state.")]
		public float MinHeatRequiredForManualCooldown = 0.1f;

		[Header("Heatsink Behavior")]
		[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, and if this auto ejects spent heatsink, automatically break open the given break open trigger and eject the mag when it burns out.")]
		public bool UsesBreakOpenTrigger;

		public BreakOpenTrigger BOTrigger;

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

		public AudioEvent OverheatSound;

		public AudioEvent CooldownSound;

		private bool IsCoolingToZero;

		private FVRFireArm Weapon;

		private float CurrentHeat;

		private Handgun hg;

		private ClosedBoltWeapon cbw;

		private OpenBoltReceiver obr;

		private float BaseCooldownRate;

		private bool inputResetPending = false;

		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);
					hg.Slide.ImpartFiringImpulse();
				}
				if (Weapon is ClosedBoltWeapon)
				{
					ref ClosedBoltWeapon reference2 = ref cbw;
					FVRFireArm weapon2 = Weapon;
					reference2 = (ClosedBoltWeapon)(object)((weapon2 is ClosedBoltWeapon) ? weapon2 : null);
					cbw.Bolt.ImpartFiringImpulse();
				}
				if (Weapon is OpenBoltReceiver)
				{
					ref OpenBoltReceiver reference3 = ref obr;
					FVRFireArm weapon3 = Weapon;
					reference3 = (OpenBoltReceiver)(object)((weapon3 is OpenBoltReceiver) ? weapon3 : null);
					obr.Bolt.ImpartFiringImpulse();
				}
			}
			StopOverheatedParticles();
		}

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

		private void HandleHeatsinkBehavior(FVRFireArmMagazine mag)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: 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 && !UsesBreakOpenTrigger)
				{
					Weapon.EjectMag(false);
				}
				if (UsesBreakOpenTrigger && !inputResetPending)
				{
					BOTrigger.DoesEjectMag = true;
					if ((Object)(object)((FVRInteractiveObject)Weapon).m_hand != (Object)null)
					{
						if (((FVRInteractiveObject)Weapon).m_hand.IsInStreamlinedMode)
						{
							((FVRInteractiveObject)Weapon).m_hand.Input.BYButtonPressed = true;
						}
						else
						{
							((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadPressed = true;
							((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadAxes.y = 1f;
						}
						inputResetPending = true;
						((MonoBehaviour)this).StartCoroutine(ResetInputsAfterDelay(((FVRInteractiveObject)Weapon).m_hand));
					}
				}
				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;
				if (UsesBreakOpenTrigger)
				{
					BOTrigger.DoesEjectMag = false;
				}
				HeatingEffect.CooldownRate = BaseCooldownRate;
				SM.PlayCoreSound((FVRPooledAudioType)0, CooldownSound, ((Component)this).transform.position);
				if (AutoCycleBoltOnCooldown)
				{
					AutoCycleBolt();
				}
				StopOverheatedParticles();
			}
		}

		private IEnumerator ResetInputsAfterDelay(FVRViveHand hand)
		{
			yield return (object)new WaitForSeconds(0.1f);
			hand.Input.BYButtonPressed = false;
			hand.Input.TouchpadPressed = false;
			hand.Input.TouchpadAxes = Vector2.zero;
			inputResetPending = false;
		}

		private void HandleStandardOverheat(FVRFireArmMagazine mag)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (CurrentHeat >= 1f && !IsCoolingToZero)
			{
				StartCooldownStandard(mag);
			}
			if (!IsCoolingToZero)
			{
				mag.IsExtractable = true;
			}
			if (IsCoolingToZero && CurrentHeat <= 0f)
			{
				IsCoolingToZero = false;
				mag.IsExtractable = true;
				HeatingEffect.CooldownRate = BaseCooldownRate;
				SM.PlayCoreSound((FVRPooledAudioType)0, CooldownSound, ((Component)this).transform.position);
				if (AutoCycleBoltOnCooldown)
				{
					AutoCycleBolt();
				}
				StopOverheatedParticles();
			}
		}

		private void HandleBoltActionOverheat(FVRFireArmMagazine mag)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (int)BoltHandle.HandleState == 2;
			if (!IsCoolingToZero && CurrentHeat >= 1f && flag)
			{
				StartCooldownStandard(mag);
			}
			if (IsCoolingToZero)
			{
				if (flag)
				{
					HeatingEffect.CooldownRate = BaseCooldownRate * OverheatCooldownMultiplier;
				}
				else
				{
					HeatingEffect.CooldownRate = 0f;
				}
			}
			else
			{
				HeatingEffect.CooldownRate = ((!flag) ? 0f : BaseCooldownRate);
			}
			if (!IsCoolingToZero)
			{
				mag.IsExtractable = true;
			}
			if (IsCoolingToZero && CurrentHeat <= 0f)
			{
				IsCoolingToZero = false;
				mag.IsExtractable = true;
				HeatingEffect.CooldownRate = BaseCooldownRate;
				SM.PlayCoreSound((FVRPooledAudioType)0, CooldownSound, ((Component)this).transform.position);
				if (AutoCycleBoltOnCooldown)
				{
					AutoCycleBolt();
				}
				StopOverheatedParticles();
			}
		}

		private void StartCooldownStandard(FVRFireArmMagazine mag)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!IsCoolingToZero)
			{
				IsCoolingToZero = true;
				mag.IsExtractable = false;
				HeatingEffect.CooldownRate = BaseCooldownRate * OverheatCooldownMultiplier;
				SM.PlayCoreSound((FVRPooledAudioType)0, OverheatSound, ((Component)this).transform.position);
				PlayOverheatedParticles();
			}
		}

		private void TryToManuallyStartCooldown()
		{
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((FVRInteractiveObject)Weapon).m_hand == (Object)null)
			{
				return;
			}
			if (CooldownButton == ManualCooldownButton.AOrTouchpadDown)
			{
				if (((FVRInteractiveObject)Weapon).m_hand.IsInStreamlinedMode)
				{
					if (((FVRInteractiveObject)Weapon).m_hand.Input.AXButtonDown && !IsCoolingToZero && CurrentHeat > MinHeatRequiredForManualCooldown)
					{
						StartCooldownStandard(Weapon.Magazine);
					}
				}
				else if (!IsCoolingToZero && CurrentHeat > MinHeatRequiredForManualCooldown && Vector2.Angle(((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadAxes, Vector2.down) <= 45f && ((Vector2)(ref ((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadAxes)).magnitude > 0.4f && ((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadPressed)
				{
					StartCooldownStandard(Weapon.Magazine);
				}
			}
			else if (((FVRInteractiveObject)Weapon).m_hand.IsInStreamlinedMode)
			{
				if (((FVRInteractiveObject)Weapon).m_hand.Input.BYButtonDown && !IsCoolingToZero && CurrentHeat > MinHeatRequiredForManualCooldown)
				{
					StartCooldownStandard(Weapon.Magazine);
				}
			}
			else if (!IsCoolingToZero && CurrentHeat > MinHeatRequiredForManualCooldown && Vector2.Angle(((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadAxes, Vector2.up) <= 45f && ((Vector2)(ref ((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadAxes)).magnitude > 0.4f && ((FVRInteractiveObject)Weapon).m_hand.Input.TouchpadPressed)
			{
				StartCooldownStandard(Weapon.Magazine);
			}
		}

		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: U