using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
using OpenScripts2;
using OtherLoader;
using UnityEngine;
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]
public class AT4 : SimpleLauncher
{
	[Header("Trigger Settings")]
	public Transform Trigger;

	public Axis Trigger_Axis = (Axis)0;

	public Vector2 Trigger_ValRange = new Vector2(0f, 10f);

	private float m_triggerVal;

	[Header("Rocket Settings")]
	[HideInInspector]
	public bool hasFired = false;

	[Header("Self-Destruct")]
	public float DestroyDelay = 10f;

	private bool selfDestructStarted = false;

	public AT4ArmingLever ArmingLever;

	private void FireAT4()
	{
		if (base.Chamber.IsFull && !base.Chamber.IsSpent && !((Object)(object)ArmingLever == (Object)null) && ArmingLever.IsArmed)
		{
			base.Chamber.Fire();
			((FVRFireArm)this).FireMuzzleSmoke();
			hasFired = true;
			StartSelfDestructCheck();
		}
	}

	public override void UpdateInteraction(FVRViveHand hand)
	{
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Expected I4, but got Unknown
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Expected I4, but got Unknown
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)ArmingLever != (Object)null && !ArmingLever.IsArmed)
		{
			if ((Object)(object)Trigger != (Object)null && (Object)(object)hand != (Object)null)
			{
				Vector3 localPosition = Trigger.localPosition;
				((Vector3)(ref localPosition))[(int)Trigger_Axis] = Mathf.Lerp(Trigger_ValRange.x, Trigger_ValRange.y, hand.Input.TriggerFloat);
				Trigger.localPosition = localPosition;
			}
			return;
		}
		((SimpleLauncher)this).UpdateInteraction(hand);
		if ((Object)(object)Trigger != (Object)null && (Object)(object)hand != (Object)null)
		{
			Vector3 localPosition2 = Trigger.localPosition;
			((Vector3)(ref localPosition2))[(int)Trigger_Axis] = Mathf.Lerp(Trigger_ValRange.x, Trigger_ValRange.y, hand.Input.TriggerFloat);
			Trigger.localPosition = localPosition2;
		}
		if ((Object)(object)ArmingLever != (Object)null && ArmingLever.IsArmed && !((FVRPhysicalObject)this).IsAltHeld && (Object)(object)hand != (Object)null && hand.Input.TriggerDown && !hasFired && base.Chamber.IsFull && !base.Chamber.IsSpent)
		{
			FireAT4();
		}
		if ((!base.Chamber.IsFull || hasFired) && !selfDestructStarted && !((FVRInteractiveObject)this).IsHeld)
		{
			StartSelfDestructCheck();
		}
	}

	private void StartSelfDestructCheck()
	{
		if (!selfDestructStarted)
		{
			selfDestructStarted = true;
			((MonoBehaviour)this).StartCoroutine(SelfDestructCheck());
		}
	}

	private IEnumerator SelfDestructCheck()
	{
		float timer = 0f;
		while (timer < DestroyDelay)
		{
			if (!((FVRInteractiveObject)this).IsHeld)
			{
				timer += Time.deltaTime;
			}
			yield return null;
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}
}
public class AT4ArmingLever : FVRInteractiveObject
{
	public AT4 Weapon;

	[Header("Lever Movement")]
	public Transform LeverRoot;

	public Transform ForwardPoint;

	public Transform RearPoint;

	[Header("Arming Settings")]
	public float ArmThreshold = 0.9f;

	[Header("Lever Rotation Settings")]
	[Tooltip("Which local axis to rotate around: 0=X, 1=Y, 2=Z")]
	public int RotationAxis = 1;

	[Tooltip("Starting rotation (degrees) for the selected axis.")]
	public float StartRotation = 0f;

	[Tooltip("Ending rotation (degrees) for the selected axis.")]
	public float EndRotation = 45f;

	[Tooltip("How far right (in local X units) the hand must move for full rotation.")]
	public float MaxRightOffset = 0.1f;

	private bool isArmed = false;

	private float leverProgress = 0f;

	private Vector3 startLocalPos;

	private Vector3 endLocalPos;

	public bool IsArmed => isArmed;

	public override void Awake()
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		((FVRInteractiveObject)this).Awake();
		if ((Object)(object)LeverRoot != (Object)null && (Object)(object)ForwardPoint != (Object)null && (Object)(object)RearPoint != (Object)null)
		{
			startLocalPos = RearPoint.localPosition;
			endLocalPos = ForwardPoint.localPosition;
		}
	}

	public override void UpdateInteraction(FVRViveHand hand)
	{
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: 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_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: 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_007e: 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_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		((FVRInteractiveObject)this).UpdateInteraction(hand);
		if ((Object)(object)LeverRoot == (Object)null || (Object)(object)ForwardPoint == (Object)null || (Object)(object)RearPoint == (Object)null || (Object)(object)Weapon == (Object)null)
		{
			return;
		}
		Vector3 position = RearPoint.position;
		Vector3 position2 = ForwardPoint.position;
		Vector3 closestValidPoint = ((FVRInteractiveObject)this).GetClosestValidPoint(position, position2, ((HandInput)(ref hand.Input)).Pos);
		float num = Vector3.Distance(position, closestValidPoint) / Vector3.Distance(position, position2);
		num = Mathf.Clamp01(num);
		if (num < 1f)
		{
			LeverRoot.position = closestValidPoint;
			leverProgress = num;
			SetLeverRotation(StartRotation);
		}
		else
		{
			LeverRoot.position = position2;
			float num2 = Mathf.Clamp(ForwardPoint.InverseTransformPoint(((HandInput)(ref hand.Input)).Pos).x, 0f - MaxRightOffset, MaxRightOffset);
			float num3 = ((!(MaxRightOffset > 0f)) ? 0f : ((num2 + MaxRightOffset) / (2f * MaxRightOffset)));
			float leverRotation = Mathf.Lerp(StartRotation, EndRotation, num3);
			SetLeverRotation(leverRotation);
			leverProgress = 1f;
		}
		if (!isArmed && leverProgress >= ArmThreshold)
		{
			isArmed = true;
			if ((Object)(object)Weapon != (Object)null)
			{
				((FVRFireArm)Weapon).PlayAudioEvent((FirearmAudioEventType)12, 1f);
			}
		}
		else if (isArmed && leverProgress < 0.2f)
		{
			isArmed = false;
		}
	}

	private void SetLeverRotation(float angle)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		Vector3 zero = Vector3.zero;
		if (RotationAxis == 0)
		{
			zero.x = angle;
		}
		else if (RotationAxis == 1)
		{
			zero.y = angle;
		}
		else
		{
			zero.z = angle;
		}
		LeverRoot.localRotation = Quaternion.Euler(zero);
	}

	public override void EndInteraction(FVRViveHand hand)
	{
		//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_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: 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_0071: 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)
		((FVRInteractiveObject)this).EndInteraction(hand);
		Vector3 position = RearPoint.position;
		Vector3 position2 = ForwardPoint.position;
		float num = Vector3.Distance(LeverRoot.position, position);
		float num2 = Vector3.Distance(LeverRoot.position, position2);
		if (num2 < num)
		{
			LeverRoot.position = position2;
			SetLeverRotation(EndRotation);
		}
		else
		{
			LeverRoot.position = position;
			SetLeverRotation(StartRotation);
		}
	}
}
public class AT4SightCover : FVRInteractiveObject
{
	[Header("Sight References")]
	public Transform Sight;

	public Transform Cover;

	public Transform CoverRearPos;

	public Transform CoverForwardPos;

	[Header("Sight Local Positions & Rotations")]
	public Vector3 SightDownLocalPos;

	public Vector3 SightUpLocalPos;

	public Vector3 SightDownRot;

	public Vector3 SightUpRot;

	[Header("Interaction Settings")]
	[Range(0f, 1f)]
	public float CoverThreshold = 0.95f;

	private bool sightUp = false;

	public override void UpdateInteraction(FVRViveHand hand)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: 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_0135: Unknown result type (might be due to invalid IL or missing references)
		((FVRInteractiveObject)this).UpdateInteraction(hand);
		if (!((Object)(object)Sight == (Object)null) && !((Object)(object)CoverRearPos == (Object)null) && !((Object)(object)CoverForwardPos == (Object)null))
		{
			Vector3 closestValidPoint = ((FVRInteractiveObject)this).GetClosestValidPoint(CoverRearPos.position, CoverForwardPos.position, ((HandInput)(ref hand.Input)).Pos);
			float num = Vector3.Distance(CoverRearPos.position, closestValidPoint) / Vector3.Distance(CoverRearPos.position, CoverForwardPos.position);
			num = Mathf.Clamp01(num);
			if ((Object)(object)Cover != (Object)null)
			{
				Cover.position = Vector3.Lerp(CoverRearPos.position, CoverForwardPos.position, num);
			}
			else
			{
				((Component)this).transform.position = Vector3.Lerp(CoverRearPos.position, CoverForwardPos.position, num);
			}
			Sight.localPosition = Vector3.Lerp(SightDownLocalPos, SightUpLocalPos, num);
			Sight.localEulerAngles = Vector3.Lerp(SightDownRot, SightUpRot, num);
			if (num >= CoverThreshold && !sightUp)
			{
				sightUp = true;
			}
			else if (num < CoverThreshold && sightUp)
			{
				sightUp = false;
			}
		}
	}
}
public class Arwen : FVRFireArm
{
	[Header("Arwen 37mm Config")]
	public ArwenCylinder Cylinder;

	public FVRFireArmChamber[] Chambers;

	[Header("Trigger")]
	public Transform Trigger;

	[Tooltip("Trigger float value at which the weapon fires (DAO pull depth).")]
	public float TriggerFiringThreshold = 0.95f;

	[Tooltip("Trigger float value below which a spent shell ejects on release.")]
	public float TriggerEjectThreshold = 0.35f;

	[Tooltip("Trigger float value below which the trigger is considered fully reset.")]
	public float TriggerResetThreshold = 0.1f;

	public bool TriggerUsesRotation = true;

	public Vector3 TriggerRotationAxis = Vector3.right;

	public float TriggerMinAngle = 0f;

	public float TriggerMaxAngle = 30f;

	public bool TriggerUsesTranslation = false;

	public Vector3 TriggerTranslationAxis = Vector3.back;

	public float TriggerMinPosition = 0f;

	public float TriggerMaxPosition = 0.02f;

	[Header("Hammer")]
	public Transform Hammer;

	public bool HammerUsesRotation = true;

	public Vector3 HammerRotationAxis = Vector3.right;

	public float HammerMinAngle = 0f;

	public float HammerMaxAngle = 45f;

	public bool HammerUsesTranslation = false;

	public Vector3 HammerTranslationAxis = Vector3.back;

	public float HammerMinPosition = 0f;

	public float HammerMaxPosition = 0.01f;

	[Header("Bolt (animates forward→rear as trigger pulls)")]
	public Transform BoltTransform;

	public Transform Point_Bolt_Forward;

	public Transform Point_Bolt_Rear;

	[Header("Chamber Feed")]
	[Tooltip("How far (metres) the round nudges forward into the barrel as the trigger pulls.")]
	public float ChamberFeedDistance = 0.005f;

	[Header("Ejection")]
	public Transform EjectionPos;

	public Vector3 EjectionVelocity = new Vector3(0.2f, 0.5f, 0f);

	public Vector3 EjectionSpin = new Vector3(0f, 200f, 0f);

	[Header("Cylinder")]
	public float CylinderRotateDuration = 0.2f;

	[Header("Safety")]
	public Transform SafetySwitchLeft;

	public Transform SafetySwitchRight;

	public InterpStyle SafetyInterpStyle = (InterpStyle)1;

	public Axis SafetyAxis;

	public float SafetyPosition_Fire = 0f;

	public float SafetyPosition_Safe = 45f;

	private int m_curChamber = 0;

	private bool m_isSafetyOn = false;

	private bool m_hasTriggerCycled = false;

	private bool m_hasFired = false;

	private bool m_hasDryFired = false;

	private bool m_hasSafetyToggled = false;

	private bool m_isRestoringState = false;

	private bool[] m_prevChamberFull;

	private bool[] m_prevChamberPresent;

	private Coroutine m_cylinderCoroutine;

	public override void Awake()
	{
		((FVRFireArm)this).Awake();
		if (Chambers != null)
		{
			for (int i = 0; i < Chambers.Length; i++)
			{
				base.FChambers.Add(Chambers[i]);
			}
		}
		int num = ((Chambers != null) ? Chambers.Length : 0);
		m_prevChamberFull = new bool[num];
		m_prevChamberPresent = new bool[num];
		for (int j = 0; j < num; j++)
		{
			if (!((Object)(object)Chambers[j] == (Object)null))
			{
				m_prevChamberFull[j] = Chambers[j].IsFull && !Chambers[j].IsSpent;
				m_prevChamberPresent[j] = Chambers[j].IsFull;
			}
		}
		SetAllChambersAccessible(accessible: true);
		UpdateSafetyVisual();
	}

	public override void FVRUpdate()
	{
		((FVRFireArm)this).FVRUpdate();
		if (!m_isRestoringState)
		{
			DetectShellLoaded();
		}
	}

	private void DetectShellLoaded()
	{
		if (Chambers == null)
		{
			return;
		}
		for (int i = 0; i < Chambers.Length; i++)
		{
			bool flag = Chambers[i].IsFull && !Chambers[i].IsSpent;
			bool isFull = Chambers[i].IsFull;
			if (flag && !m_prevChamberFull[i])
			{
				OnShellLoaded();
			}
			if (!isFull && m_prevChamberPresent[i])
			{
				OnShellRemoved(i);
			}
			m_prevChamberFull[i] = flag;
			m_prevChamberPresent[i] = isFull;
		}
	}

	private void OnShellLoaded()
	{
		RotateToChamber(m_curChamber = (m_curChamber - 1 + Chambers.Length) % Chambers.Length);
		((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)20, 1f);
	}

	private void OnShellRemoved(int chamberIndex)
	{
		if (chamberIndex == m_curChamber)
		{
			int num = FindNextLoadedChamberClockwise();
			if (num != m_curChamber)
			{
				RotateToChamber(num);
				m_curChamber = num;
			}
		}
	}

	private int FindNextLoadedChamberClockwise()
	{
		for (int i = 1; i < Chambers.Length; i++)
		{
			int num = (m_curChamber + i) % Chambers.Length;
			if (Chambers[num].IsFull && !Chambers[num].IsSpent)
			{
				return num;
			}
		}
		return m_curChamber;
	}

	public override void UpdateInteraction(FVRViveHand hand)
	{
		((FVRPhysicalObject)this).UpdateInteraction(hand);
		if (!((Object)(object)hand == (Object)null))
		{
			float triggerFloat = hand.Input.TriggerFloat;
			UpdateTriggerVisual(triggerFloat);
			UpdateHammerVisual(triggerFloat);
			UpdateBoltVisual(triggerFloat);
			UpdateChamberFeedVisual(triggerFloat);
			HandleSafetyInput(hand);
			if (m_hasFired && triggerFloat < TriggerEjectThreshold)
			{
				EjectCurrentChamber();
				AdvanceChamberClockwise();
				m_hasFired = false;
			}
			if (m_hasDryFired && triggerFloat < TriggerResetThreshold)
			{
				AdvanceChamberClockwise();
				m_hasDryFired = false;
			}
			if (!m_isSafetyOn && triggerFloat >= TriggerFiringThreshold && !m_hasTriggerCycled)
			{
				FireOrDryFire();
				m_hasTriggerCycled = true;
			}
			if (triggerFloat < TriggerResetThreshold && m_hasTriggerCycled)
			{
				((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)16, 1f);
				m_hasTriggerCycled = false;
			}
		}
	}

	private void FireOrDryFire()
	{
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		FVRFireArmChamber val = Chambers[m_curChamber];
		if (val.IsFull && !val.IsSpent)
		{
			val.Fire();
			((FVRFireArm)this).Fire(val, (!((Object)(object)base.MuzzlePos != (Object)null)) ? ((Component)this).transform : base.MuzzlePos, true, 1f, -1f);
			((FVRFireArm)this).FireMuzzleSmoke();
			((FVRFireArm)this).Recoil(((FVRFireArm)this).IsTwoHandStabilized(), (Object)(object)((FVRPhysicalObject)this).AltGrip != (Object)null, ((FVRFireArm)this).IsShoulderStabilized(), (FVRFireArmRecoilProfile)null, 1f);
			((FVRFireArm)this).PlayAudioGunShot(val.GetRound(), GM.CurrentPlayerBody.GetCurrentSoundEnvironment(), 1f);
			if (GM.CurrentSceneSettings.IsAmmoInfinite || GM.CurrentPlayerBody.IsInfiniteAmmo)
			{
				val.IsSpent = false;
				val.UpdateProxyDisplay();
			}
			m_hasFired = true;
		}
		else
		{
			((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)6, 1f);
			m_hasDryFired = true;
		}
	}

	private void EjectCurrentChamber()
	{
		//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_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: 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_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_005a: Unknown result type (might be due to invalid IL or missing references)
		FVRFireArmChamber val = Chambers[m_curChamber];
		if (val.IsFull)
		{
			if ((Object)(object)EjectionPos != (Object)null)
			{
				val.EjectRound(EjectionPos.position, EjectionVelocity, EjectionSpin, EjectionPos.position, EjectionPos.rotation, false);
			}
			else
			{
				val.EjectRound(((Component)val).transform.position + ((Component)val).transform.forward * 0.1f, ((Component)val).transform.forward * 3f + Vector3.up * 1.5f, Vector3.up * 200f, true);
			}
		}
	}

	private void AdvanceChamberClockwise()
	{
		int num = (m_curChamber + 1) % Chambers.Length;
		RotateToChamber(num);
		m_curChamber = num;
	}

	private void RotateToChamber(int index)
	{
		if (m_cylinderCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(m_cylinderCoroutine);
		}
		m_cylinderCoroutine = ((MonoBehaviour)this).StartCoroutine(RotateCylinderTo(index));
	}

	private IEnumerator RotateCylinderTo(int toIndex)
	{
		if (!((Object)(object)Cylinder == (Object)null))
		{
			Quaternion from = ((Component)Cylinder).transform.localRotation;
			Quaternion to = Cylinder.GetLocalRotationFromCylinder(toIndex);
			float elapsed = 0f;
			float dur = Mathf.Max(0.01f, CylinderRotateDuration);
			while (elapsed < 1f)
			{
				elapsed += Time.deltaTime / dur;
				((Component)Cylinder).transform.localRotation = Quaternion.Slerp(from, to, elapsed);
				yield return null;
			}
			((Component)Cylinder).transform.localRotation = to;
		}
	}

	public void StopCylinderRotation()
	{
		if (m_cylinderCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(m_cylinderCoroutine);
			m_cylinderCoroutine = null;
		}
	}

	public void SyncChamberFromCylinder()
	{
		if ((Object)(object)Cylinder != (Object)null)
		{
			m_curChamber = Cylinder.GetClosestChamberIndex();
		}
	}

	private void UpdateTriggerVisual(float t)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: 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)
		if (!((Object)(object)Trigger == (Object)null))
		{
			if (TriggerUsesRotation)
			{
				Trigger.localRotation = Quaternion.AngleAxis(Mathf.Lerp(TriggerMinAngle, TriggerMaxAngle, t), TriggerRotationAxis);
			}
			if (TriggerUsesTranslation)
			{
				Trigger.localPosition = ((Vector3)(ref TriggerTranslationAxis)).normalized * Mathf.Lerp(TriggerMinPosition, TriggerMaxPosition, t);
			}
		}
	}

	private void UpdateHammerVisual(float t)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: 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)
		if (!((Object)(object)Hammer == (Object)null))
		{
			float num = ((!m_isSafetyOn) ? t : 0f);
			if (HammerUsesRotation)
			{
				Hammer.localRotation = Quaternion.AngleAxis(Mathf.Lerp(HammerMinAngle, HammerMaxAngle, num), HammerRotationAxis);
			}
			if (HammerUsesTranslation)
			{
				Hammer.localPosition = ((Vector3)(ref HammerTranslationAxis)).normalized * Mathf.Lerp(HammerMinPosition, HammerMaxPosition, num);
			}
		}
	}

	private void UpdateBoltVisual(float t)
	{
		//IL_005c: 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_006d: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)BoltTransform == (Object)null) && !((Object)(object)Point_Bolt_Forward == (Object)null) && !((Object)(object)Point_Bolt_Rear == (Object)null))
		{
			float num = ((!m_isSafetyOn) ? t : 0f);
			BoltTransform.localPosition = Vector3.Lerp(Point_Bolt_Forward.localPosition, Point_Bolt_Rear.localPosition, num);
		}
	}

	private void UpdateChamberFeedVisual(float t)
	{
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		if (Chambers != null && m_curChamber < Chambers.Length)
		{
			FVRFireArmChamber val = Chambers[m_curChamber];
			if (val.IsFull && !((Object)(object)val.ProxyRound == (Object)null))
			{
				float num = ((!m_isSafetyOn) ? t : 0f);
				val.ProxyRound.localPosition = Vector3.Lerp(Vector3.zero, Vector3.forward * ChamberFeedDistance, num);
			}
		}
	}

	private void HandleSafetyInput(FVRViveHand hand)
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		if (hand.IsInStreamlinedMode)
		{
			if (hand.Input.BYButtonDown && !m_hasSafetyToggled)
			{
				ToggleSafety();
				m_hasSafetyToggled = true;
			}
			else if (!hand.Input.BYButtonDown)
			{
				m_hasSafetyToggled = false;
			}
		}
		else if (hand.Input.TouchpadDown)
		{
			Vector2 touchpadAxes = hand.Input.TouchpadAxes;
			if (((Vector2)(ref touchpadAxes)).magnitude > 0.2f && Vector2.Angle(touchpadAxes, Vector2.left) < 45f)
			{
				ToggleSafety();
			}
		}
	}

	private void ToggleSafety()
	{
		m_isSafetyOn = !m_isSafetyOn;
		UpdateSafetyVisual();
		((FVRFireArm)this).PlayAudioEvent((FirearmAudioEventType)15, 1f);
	}

	private void UpdateSafetyVisual()
	{
		//IL_0038: 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_0062: 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)
		float num = ((!m_isSafetyOn) ? SafetyPosition_Fire : SafetyPosition_Safe);
		if ((Object)(object)SafetySwitchLeft != (Object)null)
		{
			((FVRPhysicalObject)this).SetAnimatedComponent(SafetySwitchLeft, num, SafetyInterpStyle, SafetyAxis);
		}
		if ((Object)(object)SafetySwitchRight != (Object)null)
		{
			((FVRPhysicalObject)this).SetAnimatedComponent(SafetySwitchRight, num, SafetyInterpStyle, SafetyAxis);
		}
	}

	private void SetAllChambersAccessible(bool accessible)
	{
		if (Chambers == null)
		{
			return;
		}
		for (int i = 0; i < Chambers.Length; i++)
		{
			if ((Object)(object)Chambers[i] != (Object)null)
			{
				Chambers[i].IsAccessible = accessible;
			}
		}
	}

	public override List<FireArmRoundClass> GetChamberRoundList()
	{
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		bool flag = false;
		List<FireArmRoundClass> list = new List<FireArmRoundClass>();
		for (int i = 0; i < Chambers.Length; i++)
		{
			if (Chambers[i].IsFull && !Chambers[i].IsSpent)
			{
				list.Add(Chambers[i].GetRound().RoundClass);
				flag = true;
			}
			else
			{
				list.Add((FireArmRoundClass)(-1));
			}
		}
		return (!flag) ? null : list;
	}

	public override void SetLoadedChambers(List<FireArmRoundClass> rounds)
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Invalid comparison between Unknown and I4
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		if (rounds == null)
		{
			return;
		}
		m_isRestoringState = true;
		for (int i = 0; i < rounds.Count && i < Chambers.Length; i++)
		{
			if ((int)rounds[i] >= 0)
			{
				Chambers[i].Autochamber(rounds[i]);
			}
		}
		for (int j = 0; j < Chambers.Length; j++)
		{
			m_prevChamberFull[j] = Chambers[j].IsFull && !Chambers[j].IsSpent;
			m_prevChamberPresent[j] = Chambers[j].IsFull;
		}
		m_isRestoringState = false;
	}
}
public class ArwenCylinder : FVRInteractiveObject
{
	[Header("Arwen Cylinder Config")]
	public Arwen Arwen;

	public int numChambers = 5;

	private float m_fakeAngularVel;

	public override void Awake()
	{
		((FVRInteractiveObject)this).Awake();
	}

	public override bool IsInteractable()
	{
		return true;
	}

	public override void BeginInteraction(FVRViveHand hand)
	{
		((FVRInteractiveObject)this).BeginInteraction(hand);
		if ((Object)(object)Arwen != (Object)null)
		{
			Arwen.StopCylinderRotation();
		}
	}

	public override void UpdateInteraction(FVRViveHand hand)
	{
		//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_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		((FVRInteractiveObject)this).UpdateInteraction(hand);
		if (!((Object)(object)Arwen == (Object)null))
		{
			float num = (0f - ((Component)Arwen).transform.InverseTransformDirection(hand.Input.VelLinearWorld).y) * 120f;
			((Component)this).transform.localEulerAngles = new Vector3(0f, 0f, ((Component)this).transform.localEulerAngles.z + num);
			m_fakeAngularVel = Mathf.Clamp(num, -360f, 360f);
		}
	}

	public override void EndInteraction(FVRViveHand hand)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)Arwen != (Object)null)
		{
			m_fakeAngularVel = Mathf.Clamp((0f - ((Component)Arwen).transform.InverseTransformDirection(hand.Input.VelLinearWorld).y) * 120f, -360f, 360f);
			Arwen.SyncChamberFromCylinder();
		}
		((FVRInteractiveObject)this).EndInteraction(hand);
	}

	public override void FVRUpdate()
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		((FVRInteractiveObject)this).FVRUpdate();
		if (!((FVRInteractiveObject)this).IsHeld && Mathf.Abs(m_fakeAngularVel) > 0.01f)
		{
			((Component)this).transform.localEulerAngles = new Vector3(0f, 0f, ((Component)this).transform.localEulerAngles.z + m_fakeAngularVel);
			m_fakeAngularVel = Mathf.Lerp(m_fakeAngularVel, 0f, Time.deltaTime * 0.8f);
		}
		else if (!((FVRInteractiveObject)this).IsHeld)
		{
			m_fakeAngularVel = 0f;
		}
	}

	public int GetClosestChamberIndex()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		float num = 0f - ((Component)this).transform.localEulerAngles.z;
		num += 360f / (float)numChambers * 0.5f;
		num = Mathf.Repeat(num, 360f);
		return Mathf.Clamp(Mathf.CeilToInt(num / (360f / (float)numChambers)) - 1, 0, numChambers - 1);
	}

	public Quaternion GetLocalRotationFromCylinder(int cylinder)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		float num = Mathf.Repeat((float)cylinder * (360f / (float)numChambers) * -1f, 360f);
		return Quaternion.Euler(0f, 0f, num);
	}
}
public class BouncingBetty : PinnedGrenade
{
	[Header("Betty Settings")]
	public float BounceHeight = 2f;

	public float ExplosionDelay = 0.5f;

	public float ArmDelay = 0.4f;

	[Header("Proximity Settings")]
	public float ProxRange = 3f;

	public LayerMask LM_Prox;

	[Header("Parts")]
	public GameObject BottomPartToDisable;

	public AudioEvent LaunchSound;

	public AudioEvent ArmSound;

	[Header("Stick Settings")]
	[Tooltip("Point Z to direction to check. If an layer object is within 0.05m from the raycastdir, it will lock.")]
	public Transform RaycastDir;

	public LayerMask StickLayer;

	[Tooltip("If velocity is below this, it will allow it to lock.")]
	public float MinStickVelocity = 0.1f;

	private bool isArmed = false;

	private bool isSet = false;

	private bool hasBounced = false;

	private bool beginCountdown = false;

	private float timer = 0f;

	private bool timerReached = false;

	private bool hasExploded = false;

	private bool isPinPulled = false;

	private bool isStuck = false;

	private bool isLocked = false;

	private Vector3 stuckNormal;

	private Transform stuckToSurface;

	public override void Awake()
	{
		((PinnedGrenade)this).Awake();
		base.m_isLeverReleased = true;
		base.m_isFused = false;
		base.m_fuseTime = float.MaxValue;
		base.m_startFuseTime = float.MaxValue;
		base.FuseOnSpawn = false;
		if ((Object)(object)base.FakeHandle != (Object)null)
		{
			base.FakeHandle.SetActive(false);
		}
		if ((Object)(object)base.RealHandle != (Object)null)
		{
			base.RealHandle.SetActive(false);
		}
		if ((Object)(object)base.LeverJoint != (Object)null)
		{
			Object.Destroy((Object)(object)base.LeverJoint);
		}
	}

	public override void FVRUpdate()
	{
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		((PinnedGrenade)this).FVRUpdate();
		if (base.m_rings.Count > 0)
		{
			isPinPulled = true;
			foreach (PinnedGrenadeRing ring in base.m_rings)
			{
				if (!ring.HasPinDetached())
				{
					isPinPulled = false;
				}
			}
		}
		if (!isPinPulled || isStuck || !((FVRInteractiveObject)this).IsHeld)
		{
		}
		if (isStuck && !beginCountdown && !isArmed)
		{
			BeginArming();
		}
		if (beginCountdown && !timerReached)
		{
			timer += Time.deltaTime;
			if (timer >= ArmDelay)
			{
				isSet = true;
				beginCountdown = false;
				timerReached = true;
				isArmed = true;
			}
		}
		if (isSet && isArmed && !hasBounced && !hasExploded)
		{
			Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, ProxRange, LayerMask.op_Implicit(LM_Prox));
			if (array.Length > 0)
			{
				hasBounced = true;
				((MonoBehaviour)this).StartCoroutine(BounceAndExplode());
			}
		}
	}

	public override void OnCollisionEnter(Collision collision)
	{
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		if (isPinPulled && !isStuck && !((FVRInteractiveObject)this).IsHeld && ((1 << collision.gameObject.layer) & (LayerMask.GetMask(new string[1] { "Default" }) | LayerMask.GetMask(new string[1] { "Environment" }))) != 0)
		{
			ContactPoint val = collision.contacts[0];
			((Component)this).transform.position = ((ContactPoint)(ref val)).point;
			stuckNormal = ((ContactPoint)(ref val)).normal;
			stuckToSurface = collision.transform;
			Rigidbody component = ((Component)this).GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				component.isKinematic = true;
				component.velocity = Vector3.zero;
				component.angularVelocity = Vector3.zero;
			}
			isStuck = true;
			if ((Object)(object)BottomPartToDisable != (Object)null)
			{
				BottomPartToDisable.SetActive(false);
			}
		}
	}

	private void BeginArming()
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		beginCountdown = true;
		timer = 0f;
		if (ArmSound != null)
		{
			SM.PlayCoreSound((FVRPooledAudioType)0, ArmSound, ((Component)this).transform.position);
		}
	}

	private IEnumerator BounceAndExplode()
	{
		Rigidbody rb = ((Component)this).GetComponent<Rigidbody>();
		if ((Object)(object)rb == (Object)null)
		{
			rb = ((Component)this).gameObject.AddComponent<Rigidbody>();
		}
		rb.isKinematic = false;
		float bounceVel = Mathf.Sqrt(19.62f * BounceHeight);
		rb.velocity = Vector3.zero;
		rb.AddForce(Vector3.up * bounceVel, (ForceMode)2);
		if (LaunchSound != null)
		{
			SM.PlayCoreSound((FVRPooledAudioType)0, LaunchSound, ((Component)this).transform.position);
		}
		yield return (object)new WaitForSeconds(ExplosionDelay);
		TriggerExplosion();
	}

	private void TriggerExplosion()
	{
		//IL_0032: 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)
		if (hasExploded)
		{
			return;
		}
		hasExploded = true;
		for (int i = 0; i < base.SpawnOnSplode.Count; i++)
		{
			GameObject val = Object.Instantiate<GameObject>(base.SpawnOnSplode[i], ((Component)this).transform.position, Quaternion.identity);
			Explosion component = val.GetComponent<Explosion>();
			if ((Object)(object)component != (Object)null)
			{
				component.IFF = base.IFF;
			}
			ExplosionSound component2 = val.GetComponent<ExplosionSound>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.IFF = base.IFF;
			}
			GrenadeExplosion component3 = val.GetComponent<GrenadeExplosion>();
			if ((Object)(object)component3 != (Object)null)
			{
				component3.IFF = base.IFF;
			}
		}
		if ((Object)(object)base.SmokeEmitter != (Object)null)
		{
			base.SmokeEmitter.Engaged = true;
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.red;
		Gizmos.DrawWireSphere(((Component)this).transform.position, ProxRange);
	}

	public override void FVRFixedUpdate()
	{
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		((PinnedGrenade)this).FVRFixedUpdate();
		base.m_isImpactFuseActive = false;
		base.m_impactFuseBurnDown = float.MaxValue;
		Rigidbody component = ((Component)this).GetComponent<Rigidbody>();
		if ((Object)(object)component != (Object)null && !isStuck && isPinPulled && !((FVRInteractiveObject)this).IsHeld)
		{
			Vector3 velocity = component.velocity;
			RaycastHit val = default(RaycastHit);
			if (((Vector3)(ref velocity)).magnitude <= MinStickVelocity && (Object)(object)RaycastDir != (Object)null && Physics.Raycast(RaycastDir.position, RaycastDir.forward, ref val, 2f, LayerMask.op_Implicit(StickLayer)))
			{
				isStuck = true;
				isLocked = true;
				component.isKinematic = true;
				component.velocity = Vector3.zero;
				component.angularVelocity = Vector3.zero;
				((Component)this).transform.position = ((RaycastHit)(ref val)).point;
				stuckNormal = ((RaycastHit)(ref val)).normal;
				stuckToSurface = ((RaycastHit)(ref val)).transform;
				if ((Object)(object)BottomPartToDisable != (Object)null)
				{
					BottomPartToDisable.SetActive(false);
				}
			}
		}
		if (isLocked && ((FVRInteractiveObject)this).IsHeld)
		{
			isLocked = false;
			if ((Object)(object)component != (Object)null)
			{
				component.isKinematic = false;
			}
		}
	}
}
[Serializable]
public class GrenadeExplosionMapping
{
	[Tooltip("The ScriptableObject asset name of the rifle grenade round (e.g., 'RifleGrenade_HEAT' or 'M9_Frag').")]
	public string RoundNameID;

	[Tooltip("The custom explosion prefabs to trigger if this specific grenade is loaded and shot with a live round.")]
	public List<GameObject> ExplosionPrefabs = new List<GameObject>();
}
public class RifleGrenadeAdapterFixed : MuzzleDevice
{
	private enum WeaponActionType
	{
		None,
		OpenBolt,
		ClosedBolt,
		Handgun
	}

	[Header("Rifle Grenade Adapter Config")]
	public FVRFireArmChamber GrenadeChamber;

	public Transform GrenadeMuzzle;

	public float VelocityMultiplier = 1f;

	public float RangeOverride = -1f;

	public FVRFireArmRecoilProfile OverrideRecoilProfile;

	public FVRFireArmRecoilProfile OverrideRecoilProfileStocked;

	public AudioEvent GrenadeShot;

	[Tooltip("Normally, only caseless rounds will be removed from the chamber when fired. Enabling this will also remove fired cased rounds from the chamber automatically.")]
	public bool DoesClearCasedRounds = false;

	[Header("Safe Rounds Settings (\"Blank Firing rounds\")")]
	[Tooltip("Do you need to use a specific round class to not make the grenade go boom on the muzzle?\nLike Blank firing rounds and such.")]
	public bool UsesSafeRoundClass = false;

	public FireArmRoundClass SafeRoundClass;

	[Tooltip("Fallback explosion prefabs to spawn on the barrel if the loaded grenade's submunitions cannot be resolved statically.")]
	public List<GameObject> DefaultExplosionPrefabs = new List<GameObject>();

	[Header("Custom Grenade Detonation Map")]
	[Tooltip("List of specific rifle grenades and their custom on-barrel explosion prefabs.")]
	public List<GrenadeExplosionMapping> CustomDetonationMaps = new List<GrenadeExplosionMapping>();

	[Header("Gas Cutoff Configuration")]
	[Tooltip("If enabled, the player can manually shut off the gas system using the valve component.")]
	public bool SupportsManualGasCutoff = true;

	[Tooltip("If true, chambering a blank round will automatically cut off the gas, requiring a manual cycle.")]
	public bool AutoCutoffOnBlank = true;

	[Header("Gas Valve Animation & Sound")]
	public Transform GasValveGeo;

	[Tooltip("How fast the transition occurs (1 / duration in seconds). E.g., 2 means 0.5 seconds.")]
	public float TransitionSpeed = 2f;

	public AudioEvent AudEvent_ValveOpen;

	public AudioEvent AudEvent_ValveClose;

	[Header("Valve Local Transformations (Open vs. Closed)")]
	[Tooltip("The local position of the valve when the gas system is OPEN (normal weapon cycling).")]
	public Vector3 OpenLocalPosition = Vector3.zero;

	[Tooltip("The local position of the valve when the gas system is CLOSED (manual cycling required).")]
	public Vector3 ClosedLocalPosition = Vector3.zero;

	[Space(5f)]
	[Tooltip("The local Euler angles of the valve when the gas system is OPEN (normal weapon cycling).")]
	public Vector3 OpenLocalRotation = Vector3.zero;

	[Tooltip("The local Euler angles of the valve when the gas system is CLOSED (manual cycling required).")]
	public Vector3 ClosedLocalRotation = Vector3.zero;

	[Header("One-Handed Firing Penalty")]
	[Tooltip("If enabled, firing the grenade one-handed (without stabilization) forces the player to drop the gun.")]
	public bool ForceDropOneHanded = true;

	[Tooltip("If true, shoulder-bracing (stock pressed to chest) bypasses the one-handed drop penalty.")]
	public bool AllowShoulderStabilization = true;

	[Tooltip("How violently the gun kicks backward out of the hands during a one-handed drop.")]
	public float RearwardLurchForce = 12f;

	private Vector3 _origMuzzlePos;

	private Quaternion _origMuzzleRot;

	private FVRFireArm _fireArm;

	private FVRFireArmRecoilProfile _origRecoilProfile;

	private FVRFireArmRecoilProfile _origRecoilProfileStocked;

	private bool _recoilProfileSet = false;

	private bool _isFiringGrenade = false;

	private bool _isGasCutoffActive = false;

	private bool _isBoltSpeedModified = false;

	private float _prevBoltSpeedRearward = 0f;

	private float _valveProgress = 0f;

	public override void Awake()
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Expected O, but got Unknown
		((MuzzleDevice)this).Awake();
		_origMuzzlePos = base.Muzzle.localPosition;
		_origMuzzleRot = base.Muzzle.localRotation;
		_valveProgress = 0f;
		OpenScripts2_BasePlugin.ProjectileFiredEvent += new ProjectileFired(ProjectileFiredEvent);
	}

	private void ProjectileFiredEvent(FVRFireArm fireArm, ref BallisticProjectile projectile)
	{
		if (!_isFiringGrenade && !((Object)(object)((FVRFireArmAttachment)this).curMount == (Object)null) && !((Object)(object)((FVRFireArmAttachment)this).curMount.GetRootMount() == (Object)null) && !((Object)(object)GrenadeChamber == (Object)null) && (Object)(object)fireArm == (Object)(object)((FVRFireArmAttachment)this).curMount.GetRootMount().MyObject && GrenadeChamber.IsFull)
		{
			Object.Destroy((Object)(object)((Component)projectile).gameObject);
		}
	}

	public override void OnDestroy()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		OpenScripts2_BasePlugin.ProjectileFiredEvent -= new ProjectileFired(ProjectileFiredEvent);
		((FVRPhysicalObject)this).OnDestroy();
	}

	public override void FVRUpdate()
	{
		((FVRPhysicalObject)this).FVRUpdate();
		if ((Object)(object)((FVRFireArmAttachment)this).curMount != (Object)null && (Object)(object)_fireArm == (Object)null)
		{
			ref FVRFireArm fireArm = ref _fireArm;
			FVRPhysicalObject myObject = ((FVRFireArmAttachment)this).curMount.GetRootMount().MyObject;
			fireArm = (FVRFireArm)(object)((myObject is FVRFireArm) ? myObject : null);
		}
		else if ((Object)(object)((FVRFireArmAttachment)this).curMount == (Object)null && (Object)(object)_fireArm != (Object)null)
		{
			OnDetach();
		}
		if ((Object)(object)GrenadeChamber == (Object)null)
		{
			return;
		}
		if (GrenadeChamber.IsFull)
		{
			if (!_recoilProfileSet && (Object)(object)_fireArm != (Object)null && (Object)(object)OverrideRecoilProfile != (Object)null)
			{
				_origRecoilProfile = _fireArm.RecoilProfile;
				_origRecoilProfileStocked = _fireArm.RecoilProfileStocked;
				if ((Object)(object)OverrideRecoilProfileStocked != (Object)null)
				{
					_fireArm.RecoilProfile = OverrideRecoilProfile;
					_fireArm.RecoilProfileStocked = OverrideRecoilProfileStocked;
				}
				else
				{
					_fireArm.RecoilProfile = OverrideRecoilProfile;
					_fireArm.RecoilProfileStocked = OverrideRecoilProfile;
				}
				_recoilProfileSet = true;
			}
			if (GrenadeChamber.IsSpent && (GrenadeChamber.GetRound().IsCaseless || DoesClearCasedRounds))
			{
				GrenadeChamber.Unload();
			}
		}
		else if (_recoilProfileSet && (Object)(object)_fireArm != (Object)null)
		{
			_fireArm.RecoilProfile = _origRecoilProfile;
			_fireArm.RecoilProfileStocked = _origRecoilProfileStocked;
			_recoilProfileSet = false;
		}
		UpdateGasCutoffState();
		UpdateValveAnimation();
	}

	private void OnDetach()
	{
		if (_recoilProfileSet && (Object)(object)_fireArm != (Object)null)
		{
			_fireArm.RecoilProfile = _origRecoilProfile;
			_fireArm.RecoilProfileStocked = _origRecoilProfileStocked;
			_recoilProfileSet = false;
		}
		if (_isBoltSpeedModified && (Object)(object)_fireArm != (Object)null)
		{
			WeaponActionType weaponActionType = GetWeaponActionType(_fireArm);
			if (weaponActionType != WeaponActionType.None)
			{
				SetBoltSpeedRearward(_fireArm, weaponActionType, _prevBoltSpeedRearward);
			}
			_isBoltSpeedModified = false;
		}
		_fireArm = null;
	}

	public void ToggleGasCutoff()
	{
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		if (SupportsManualGasCutoff)
		{
			_isGasCutoffActive = !_isGasCutoffActive;
			AudioEvent val = ((!_isGasCutoffActive) ? AudEvent_ValveOpen : AudEvent_ValveClose);
			if ((Object)(object)_fireArm != (Object)null)
			{
				_fireArm.PlayAudioAsHandling(val, ((Component)this).transform.position);
			}
			else
			{
				SM.PlayCoreSound((FVRPooledAudioType)10, val, ((Component)this).transform.position);
			}
		}
	}

	private void UpdateGasCutoffState()
	{
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_fireArm == (Object)null)
		{
			if (_isBoltSpeedModified)
			{
				_isBoltSpeedModified = false;
			}
			return;
		}
		WeaponActionType weaponActionType = GetWeaponActionType(_fireArm);
		if (weaponActionType == WeaponActionType.None)
		{
			return;
		}
		bool flag = false;
		FVRFireArmChamber currentChamber = OpenScripts2_BasePlugin.GetCurrentChamber(_fireArm);
		if ((Object)(object)currentChamber != (Object)null && (Object)(object)currentChamber.m_round != (Object)null && currentChamber.m_round.RoundClass == SafeRoundClass)
		{
			flag = true;
		}
		if (_isGasCutoffActive || (flag && AutoCutoffOnBlank))
		{
			if (!_isBoltSpeedModified)
			{
				_prevBoltSpeedRearward = GetBoltSpeedRearward(_fireArm, weaponActionType);
				SetBoltSpeedRearward(_fireArm, weaponActionType, 0f);
				_isBoltSpeedModified = true;
			}
		}
		else if (_isBoltSpeedModified)
		{
			SetBoltSpeedRearward(_fireArm, weaponActionType, _prevBoltSpeedRearward);
			_isBoltSpeedModified = false;
		}
	}

	private void UpdateValveAnimation()
	{
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: 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)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)GasValveGeo == (Object)null))
		{
			float num = ((!_isGasCutoffActive) ? 0f : 1f);
			if (Mathf.Abs(_valveProgress - num) > 0.001f)
			{
				_valveProgress = Mathf.MoveTowards(_valveProgress, num, Time.deltaTime * TransitionSpeed);
				GasValveGeo.localPosition = Vector3.Lerp(OpenLocalPosition, ClosedLocalPosition, _valveProgress);
				GasValveGeo.localRotation = Quaternion.Slerp(Quaternion.Euler(OpenLocalRotation), Quaternion.Euler(ClosedLocalRotation), _valveProgress);
			}
		}
	}

	public override void OnShot(FVRFireArm f, FVRTailSoundClass tailClass)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		((MuzzleDevice)this).OnShot(f, tailClass);
		FireGrenade();
	}

	private void FireGrenade()
	{
		//IL_0424: Unknown result type (might be due to invalid IL or missing references)
		//IL_043d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0442: Unknown result type (might be due to invalid IL or missing references)
		//IL_044c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0451: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_049e: Unknown result type (might be due to invalid IL or missing references)
		//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0501: Unknown result type (might be due to invalid IL or missing references)
		//IL_0508: Unknown result type (might be due to invalid IL or missing references)
		//IL_050d: Unknown result type (might be due to invalid IL or missing references)
		//IL_053c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0572: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0409: Unknown result type (might be due to invalid IL or missing references)
		//IL_040e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0412: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)GrenadeChamber == (Object)null || (Object)(object)_fireArm == (Object)null)
		{
			return;
		}
		if (UsesSafeRoundClass && GrenadeChamber.IsFull && !GrenadeChamber.IsSpent)
		{
			FVRFireArmChamber currentChamber = OpenScripts2_BasePlugin.GetCurrentChamber(_fireArm);
			if ((Object)(object)currentChamber != (Object)null && (Object)(object)currentChamber.m_round != (Object)null && currentChamber.m_round.RoundClass != SafeRoundClass)
			{
				FVRFireArmRound loadedGrenade = GrenadeChamber.GetRound();
				List<GameObject> list = new List<GameObject>();
				if ((Object)(object)loadedGrenade != (Object)null && CustomDetonationMaps != null && CustomDetonationMaps.Count > 0)
				{
					GrenadeExplosionMapping grenadeExplosionMapping = CustomDetonationMaps.FirstOrDefault((GrenadeExplosionMapping map) => !string.IsNullOrEmpty(map.RoundNameID) && ((Object)loadedGrenade).name.IndexOf(map.RoundNameID, StringComparison.OrdinalIgnoreCase) >= 0);
					if (grenadeExplosionMapping != null && grenadeExplosionMapping.ExplosionPrefabs != null && grenadeExplosionMapping.ExplosionPrefabs.Count > 0)
					{
						list = grenadeExplosionMapping.ExplosionPrefabs;
					}
				}
				if (list.Count == 0 && DefaultExplosionPrefabs != null && DefaultExplosionPrefabs.Count > 0)
				{
					list = DefaultExplosionPrefabs;
				}
				if (list.Count == 0)
				{
					BallisticProjectile val = ((!((Object)(object)loadedGrenade != (Object)null) || !((Object)(object)loadedGrenade.BallisticProjectilePrefab != (Object)null)) ? null : loadedGrenade.BallisticProjectilePrefab.GetComponent<BallisticProjectile>());
					if ((Object)(object)val != (Object)null && val.Submunitions != null)
					{
						foreach (Submunition item in val.Submunitions.Where((Submunition submun) => (int)submun.Type == 0))
						{
							if (item.Prefabs == null)
							{
								continue;
							}
							foreach (GameObject prefab in item.Prefabs)
							{
								if ((Object)(object)prefab != (Object)null)
								{
									list.Add(prefab);
								}
							}
						}
					}
				}
				foreach (GameObject item2 in list)
				{
					if ((Object)(object)item2 != (Object)null)
					{
						Object.Instantiate<GameObject>(item2, ((Component)this).transform.TransformPoint(_origMuzzlePos), ((Component)this).transform.rotation);
					}
				}
				GrenadeChamber.Unload();
				return;
			}
		}
		if (!GrenadeChamber.Fire())
		{
			return;
		}
		if (ForceDropOneHanded && !_fireArm.IsTwoHandStabilized() && !_fireArm.IsForegripStabilized() && (!AllowShoulderStabilization || !_fireArm.IsShoulderStabilized()))
		{
			FVRAlternateGrip altGrip = ((FVRPhysicalObject)_fireArm).AltGrip;
			((FVRInteractiveObject)_fireArm).ForceBreakInteraction();
			if ((Object)(object)altGrip != (Object)null)
			{
				((FVRInteractiveObject)altGrip).ForceBreakInteraction();
			}
			Rigidbody rootRigidbody = ((FVRPhysicalObject)_fireArm).RootRigidbody;
			if ((Object)(object)rootRigidbody != (Object)null && !rootRigidbody.isKinematic)
			{
				Vector3 val2 = -GrenadeMuzzle.forward * RearwardLurchForce + Vector3.up * (RearwardLurchForce * 0.33f);
				rootRigidbody.AddForce(val2, (ForceMode)1);
				Vector3 val3 = Random.onUnitSphere * (RearwardLurchForce * 0.66f);
				rootRigidbody.AddTorque(val3, (ForceMode)1);
			}
		}
		float num = _fireArm.GetCombinedFixedDrop(base.MechanicalAccuracy) * 0.0166667f;
		Vector2 val4 = _fireArm.GetCombinedFixedDrift(base.MechanicalAccuracy) * 0.0166667f;
		_isFiringGrenade = true;
		for (int num2 = 0; num2 < GrenadeChamber.GetRound().NumProjectiles; num2++)
		{
			float num3 = GrenadeChamber.GetRound().ProjectileSpread + base.m_mechanicalAccuracy;
			if ((Object)(object)GrenadeChamber.GetRound().BallisticProjectilePrefab != (Object)null)
			{
				Vector3 val5 = GrenadeMuzzle.forward * 0.005f;
				GameObject val6 = Object.Instantiate<GameObject>(GrenadeChamber.GetRound().BallisticProjectilePrefab, GrenadeMuzzle.position - val5, GrenadeMuzzle.rotation);
				Vector2 val7 = (Random.insideUnitCircle + Random.insideUnitCircle + Random.insideUnitCircle) * (1f / 3f) * num3;
				val6.transform.Rotate(new Vector3(val7.x + val4.y + num, val7.y + val4.x, 0f));
				BallisticProjectile component = val6.GetComponent<BallisticProjectile>();
				component.Fire(component.MuzzleVelocityBase * GrenadeChamber.ChamberVelocityMultiplier * VelocityMultiplier, val6.transform.forward, _fireArm, true);
				if (RangeOverride > 0f)
				{
					component.ForceSetMaxDist(RangeOverride);
				}
			}
		}
		_isFiringGrenade = false;
		SM.PlayCoreSound((FVRPooledAudioType)1, GrenadeShot, GrenadeMuzzle.position);
	}

	private WeaponActionType GetWeaponActionType(FVRFireArm weapon)
	{
		if (weapon is OpenBoltReceiver)
		{
			return WeaponActionType.OpenBolt;
		}
		if (weapon is ClosedBoltWeapon)
		{
			return WeaponActionType.ClosedBolt;
		}
		if (weapon is Handgun)
		{
			return WeaponActionType.Handgun;
		}
		return WeaponActionType.None;
	}

	private float GetBoltSpeedRearward(FVRFireArm weapon, WeaponActionType type)
	{
		switch (type)
		{
		case WeaponActionType.OpenBolt:
		{
			OpenBoltReceiver val3 = (OpenBoltReceiver)(object)((weapon is OpenBoltReceiver) ? weapon : null);
			return (!((Object)(object)val3 != (Object)null) || !((Object)(object)val3.Bolt != (Object)null)) ? 0f : val3.Bolt.BoltSpeed_Rearward;
		}
		case WeaponActionType.ClosedBolt:
		{
			ClosedBoltWeapon val2 = (ClosedBoltWeapon)(object)((weapon is ClosedBoltWeapon) ? weapon : null);
			return (!((Object)(object)val2 != (Object)null) || !((Object)(object)val2.Bolt != (Object)null)) ? 0f : val2.Bolt.Speed_Rearward;
		}
		case WeaponActionType.Handgun:
		{
			Handgun val = (Handgun)(object)((weapon is Handgun) ? weapon : null);
			return (!((Object)(object)val != (Object)null) || !((Object)(object)val.Slide != (Object)null)) ? 0f : val.Slide.Speed_Rearward;
		}
		default:
			return 0f;
		}
	}

	private void SetBoltSpeedRearward(FVRFireArm weapon, WeaponActionType type, float speed)
	{
		switch (type)
		{
		case WeaponActionType.OpenBolt:
		{
			OpenBoltReceiver val3 = (OpenBoltReceiver)(object)((weapon is OpenBoltReceiver) ? weapon : null);
			if ((Object)(object)val3 != (Object)null && (Object)(object)val3.Bolt != (Object)null)
			{
				val3.Bolt.BoltSpeed_Rearward = speed;
			}
			break;
		}
		case WeaponActionType.ClosedBolt:
		{
			ClosedBoltWeapon val2 = (ClosedBoltWeapon)(object)((weapon is ClosedBoltWeapon) ? weapon : null);
			if ((Object)(object)val2 != (Object)null && (Object)(object)val2.Bolt != (Object)null)
			{
				val2.Bolt.Speed_Rearward = speed;
			}
			break;
		}
		case WeaponActionType.Handgun:
		{
			Handgun val = (Handgun)(object)((weapon is Handgun) ? weapon : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val.Slide != (Object)null)
			{
				val.Slide.Speed_Rearward = speed;
			}
			break;
		}
		}
	}
}
public class RifleGrenadeGasValve : FVRInteractiveObject
{
	public RifleGrenadeAdapterFixed Adapter;

	public override void SimpleInteraction(FVRViveHand hand)
	{
		((FVRInteractiveObject)this).SimpleInteraction(hand);
		if ((Object)(object)Adapter != (Object)null)
		{
			Adapter.ToggleGasCutoff();
		}
	}
}
public class Idle : StateMachineBehaviour
{
}
public class LazeTargeting : FVRPhysicalObject
{
	[Header("Laze Settings")]
	public Transform LaserOrigin;

	public LayerMask LazeLayerMask;

	public GameObject ArrowIndicator;

	public Image FillBar;

	public Text StatusText;

	public AudioEvent ConfirmedSound;

	public AudioEvent DeniedSound;

	public AudioEvent ErrorSound;

	[Tooltip("List of possible strike prefabs. First is default.")]
	public List<GameObject> StrikePrefabs;

	public float HoldTimeToConfirm = 2f;

	public float CooldownTime = 5f;

	public float MaxLazeDistance = 500f;

	public float SpawnAltitude = 100f;

	public int StrikeCount = 1;

	public float StrikeInterval = 0.2f;

	public float StrikeSpread = 0f;

	public LayerMask SkyObstructionMask;

	[Header("Strike Type UI")]
	public GameObject StrikeTypeUI;

	[Header("Laser Visuals")]
	public LaserLight laserLight;

	public AudioEvent LaserOnSound;

	public AudioEvent LaserOffSound;

	[Header("Strike Type Text")]
	public GameObject TextRoot;

	public Text TextField;

	[Header("Strike Knob Visual")]
	public Transform StrikeKnobMesh;

	[Tooltip("Set true for translation, false for rotation, per strike type.")]
	public bool[] UseTranslationForStrike;

	public Vector3 KnobTranslation = new Vector3(0f, 0.02f, 0f);

	public Vector3 KnobRotation = new Vector3(0f, 30f, 0f);

	[Header("Laser Button Visual")]
	public Transform LaserButtonMesh;

	public Vector3 LaserButtonDefaultLocalPos = Vector3.zero;

	public Vector3 LaserButtonPressedLocalPos = new Vector3(0f, -0.01f, 0f);

	private float holdTimer = 0f;

	private float cooldownTimer = 0f;

	private bool isLazing = false;

	private RaycastHit hit;

	private int currentStrikeIndex = 0;

	private bool isStrikeTypeUIActive = false;

	private bool isButtonHeld = false;

	private float buttonHeldTime = 0f;

	private bool hasEventFiredSincePress = false;

	private float holdToOpenStrikeUI = 0.6f;

	private bool m_isLaserOn = false;

	public override void FVRUpdate()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: 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_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: 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_00a1: 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_011e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0677: 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)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0200: Unknown result type (might be due to invalid IL or missing references)
		//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0616: Unknown result type (might be due to invalid IL or missing references)
		//IL_0599: Unknown result type (might be due to invalid IL or missing references)
		//IL_0422: Unknown result type (might be due to invalid IL or missing references)
		//IL_0427: Unknown result type (might be due to invalid IL or missing references)
		//IL_0432: Unknown result type (might be due to invalid IL or missing references)
		//IL_0437: Unknown result type (might be due to invalid IL or missing references)
		//IL_043c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0448: Unknown result type (might be due to invalid IL or missing references)
		//IL_0477: Unknown result type (might be due to invalid IL or missing references)
		//IL_048f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0503: Unknown result type (might be due to invalid IL or missing references)
		//IL_0539: Unknown result type (might be due to invalid IL or missing references)
		//IL_055a: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
		((FVRPhysicalObject)this).FVRUpdate();
		UpdateLaserVisual();
		Vector3 position = LaserOrigin.position;
		Vector3 forward = LaserOrigin.forward;
		float num = 1000f;
		bool flag = Physics.Raycast(position, forward, ref hit, num, LayerMask.op_Implicit(LazeLayerMask));
		Vector3 position2;
		Vector3 up;
		if (flag)
		{
			position2 = ((RaycastHit)(ref hit)).point;
			up = ((RaycastHit)(ref hit)).normal;
		}
		else
		{
			position2 = position + forward * num;
			up = Vector3.up;
		}
		if ((Object)(object)ArrowIndicator != (Object)null)
		{
			ArrowIndicator.transform.position = position2;
			ArrowIndicator.transform.up = up;
			ArrowIndicator.SetActive(true);
		}
		if ((Object)(object)LaserButtonMesh != (Object)null)
		{
			LaserButtonMesh.localPosition = ((!m_isLaserOn) ? LaserButtonDefaultLocalPos : LaserButtonPressedLocalPos);
		}
		FVRViveHand hand = ((FVRInteractiveObject)this).m_hand;
		if ((Object)(object)hand != (Object)null)
		{
			Vector2 touchpadAxes = hand.Input.TouchpadAxes;
			bool flag2 = (hand.IsInStreamlinedMode && hand.Input.BYButtonDown) || (!hand.IsInStreamlinedMode && hand.Input.TouchpadDown && Vector2.Angle(touchpadAxes, Vector2.up) <= 45f);
			bool flag3 = (hand.IsInStreamlinedMode && hand.Input.BYButtonUp) || (!hand.IsInStreamlinedMode && hand.Input.TouchpadUp);
			if ((hand.IsInStreamlinedMode && hand.Input.AXButtonDown) || (!hand.IsInStreamlinedMode && hand.Input.TouchpadDown && Vector2.Angle(hand.Input.TouchpadAxes, Vector2.left) < 45f))
			{
				ToggleLaser();
			}
			if (flag2)
			{
				isButtonHeld = true;
				hasEventFiredSincePress = false;
				buttonHeldTime = 0f;
			}
			if (flag3)
			{
				if (!hasEventFiredSincePress && buttonHeldTime < holdToOpenStrikeUI && StrikePrefabs != null && StrikePrefabs.Count > 0)
				{
					currentStrikeIndex = (currentStrikeIndex + 1) % StrikePrefabs.Count;
					ShowStrikeText();
					UpdateStrikeKnobVisual();
				}
				isButtonHeld = false;
				buttonHeldTime = 0f;
				if (isStrikeTypeUIActive)
				{
					isStrikeTypeUIActive = false;
					if ((Object)(object)StrikeTypeUI != (Object)null)
					{
						StrikeTypeUI.SetActive(false);
					}
				}
			}
			if (isButtonHeld && !hasEventFiredSincePress)
			{
				buttonHeldTime += Time.deltaTime;
				if (buttonHeldTime >= holdToOpenStrikeUI)
				{
					hasEventFiredSincePress = true;
					isStrikeTypeUIActive = !isStrikeTypeUIActive;
					if ((Object)(object)StrikeTypeUI != (Object)null)
					{
						StrikeTypeUI.SetActive(isStrikeTypeUIActive);
					}
					if (isStrikeTypeUIActive)
					{
						ShowStrikeText();
					}
				}
			}
			if (m_isLaserOn && hand.Input.TriggerPressed && cooldownTimer <= 0f && !isStrikeTypeUIActive)
			{
				if (flag)
				{
					holdTimer += Time.deltaTime;
					FillBar.fillAmount = holdTimer / HoldTimeToConfirm;
					StatusText.text = "Lazing...";
					if (holdTimer >= HoldTimeToConfirm)
					{
						bool flag4 = ((RaycastHit)(ref hit)).distance > MaxLazeDistance;
						bool flag5 = Physics.Raycast(((RaycastHit)(ref hit)).point + Vector3.up * SpawnAltitude, Vector3.down, SpawnAltitude, LayerMask.op_Implicit(SkyObstructionMask));
						if (flag4)
						{
							StatusText.text = "Target too far!";
							((Graphic)FillBar).color = Color.red;
							SM.PlayCoreSound((FVRPooledAudioType)10, DeniedSound, ((RaycastHit)(ref hit)).point);
							holdTimer = 0f;
							return;
						}
						if (flag5)
						{
							StatusText.text = "No sky sight!";
							((Graphic)FillBar).color = Color.red;
							SM.PlayCoreSound((FVRPooledAudioType)10, ErrorSound, ((RaycastHit)(ref hit)).point);
							holdTimer = 0f;
							return;
						}
						((MonoBehaviour)this).StartCoroutine(SpawnStrikeBarrage(((RaycastHit)(ref hit)).point, StrikeCount, StrikeInterval, StrikeSpread, SpawnAltitude));
						SM.PlayCoreSound((FVRPooledAudioType)10, ConfirmedSound, ((RaycastHit)(ref hit)).point);
						StatusText.text = "Strike Confirmed!";
						((Graphic)FillBar).color = Color.green;
						cooldownTimer = CooldownTime;
						holdTimer = 0f;
					}
				}
				else
				{
					StatusText.text = "No Target";
					((Graphic)FillBar).color = Color.red;
					FillBar.fillAmount = 0f;
					holdTimer = 0f;
				}
			}
			else
			{
				if (holdTimer > 0f && cooldownTimer <= 0f)
				{
					SM.PlayCoreSound((FVRPooledAudioType)10, DeniedSound, ((Component)this).transform.position);
					StatusText.text = "Cancelled";
					((Graphic)FillBar).color = Color.red;
				}
				holdTimer = 0f;
				FillBar.fillAmount = 0f;
			}
		}
		if (cooldownTimer > 0f)
		{
			cooldownTimer -= Time.deltaTime;
			StatusText.text = "Cooldown...";
			((Graphic)FillBar).color = Color.yellow;
		}
	}

	private void UpdateLaserVisual()
	{
		//IL_0039: 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)
		if (!((Object)(object)laserLight == (Object)null) && !((Object)(object)LaserOrigin == (Object)null))
		{
			laserLight.LaserAperture.position = LaserOrigin.position;
			laserLight.LaserAperture.rotation = LaserOrigin.rotation;
			laserLight.IsActive = m_isLaserOn;
		}
	}

	public void ToggleLaser()
	{
		//IL_0056: 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)
		m_isLaserOn = !m_isLaserOn;
		if ((Object)(object)laserLight != (Object)null)
		{
			laserLight.IsActive = m_isLaserOn;
		}
		if (m_isLaserOn && LaserOnSound != null)
		{
			SM.PlayCoreSound((FVRPooledAudioType)10, LaserOnSound, ((Component)this).transform.position);
		}
		else if (!m_isLaserOn && LaserOffSound != null)
		{
			SM.PlayCoreSound((FVRPooledAudioType)10, LaserOffSound, ((Component)this).transform.position);
		}
	}

	public void SetStrikeIndex(int idx)
	{
		if (StrikePrefabs != null && StrikePrefabs.Count != 0)
		{
			currentStrikeIndex = Mathf.Clamp(idx, 0, StrikePrefabs.Count - 1);
			ShowStrikeText();
			UpdateStrikeKnobVisual();
		}
	}

	private void ShowStrikeText()
	{
		if ((Object)(object)TextField != (Object)null && StrikePrefabs != null && StrikePrefabs.Count > 0)
		{
			TextField.text = "Strike: " + ((Object)StrikePrefabs[currentStrikeIndex]).name;
			if ((Object)(object)TextRoot != (Object)null)
			{
				TextRoot.SetActive(true);
			}
			((MonoBehaviour)this).StopCoroutine("HideStrikeText");
			((MonoBehaviour)this).StartCoroutine("HideStrikeText");
		}
		if ((Object)(object)StatusText != (Object)null && StrikePrefabs != null && StrikePrefabs.Count > 0)
		{
			StatusText.text = "Strike: " + ((Object)StrikePrefabs[currentStrikeIndex]).name;
		}
	}

	private void UpdateStrikeKnobVisual()
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)StrikeKnobMesh == (Object)null) && StrikePrefabs != null && StrikePrefabs.Count != 0)
		{
			int num = currentStrikeIndex;
			bool flag = false;
			if (UseTranslationForStrike != null && num < UseTranslationForStrike.Length)
			{
				flag = UseTranslationForStrike[num];
			}
			if (flag)
			{
				StrikeKnobMesh.localPosition = KnobTranslation * (float)num;
				StrikeKnobMesh.localRotation = Quaternion.identity;
			}
			else
			{
				StrikeKnobMesh.localPosition = Vector3.zero;
				StrikeKnobMesh.localRotation = Quaternion.Euler(KnobRotation * (float)num);
			}
		}
	}

	private IEnumerator HideStrikeText()
	{
		yield return (object)new WaitForSeconds(1f);
		if ((Object)(object)TextRoot != (Object)null)
		{
			TextRoot.SetActive(false);
		}
	}

	private IEnumerator SpawnStrikeBarrage(Vector3 target, int count, float interval, float spread, float altitude)
	{
		//IL_0016: 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)
		Debug.Log((object)("SpawnStrikeBarrage called. Prefab count: " + ((StrikePrefabs == null) ? "null" : StrikePrefabs.Count.ToString())));
		for (int i = 0; i < count; i++)
		{
			Vector3 offset = (Vector3)((!(spread > 0f)) ? Vector3.zero : new Vector3(Random.Range(0f - spread, spread), 0f, Random.Range(0f - spread, spread)));
			Vector3 spawnPos = target + offset + Vector3.up * altitude;
			if (StrikePrefabs != null && StrikePrefabs.Count > 0 && (Object)(object)StrikePrefabs[currentStrikeIndex] != (Object)null)
			{
				Debug.Log((object)("Spawning prefab: " + ((Object)StrikePrefabs[currentStrikeIndex]).name + " at " + spawnPos));
				Object.Instantiate<GameObject>(StrikePrefabs[currentStrikeIndex], spawnPos, Quaternion.identity);
			}
			else
			{
				Debug.LogError((object)"Strike prefab is null or not assigned!");
			}
			yield return (object)new WaitForSeconds(interval);
		}
	}
}
public class FVRCappedGrenadeCapExtended : FVRCappedGrenadeCap
{
	[Header("Extra Behaviours")]
	public GameObject EnableOnRemove;

	public GameObject ExplosionPrefab;

	public LayerMask TriggerLayers;

	public float ImpactVelocity = 2f;

	private bool _isRemoved = false;

	public override void BeginInteraction(FVRViveHand hand)
	{
		((FVRCappedGrenadeCap)this).BeginInteraction(hand);
		if (!_isRemoved)
		{
			_isRemoved = true;
			if ((Object)(object)EnableOnRemove != (Object)null)
			{
				EnableOnRemove.SetActive(true);
			}
		}
	}

	private void OnCollisionEnter(Collision col)
	{
		//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_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		if (!_isRemoved)
		{
			return;
		}
		Vector3 relativeVelocity = col.relativeVelocity;
		if (((Vector3)(ref relativeVelocity)).magnitude > ImpactVelocity && ((1 << col.gameObject.layer) & ((LayerMask)(ref TriggerLayers)).value) != 0)
		{
			if ((Object)(object)ExplosionPrefab != (Object)null)
			{
				Object.Instantiate<GameObject>(ExplosionPrefab, ((Component)this).transform.position, Quaternion.identity);
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
}
public class LungeMine : FVRCappedGrenade
{
	[Header("Lunge Mine Settings")]
	public bool ExplodeOnAnyContactWhenArmed = false;

	public LayerMask TriggerLayers = LayerMask.op_Implicit(-1);

	public bool ForceArmOnPrimaryCap = true;

	public float MinArmedDelay = 0f;

	private bool m_isArmed = false;

	private float m_armedTime = -1f;

	private bool m_prevObservedArmedState = false;

	public override void Start()
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		((FVRCappedGrenade)this).Start();
		base.FuseType = (CappedGrenadeFuseType)1;
		if (ForceArmOnPrimaryCap)
		{
			base.UsesSecondaryCap = false;
		}
	}

	private void Update()
	{
		bool flag = (ForceArmOnPrimaryCap ? base.IsPrimaryCapRemoved : ((!base.UsesSecondaryCap) ? base.IsPrimaryCapRemoved : (base.IsPrimaryCapRemoved && base.IsSecondaryCapRemoved)));
		if (flag && !m_prevObservedArmedState)
		{
			m_isArmed = true;
			m_armedTime = Time.time;
		}
		else if (!flag && m_prevObservedArmedState)
		{
			m_isArmed = false;
			m_armedTime = -1f;
		}
		m_prevObservedArmedState = flag;
	}

	public override void OnCollisionEnter(Collision col)
	{
		//IL_0067: 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_0099: Unknown result type (might be due to invalid IL or missing references)
		((FVRCappedGrenade)this).OnCollisionEnter(col);
		if (!m_isArmed || (MinArmedDelay > 0f && m_armedTime > 0f && Time.time - m_armedTime < MinArmedDelay) || ((1 << col.gameObject.layer) & LayerMask.op_Implicit(TriggerLayers)) == 0)
		{
			return;
		}
		if (ExplodeOnAnyContactWhenArmed)
		{
			((FVRCappedGrenade)this).Explode();
			return;
		}
		Vector3 relativeVelocity = col.relativeVelocity;
		float magnitude = ((Vector3)(ref relativeVelocity)).magnitude;
		if (magnitude >= base.ImpactFuseVelThreshold)
		{
			((FVRCappedGrenade)this).Explode();
		}
	}

	public void Disarm()
	{
		m_isArmed = false;
		m_armedTime = -1f;
	}

	public void ForceDetonate()
	{
		((FVRCappedGrenade)this).Explode();
	}
}
public class LungeMineProng : MonoBehaviour
{
	[Tooltip("If left empty, the script will auto-find FVRCappedGrenade in parent.")]
	public FVRCappedGrenade Grenade;

	[Tooltip("Which layers can trigger the prong (set in inspector).")]
	public LayerMask TriggerLayers = LayerMask.op_Implicit(-1);

	[Tooltip("Minimum collision velocity required to trigger.")]
	public float MinVelocity = 1f;

	[Tooltip("Require grenade to be armed (cap removed) before it can detonate.")]
	public bool RequireArmed = true;

	[Tooltip("Show debug logs in console.")]
	public bool DebugEnabled = false;

	private void Start()
	{
		if ((Object)(object)Grenade == (Object)null)
		{
			Grenade = ((Component)this).GetComponentInParent<FVRCappedGrenade>();
			if (DebugEnabled)
			{
				Debug.Log((object)("[LungeMineProng] Auto-found grenade: " + ((Object)(object)Grenade != (Object)null)));
			}
		}
	}

	private void OnCollisionEnter(Collision col)
	{
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		if (DebugEnabled)
		{
			Debug.Log((object)"[LungeMineProng] OnCollisionEnter called.");
		}
		if (DebugEnabled)
		{
			Rigidbody component = ((Component)this).GetComponent<Rigidbody>();
			Collider component2 = ((Component)this).GetComponent<Collider>();
			Debug.Log((object)("[LungeMineProng] Rigidbody: " + ((Object)(object)component != (Object)null) + " Collider: " + ((Object)(object)component2 != (Object)null)));
		}
		if ((Object)(object)Grenade == (Object)null)
		{
			if (DebugEnabled)
			{
				Debug.Log((object)"[LungeMineProng] No grenade reference.");
			}
			return;
		}
		if (((1 << col.gameObject.layer) & ((LayerMask)(ref TriggerLayers)).value) == 0)
		{
			if (DebugEnabled)
			{
				Debug.Log((object)("[LungeMineProng] Wrong layer: " + LayerMask.LayerToName(col.gameObject.layer)));
			}
			return;
		}
		Vector3 relativeVelocity = col.relativeVelocity;
		float magnitude = ((Vector3)(ref relativeVelocity)).magnitude;
		if (magnitude < MinVelocity)
		{
			if (DebugEnabled)
			{
				Debug.Log((object)("[LungeMineProng] Hit too soft: " + magnitude));
			}
			return;
		}
		bool flag = true;
		if (RequireArmed)
		{
			PropertyInfo property = ((object)Grenade).GetType().GetProperty("IsPrimaryCapRemoved");
			if ((object)property != null)
			{
				flag = (bool)property.GetValue(Grenade, null);
			}
			else
			{
				if (DebugEnabled)
				{
					Debug.Log((object)"[LungeMineProng] Could not find IsPrimaryCapRemoved property.");
				}
				flag = false;
			}
		}
		if (!flag)
		{
			if (DebugEnabled)
			{
				Debug.Log((object)"[LungeMineProng] Grenade not armed yet.");
			}
			return;
		}
		if (DebugEnabled)
		{
			Debug.Log((object)("[LungeMineProng] Detonating! Velocity: " + magnitude + " Object: " + ((Object)col.gameObject).name));
		}
		((Component)Grenade).gameObject.SendMessage("Explode", (SendMessageOptions)1);
	}
}
namespace Volks.HandheldMortar;

[BepInPlugin("Volks.HandheldMortar", "HandheldMortar", "1.0.0")]
[BepInProcess("h3vr.exe")]
[Description("Built with MeatKit")]
[BepInDependency("h3vr.otherloader", "1.3.0")]
public class HandheldMortarPlugin : 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(), "Volks.HandheldMortar");
		OtherLoader.RegisterDirectLoad(BasePath, "Volks.HandheldMortar", "", "", "handheldmortar_launcher", "");
	}
}
public class AttachableHammerFirearm : AttachableFirearm
{
	[Header("Hammer Params")]
	public Transform Hammer;

	public bool HasVisibleHammer = true;

	public bool CanCockHammer = true;

	public Axis HammerAxis;

	public InterpStyle HammerInterp = (InterpStyle)1;

	public float HammerMinRot;

	public float HammerMaxRot = -70f;

	[Header("Trigger Params")]
	public Transform Trigger;

	public Vector2 TriggerForwardBackRots;

	[Header("Chamber")]
	public FVRFireArmChamber Chamber;

	private bool m_isHammerCocked;

	private bool m_isTriggerReset = true;

	public void CockHammer()
	{
		//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)
		if (!m_isHammerCocked && CanCockHammer)
		{
			m_isHammerCocked = true;
			if ((Object)(object)Hammer != (Object)null)
			{
				SetAnimatedComponent(Hammer, HammerMaxRot, HammerInterp, HammerAxis);
			}
			((AttachableFirearm)this).PlayAudioEvent((FirearmAudioEventType)7, 1f);
		}
	}

	public void SetHammerCocked(bool cocked)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		m_isHammerCocked = cocked;
		if ((Object)(object)Hammer != (Object)null)
		{
			float rot = ((!cocked) ? HammerMinRot : HammerMaxRot);
			SetAnimatedComponent(Hammer, rot, HammerInterp, HammerAxis);
		}
	}

	public override void ProcessInput(FVRViveHand hand, bool fromInterface, FVRInteractiveObject o)
	{
		//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_005f: Unknown result type (might be due to invalid IL or missing references)
		((AttachableFirearm)this).ProcessInput(hand, fromInterface, o);
		if ((Object)(object)Trigger != (Object)null)
		{
			float triggerFloat = hand.Input.TriggerFloat;
			float x = Mathf.Lerp(TriggerForwardBackRots.x, TriggerForwardBackRots.y, triggerFloat);
			Vector3 localEulerAngles = Trigger.localEulerAngles;
			localEulerAngles.x = x;
			Trigger.localEulerAngles = localEulerAngles;
		}
		if (CanCockHammer)
		{
			if (hand.IsInStreamlinedMode)
			{
				if (hand.Input.BYButtonDown)
				{
					CockHammer();
				}
			}
			else if (hand.Input.TouchpadUp)
			{
				CockHammer();
			}
		}
		if (m_isHammerCocked && hand.Input.TriggerFloat > 0.7f && m_isTriggerReset)
		{
			m_isTriggerReset = false;
			SetHammerCocked(cocked: false);
			if ((Object)(object)Chamber != (Object)null && Chamber.IsFull && !Chamber.IsSpent)
			{
				FireHammerAction(fromInterface);
			}
			else
			{
				((AttachableFirearm)this).PlayAudioEvent((FirearmAudioEventType)16, 1f);
			}
		}
		else if (hand.Input.TriggerFloat < 0.2f && !m_isTriggerReset)
		{
			m_isTriggerReset = true;
		}
	}

	private void FireHammerAction(bool firedFromInterface)
	{
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)Chamber != (Object)null && Chamber.Fire())
		{
			((AttachableFirearm)this).FireMuzzleSmoke();
			((AttachableFirearm)this).Fire(Chamber, ((AttachableFirearm)this).GetMuzzle(), true, (FVRFireArm)null, 1f);
			((AttachableFirearm)this).PlayAudioEvent((FirearmAudioEventType)6, 1f);
			((AttachableFirearm)this).PlayAudioGunShot(Chamber.GetRound(), GM.CurrentPlayerBody.GetCurrentSoundEnvironment(), 1f);
			Chamber.SetRound((FVRFireArmRound)null, false);
			Chamber.UpdateProxyDisplay();
		}
	}

	protected void SetAnimatedComponent(Transform t, float rot, InterpStyle interp, Axis axis)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Invalid comparison between Unknown and I4
		//IL_005d: 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_002b: Invalid comparison between Unknown and I4
		if ((Object)(object)t == (Object)null)
		{
			return;
		}
		Vector3 localEulerAngles = t.localEulerAngles;
		if ((int)axis != 0)
		{
			if ((int)axis != 1)
			{
				if ((int)axis == 2)
				{
					localEulerAngles.z = rot;
				}
			}
			else
			{
				localEulerAngles.y = rot;
			}
		}
		else
		{
			localEulerAngles.x = rot;
		}
		t.localEulerAngles = localEulerAngles;
	}
}
public class TripwireMine : FVRPhysicalObject
{
	[Header("Tripwire Settings")]
	public float TripwireMaxRange = 5f;

	public Material TripwireValidMat;

	public LineRenderer TripwireLineTemplate;

	[Header("Parts")]
	public GameObject DeployVisual;

	[Header("Explosion/Smoke")]
	public List<GameObject> SpawnOnTrigger;

	public SmokeSolidEmitter SmokeEmitter;

	[Header("Audio")]
	public AudioEvent TriggerSound;

	public AudioEvent PlantMineSound;

	[Header("Deployment")]
	public LayerMask DeployLayerMask = LayerMask.op_Implicit(-1);

	public float DeployCheckDistance = 0.12f;

	[Header("Jab Settings")]
	public Transform JabOrigin;

	public Vector3 JabDirection = Vector3.down;

	public float JabSinkDepth = 0.05f;

	[Header("Wire/Laser Settings")]
	public List<Transform> WireOrigins = new List<Transform>();

	public List<Vector3> WireDirections = new List<Vector3> { Vector3.forward };

	public LayerMask TripwireTriggerLayerMask = LayerMask.op_Implicit(-1);

	public LayerMask WireStopLayerMask = LayerMask.op_Implicit(-1);

	[Header("Wire End")]
	public GameObject WireEndPrefab;

	private bool isPlanted = false;

	private bool isArmed = false;

	private bool hasDetonated = false;

	private float cooldown = 0f;

	private float armingTimer = 0f;

	public float ArmingDelay = 0.5f;

	private bool pendingArming = false;

	private List<LineRenderer> TripwireLines = new List<LineRenderer>();

	private List<bool> hasPlacedWireEnd = new List<bool>();

	private List<GameObject> spawnedWireEnds = new List<GameObject>();

	public override void Awake()
	{
		((FVRPhysicalObject)this).Awake();
	}

	public override void Start()
	{
		((FVRInteractiveObject)this).Start();
		TripwireLines.Clear();
		hasPlacedWireEnd.Clear();
		spawnedWireEnds.Clear();
		for (int i = 0; i < WireDirections.Count; i++)
		{
			LineRenderer val = null;
			if ((Object)(object)TripwireLineTemplate != (Object)null)
			{
				val = Object.Instantiate<LineRenderer>(TripwireLineTemplate, ((Component)this).transform);
				((Renderer)val).enabled = false;
				if ((Object)(object)((Renderer)val).material == (Object)null && (Object)(object)TripwireValidMat != (Object)null)
				{
					((Renderer)val).material = TripwireValidMat;
				}
			}
			TripwireLines.Add(val);
			hasPlacedWireEnd.Add(item: false);
			spawnedWireEnds.Add(null);
		}
		if ((Object)(object)DeployVisual != (Object)null)
		{
			DeployVisual.SetActive(false);
		}
	}

	public override void BeginInteraction(FVRViveHand hand)
	{
		((FVRPhysicalObject)this).BeginInteraction(hand);
		cooldown = 0f;
		((FVRPhysicalObject)this).RootRigidbody.isKinematic = false;
	}

	public override void OnCollisionEnter(Collision col)
	{
		((FVRPhysicalObject)this).OnCollisionEnter(col);
		if (cooldown > 0.5f && ((FVRInteractiveObject)this).IsHeld && (Object)(object)col.collider.attachedRigidbody == (Object)null)
		{
			((FVRInteractiveObject)this).ForceBreakInteraction();
			((FVRPhysicalObject)this).RootRigidbody.isKinematic = true;
		}
	}

	public override void FVRUpdate()
	{
		//IL_0077: 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_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: 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_0099: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: 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_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0413: Unknown result type (might be due to invalid IL or missing references)
		//IL_0418: Unknown result type (might be due to invalid IL or missing references)
		//IL_0424: Unknown result type (might be due to invalid IL or missing references)
		//IL_0429: Unknown result type (might be due to invalid IL or missing references)
		//IL_042e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0438: Unknown result type (might be due to invalid IL or missing references)
		//IL_043a: Unknown result type (might be due to invalid IL or missing references)
		//IL_045c: Unknown result type (might be due to invalid IL or missing references)
		//IL_045e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0462: 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_0452: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_046c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0495: Unknown result type (might be due to invalid IL or missing references)
		//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0501: Unknown result type (might be due to invalid IL or missing references)
		//IL_0264: Unknown result type (might be due to invalid IL or missing references)
		//IL_0254: Unknown result type (might be due to invalid IL or missing references)
		//IL_0234: Unknown result type (might be due to invalid IL or missing references)
		//IL_0269: 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_028e: Unknown result type (might be due to invalid IL or missing references)
		((FVRPhysicalObject)this).FVRUpdate();
		if (cooldown < 1f)
		{
			cooldown += Time.deltaTime;
		}
		if (!isPlanted && ((FVRInteractiveObject)this).IsHeld && (Object)(object)((FVRPhysicalObject)this).QuickbeltSlot == (Object)null)
		{
			Vector3 val = ((!Object.op_Implicit((Object)(object)JabOrigin)) ? ((Component)this).transform.position : JabOrigin.position);
			Vector3 val2 = ((!Object.op_Implicit((Object)(object)JabOrigin)) ? ((Component)this).transform.TransformDirection(JabDirection) : JabOrigin.TransformDirection(JabDirection));
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(val, val2, ref val3, DeployCheckDistance, LayerMask.op_Implicit(DeployLayerMask), (QueryTriggerInteraction)1))
			{
				((Component)this).transform.position = ((RaycastHit)(ref val3)).point + ((Vector3)(ref val2)).normalized * JabSinkDepth;
				Vector3 normal = ((RaycastHit)(ref val3)).normal;
				Vector3 val4 = Vector3.ProjectOnPlane(((Component)this).transform.forward, normal);
				if (((Vector3)(ref val4)).sqrMagnitude < 0.01f)
				{
					val4 = Vector3.ProjectOnPlane(((Component)this).transform.right, normal);
				}
				((Component)this).transform.rotation = Quaternion.LookRotation(val4, normal);
				if (!isPlanted && (Object)(object)((FVRPhysicalObject)this).QuickbeltSlot == (Object)null && ((FVRInteractiveObject)this).IsHeld)
				{
					((FVRInteractiveObject)this).ForceBreakInteraction();
				}
				isPlanted = true;
				isArmed = true;
				pendingArming = false;
				armingTimer = 0f;
				base.IsPickUpLocked = true;
				if (PlantMineSound != null)
				{
					SM.PlayCoreSound((FVRPooledAudioType)0, PlantMineSound, ((Component)this).transform.position);
				}
				for (int i = 0; i < TripwireLines.Count; i++)
				{
					if ((Object)(object)TripwireLines[i] != (Object)null)
					{
						((Renderer)TripwireLines[i]).enabled = true;
						Vector3 val5 = ((WireOrigins.Count > i && (Object)(object)WireOrigins[i] != (Object)null) ? WireOrigins[i].position : ((!Object.op_Implicit((Object)(object)JabOrigin)) ? ((Component)this).transform.position : JabOrigin.position));
						TripwireLines[i].SetPosition(0, val5);
						TripwireLines[i].SetPosition(1, val5);
						if ((Object)(object)((Renderer)TripwireLines[i]).material == (Object)null && (Object)(object)TripwireValidMat != (Object)null)
						{
							((Renderer)TripwireLines[i]).material = TripwireValidMat;
						}
					}
				}
				if ((Object)(object)DeployVisual != (Object)null)
				{
					DeployVisual.SetActive(true);
				}
				if (((FVRInteractiveObject)this).IsHeld)
				{
					((FVRInteractiveObject)this).ForceBreakInteraction();
				}
				((FVRPhysicalObject)this).RootRigidbody.isKinematic = true;
			}
		}
		if (isPlanted && pendingArming && !isArmed)
		{
			armingTimer += Time.deltaTime;
			if (armingTimer >= ArmingDelay)
			{
				isArmed = true;
				pendingArming = false;
			}
		}
		if (!isPlanted || !isArmed || hasDetonated)
		{
			return;
		}
		RaycastHit val8 = default(RaycastHit);
		for (int j = 0; j < WireDirections.Count; j++)
		{
			Transform val6 = ((WireOrigins.Count > j && (Object)(object)WireOrigins[j] != (Object)null) ? WireOrigins[j] : ((!Object.op_Implicit((Object)(object)JabOrigin)) ? ((Component)this).transform : JabOrigin));
			Vector3 position = val6.position;
			Vector3 val7 = val6.TransformDirection(WireDirections[j]);
			float tripwireMaxRange = TripwireMaxRange;
			bool flag = Physics.Raycast(position, val7, ref val8, tripwireMaxRange, -1, (QueryTriggerInteraction)2);
			Vector3 val9 = ((!flag) ? (position + val7 * tripwireMaxRange) : ((RaycastHit)(ref val8)).point);
			if ((Object)(object)TripwireLines[j] != (Object)null)
			{
				TripwireLines[j].SetPosition(0, position);
				TripwireLines[j].SetPosition(1, val9);
			}
			if (!flag && !hasPlacedWireEnd[j] && (Object)(object)WireEndPrefab != (Object)null)
			{
				hasPlacedWireEnd[j] = true;
				spawnedWireEnds[j] = Object.Instantiate<GameObject>(WireEndPrefab, val9, ((Component)this).transform.rotation);
			}
			if (flag && (Object)(object)((RaycastHit)(ref val8)).collider.attachedRigidbody != (Object)null &