using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
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 AdvanceLaserSightComponent : LaserLightAttachment
{
public Transform KnobMesh;
public Vector3 RotationAxis = Vector3.up;
public List<float> CustomRotationAngles;
public GameObject ControlledGameObject;
public bool[] GameObjectEnableFlags;
public AudioEvent SettingSwapSound;
private int previousSettingsIndex = -1;
private void Start()
{
UpdateKnobRotationAndGameObject();
}
private void Update()
{
UpdateKnobRotationAndGameObject();
}
private void UpdateKnobRotationAndGameObject()
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)KnobMesh != (Object)null && base.Settings.Count > 0 && CustomRotationAngles.Count == base.Settings.Count && GameObjectEnableFlags.Length == base.Settings.Count)
{
float num = CustomRotationAngles[base.SettingsIndex];
KnobMesh.localEulerAngles = RotationAxis * num;
UpdateControlledGameObject(base.SettingsIndex);
if (base.SettingsIndex != previousSettingsIndex)
{
PlaySettingSwapSound();
previousSettingsIndex = base.SettingsIndex;
}
}
}
private void UpdateControlledGameObject(int settingIndex)
{
if ((Object)(object)ControlledGameObject != (Object)null)
{
ControlledGameObject.SetActive(GameObjectEnableFlags[settingIndex]);
}
}
private void PlaySettingSwapSound()
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
if (SettingSwapSound != null && SettingSwapSound.Clips.Count > 0)
{
AudioClip val = SettingSwapSound.Clips[Random.Range(0, SettingSwapSound.Clips.Count)];
AudioSource.PlayClipAtPoint(val, ((Component)this).transform.position, Random.Range(SettingSwapSound.VolumeRange.x, SettingSwapSound.VolumeRange.y));
}
}
}
public class DiceFaceDetector : MonoBehaviour
{
public ParticleSystem effect;
public Transform faceOneMarker;
public float checkThreshold = 0.9f;
public float cooldownTime = 2f;
private float lastTriggerTime = 0f;
private void Update()
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)faceOneMarker == (Object)null) && !(Time.time - lastTriggerTime < cooldownTime) && Vector3.Dot(faceOneMarker.up, Vector3.up) > checkThreshold)
{
TriggerEffect();
}
}
private void TriggerEffect()
{
if ((Object)(object)effect != (Object)null)
{
effect.Play();
lastTriggerTime = Time.time;
}
}
}
public class QBScaler : MonoBehaviour
{
public FVRQuickBeltSlot slot;
public float scaleMultiplier = 0.5f;
private Transform currentObj;
private Vector3 originalScale;
private Rigidbody[] secondaryRigidbodies;
private bool[] originalKinematicStates;
private Vector3[] originalLocalOffsets;
private void Update()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: 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_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_0228: Unknown result type (might be due to invalid IL or missing references)
//IL_022d: Unknown result type (might be due to invalid IL or missing references)
//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
//IL_0191: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)slot == (Object)null || (Object)(object)slot.CurObject == (Object)null)
{
if ((Object)(object)currentObj != (Object)null)
{
currentObj.localScale = originalScale;
RestoreRigidbodies();
currentObj = null;
}
return;
}
if ((Object)(object)currentObj != (Object)(object)((Component)slot.CurObject).transform)
{
if ((Object)(object)currentObj != (Object)null)
{
currentObj.localScale = originalScale;
RestoreRigidbodies();
}
currentObj = ((Component)slot.CurObject).transform;
originalScale = currentObj.localScale;
Rigidbody component = ((Component)currentObj).GetComponent<Rigidbody>();
Rigidbody[] componentsInChildren = ((Component)currentObj).GetComponentsInChildren<Rigidbody>(true);
int num = 0;
for (int i = 0; i < componentsInChildren.Length; i++)
{
if ((Object)(object)componentsInChildren[i] != (Object)(object)component)
{
num++;
}
}
secondaryRigidbodies = (Rigidbody[])(object)new Rigidbody[num];
originalKinematicStates = new bool[num];
originalLocalOffsets = (Vector3[])(object)new Vector3[num];
int num2 = 0;
for (int j = 0; j < componentsInChildren.Length; j++)
{
if (!((Object)(object)componentsInChildren[j] == (Object)(object)component))
{
secondaryRigidbodies[num2] = componentsInChildren[j];
originalKinematicStates[num2] = componentsInChildren[j].isKinematic;
ref Vector3 reference = ref originalLocalOffsets[num2];
reference = currentObj.InverseTransformPoint(((Component)componentsInChildren[j]).transform.position);
componentsInChildren[j].isKinematic = true;
num2++;
}
}
currentObj.localScale = originalScale * scaleMultiplier;
}
if (secondaryRigidbodies == null)
{
return;
}
for (int k = 0; k < secondaryRigidbodies.Length; k++)
{
if ((Object)(object)secondaryRigidbodies[k] != (Object)null)
{
((Component)secondaryRigidbodies[k]).transform.position = currentObj.TransformPoint(originalLocalOffsets[k]);
}
}
}
private void RestoreRigidbodies()
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
if (secondaryRigidbodies == null)
{
return;
}
for (int i = 0; i < secondaryRigidbodies.Length; i++)
{
if ((Object)(object)secondaryRigidbodies[i] != (Object)null)
{
((Component)secondaryRigidbodies[i]).transform.position = currentObj.TransformPoint(originalLocalOffsets[i]);
secondaryRigidbodies[i].isKinematic = originalKinematicStates[i];
}
}
secondaryRigidbodies = null;
originalKinematicStates = null;
originalLocalOffsets = null;
}
}
public class OpenBoltAltHandle : FVRInteractiveObject
{
public enum HandleRot
{
Down,
Mid,
Up
}
public enum HandleState
{
Forward,
Mid,
Rear
}
[Header("References")]
public OpenBoltReceiver Receiver;
public OpenBoltReceiverBolt Bolt;
[Header("Linear Travel")]
public Transform Point_Fore;
public Transform Point_Rear;
public float ForwardSpeed = 1.5f;
[Header("Rotation / Tilt")]
public Transform BoltHandleRoot;
public Transform BoltHandle;
public float MinRot = 0f;
public float MaxRot = 90f;
public float UnlockThreshold = 65f;
public float LockThreshold = 5f;
public float RotateSnapSpeed = 270f;
public HandleRot CurRot = HandleRot.Down;
public HandleRot LastRot = HandleRot.Down;
public HandleState CurState = HandleState.Forward;
public HandleState LastState = HandleState.Forward;
private float m_boltZ_forward;
private float m_boltZ_rear;
private float m_currentHandleZ;
private float m_rotAngle;
private bool m_hasReleasedBolt;
protected void Awake()
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
((FVRInteractiveObject)this).Awake();
m_boltZ_forward = Point_Fore.localPosition.z;
m_boltZ_rear = Point_Rear.localPosition.z;
m_currentHandleZ = BoltHandleRoot.localPosition.z;
m_rotAngle = MinRot;
m_hasReleasedBolt = true;
}
public override void UpdateInteraction(FVRViveHand hand)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
((FVRInteractiveObject)this).UpdateInteraction(hand);
UpdateRotationFromHand(hand);
if (CurRot == HandleRot.Up || CurState != HandleState.Forward)
{
Vector3 closestValidPoint = ((FVRInteractiveObject)this).GetClosestValidPoint(Point_Fore.position, Point_Rear.position, ((HandInput)(ref hand.Input)).Pos);
BoltHandleRoot.position = closestValidPoint;
m_currentHandleZ = BoltHandleRoot.localPosition.z;
}
UpdateHandleState();
UpdateRotState();
if (CurState != HandleState.Forward)
{
float num = Mathf.InverseLerp(m_boltZ_forward, m_boltZ_rear, m_currentHandleZ);
Bolt.ChargingHandleHeld(num);
}
else if (CurRot != HandleRot.Down)
{
Bolt.ChargingHandleHeld(0f);
}
if (CurState == HandleState.Forward && CurRot == HandleRot.Down)
{
if (!m_hasReleasedBolt)
{
Bolt.ChargingHandleReleased();
m_hasReleasedBolt = true;
}
}
else
{
m_hasReleasedBolt = false;
}
HandleRotAudioEvents();
HandleStateAudioEvents();
LastRot = CurRot;
LastState = CurState;
}
public override void EndInteraction(FVRViveHand hand)
{
((FVRInteractiveObject)this).EndInteraction(hand);
}
protected void FVRUpdate()
{
//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_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_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
((FVRInteractiveObject)this).FVRUpdate();
if (((FVRInteractiveObject)this).IsHeld)
{
return;
}
if (Mathf.Abs(m_currentHandleZ - m_boltZ_forward) > 0.001f)
{
m_currentHandleZ = Mathf.MoveTowards(m_currentHandleZ, m_boltZ_forward, Time.deltaTime * ForwardSpeed);
BoltHandleRoot.localPosition = new Vector3(BoltHandleRoot.localPosition.x, BoltHandleRoot.localPosition.y, m_currentHandleZ);
if (CurState != HandleState.Forward)
{
float num = Mathf.InverseLerp(m_boltZ_forward, m_boltZ_rear, m_currentHandleZ);
Bolt.ChargingHandleHeld(num);
}
}
if ((CurState == HandleState.Forward || CurState == HandleState.Mid) && m_rotAngle > MinRot + 0.5f)
{
m_rotAngle = Mathf.MoveTowards(m_rotAngle, MinRot, Time.deltaTime * RotateSnapSpeed);
BoltHandle.localEulerAngles = new Vector3(0f, 0f, m_rotAngle);
}
UpdateHandleState();
UpdateRotState();
if (CurState == HandleState.Forward && CurRot == HandleRot.Down && !m_hasReleasedBolt)
{
Bolt.ChargingHandleReleased();
m_hasReleasedBolt = true;
}
HandleStateAudioEvents();
HandleRotAudioEvents();
LastRot = CurRot;
LastState = CurState;
}
private void UpdateRotationFromHand(FVRViveHand hand)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: 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_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = ((HandInput)(ref hand.Input)).Pos - BoltHandle.position;
Vector3 val2 = Vector3.ProjectOnPlane(val, BoltHandleRoot.forward);
val = ((Vector3)(ref val2)).normalized;
Vector3 right = BoltHandleRoot.right;
float num = Mathf.Atan2(Vector3.Dot(BoltHandleRoot.forward, Vector3.Cross(right, val)), Vector3.Dot(right, val)) * 57.29578f;
m_rotAngle = Mathf.Clamp(num, MinRot, MaxRot);
BoltHandle.localEulerAngles = new Vector3(0f, 0f, m_rotAngle);
}
private void UpdateRotState()
{
if (m_rotAngle >= UnlockThreshold)
{
CurRot = HandleRot.Up;
}
else if (m_rotAngle <= MinRot + LockThreshold)
{
CurRot = HandleRot.Down;
}
else
{
CurRot = HandleRot.Mid;
}
}
private void UpdateHandleState()
{
if (Mathf.Abs(m_currentHandleZ - m_boltZ_forward) < 0.005f)
{
CurState = HandleState.Forward;
}
else if (Mathf.Abs(m_currentHandleZ - m_boltZ_rear) < 0.005f)
{
CurState = HandleState.Rear;
}
else
{
CurState = HandleState.Mid;
}
}
private void HandleRotAudioEvents()
{
if (!((Object)(object)Receiver == (Object)null))
{
if (CurRot == HandleRot.Up && LastRot != HandleRot.Up)
{
((FVRFireArm)Receiver).PlayAudioEvent((FirearmAudioEventType)12, 1f);
}
else if (CurRot == HandleRot.Down && LastRot != HandleRot.Down)
{
((FVRFireArm)Receiver).PlayAudioEvent((FirearmAudioEventType)13, 1f);
}
}
}
private void HandleStateAudioEvents()
{
if (!((Object)(object)Receiver == (Object)null))
{
if (CurState == HandleState.Rear && LastState != HandleState.Rear)
{
((FVRFireArm)Receiver).PlayAudioEvent((FirearmAudioEventType)10, 1f);
}
else if (CurState == HandleState.Forward && LastState != HandleState.Forward)
{
((FVRFireArm)Receiver).PlayAudioEvent((FirearmAudioEventType)11, 1f);
}
}
}
}
[RequireComponent(typeof(Collider))]
public class GasRegulator : FVRInteractiveObject
{
private enum BoltType
{
None,
Open,
Closed
}
[Serializable]
public class RegulatorSetting
{
public string SettingName;
[Header("Visual")]
public float SelectorPosition;
[Header("Bolt Params")]
public float ForwardSpeed;
public float RearwardSpeed;
public float SpringStiffness;
}
[Header("Firearm Reference")]
public FVRFireArm Firearm;
public GameObject BoltObject;
[Header("Regulator Settings")]
public RegulatorSetting[] Settings;
private int _index = 0;
[Header("Visual")]
public Transform RegulatorGeo;
public Axis Axis;
public InterpStyle InterpStyle;
[Header("Audio")]
public AudioEvent AudEvent_Switch;
[Header("UI")]
public GameObject TextRoot;
public Text TextField;
public float TextDisplayDuration = 2f;
private BoltType _boltType = BoltType.None;
private OpenBoltReceiverBolt _openBolt;
private ClosedBolt _closedBolt;
private bool _textVisible = false;
private float _textTimer = 0f;
public override void Awake()
{
((FVRInteractiveObject)this).Awake();
if ((Object)(object)BoltObject != (Object)null)
{
_openBolt = BoltObject.GetComponent<OpenBoltReceiverBolt>();
_closedBolt = BoltObject.GetComponent<ClosedBolt>();
if ((Object)(object)_openBolt != (Object)null)
{
_boltType = BoltType.Open;
}
else if ((Object)(object)_closedBolt != (Object)null)
{
_boltType = BoltType.Closed;
}
else
{
Debug.LogWarning((object)"[GasRegulator] BoltObject has no OpenBoltReceiverBolt or ClosedBolt component.", (Object)(object)this);
}
}
else
{
Debug.LogWarning((object)"[GasRegulator] No BoltObject assigned.", (Object)(object)this);
}
if ((Object)(object)TextRoot != (Object)null)
{
TextRoot.SetActive(false);
}
if (Settings != null && Settings.Length > 0)
{
ApplySetting(0);
}
}
public override void FVRUpdate()
{
((FVRInteractiveObject)this).FVRUpdate();
if (!_textVisible)
{
return;
}
_textTimer -= Time.deltaTime;
if (_textTimer <= 0f)
{
_textVisible = false;
if ((Object)(object)TextRoot != (Object)null)
{
TextRoot.SetActive(false);
}
}
}
public override void SimpleInteraction(FVRViveHand hand)
{
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
((FVRInteractiveObject)this).SimpleInteraction(hand);
if (Settings != null && Settings.Length != 0)
{
_index++;
if (_index >= Settings.Length)
{
_index = 0;
}
ApplySetting(_index);
if ((Object)(object)Firearm != (Object)null)
{
Firearm.PlayAudioAsHandling(AudEvent_Switch, ((Component)this).transform.position);
}
ShowText(Settings[_index].SettingName);
}
}
private void ApplySetting(int i)
{
//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)
RegulatorSetting regulatorSetting = Settings[i];
if ((Object)(object)RegulatorGeo != (Object)null && (Object)(object)Firearm != (Object)null)
{
((FVRPhysicalObject)Firearm).SetAnimatedComponent(RegulatorGeo, regulatorSetting.SelectorPosition, InterpStyle, Axis);
}
switch (_boltType)
{
case BoltType.Open:
_openBolt.BoltSpeed_Forward = regulatorSetting.ForwardSpeed;
_openBolt.BoltSpeed_Rearward = regulatorSetting.RearwardSpeed;
_openBolt.BoltSpringStiffness = regulatorSetting.SpringStiffness;
break;
case BoltType.Closed:
_closedBolt.Speed_Forward = regulatorSetting.ForwardSpeed;
_closedBolt.Speed_Rearward = regulatorSetting.RearwardSpeed;
_closedBolt.SpringStiffness = regulatorSetting.SpringStiffness;
break;
}
}
private void ShowText(string settingName)
{
if (!((Object)(object)TextRoot == (Object)null))
{
if ((Object)(object)TextField != (Object)null)
{
TextField.text = settingName;
}
TextRoot.SetActive(true);
_textVisible = true;
_textTimer = TextDisplayDuration;
}
}
}
namespace Volks.MG30_LMG;
[BepInPlugin("Volks.MG30_LMG", "MG30_LMG", "1.0.0")]
[BepInProcess("h3vr.exe")]
[Description("Built with MeatKit")]
[BepInDependency("h3vr.otherloader", "1.3.0")]
public class MG30_LMGPlugin : 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.MG30_LMG");
OtherLoader.RegisterDirectLoad(BasePath, "Volks.MG30_LMG", "", "", "mg30_lmg", "");
}
}
public class AdvanceMagazineAudioProfile : MonoBehaviour
{
[Header("References")]
[Tooltip("Auto-populated from this GameObject if left empty.")]
public FVRFireArmMagazine Magazine;
[Header("Audio — Empty Magazine")]
[Tooltip("Profile used for MagazineIn / MagazineOut when the magazine is empty.")]
public FVRFirearmMagazineAudioSet EmptyProfile;
private FVRFirearmMagazineAudioSet _originalProfileOverride;
private bool _originalUsesOverrideInOut;
private bool _wasEmpty;
private void Start()
{
if ((Object)(object)Magazine == (Object)null)
{
Magazine = ((Component)this).GetComponent<FVRFireArmMagazine>();
}
if ((Object)(object)Magazine == (Object)null)
{
Debug.LogWarning((object)"[AdvanceMagazineAudioProfile] No FVRFireArmMagazine found on this GameObject.", (Object)(object)this);
((Behaviour)this).enabled = false;
return;
}
_originalProfileOverride = Magazine.ProfileOverride;
_originalUsesOverrideInOut = Magazine.UsesOverrideInOut;
_wasEmpty = !Magazine.HasARound();
ApplyProfile(_wasEmpty);
}
private void Update()
{
if (!((Object)(object)Magazine == (Object)null))
{
bool flag = !Magazine.HasARound();
if (flag != _wasEmpty)
{
_wasEmpty = flag;
ApplyProfile(flag);
}
}
}
private void ApplyProfile(bool isEmpty)
{
if (isEmpty && (Object)(object)EmptyProfile != (Object)null)
{
Magazine.UsesOverrideInOut = true;
Magazine.ProfileOverride = EmptyProfile;
}
else
{
Magazine.UsesOverrideInOut = _originalUsesOverrideInOut;
Magazine.ProfileOverride = _originalProfileOverride;
}
}
}
public class BoltReleaseChargingHandle : MonoBehaviour
{
public ClosedBoltWeapon Weapon;
public ClosedBoltHandle Handle;
public float LaunchSpeed = 5f;
[Tooltip("If true, the handle stays at Rear until bolt release is pressed again. If false, it returns forward when pulled back manually.")]
public bool HandleReturnsManually = false;
private bool m_wasLocked;
private void Start()
{
if ((Object)(object)Weapon == (Object)null || (Object)(object)Handle == (Object)null)
{
Debug.LogWarning((object)"[BoltReleaseChargingHandle] Weapon or Handle reference is missing.", (Object)(object)this);
((Behaviour)this).enabled = false;
}
else
{
m_wasLocked = Weapon.Bolt.IsBoltLocked();
}
}
private void Update()
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Invalid comparison between Unknown and I4
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Invalid comparison between Unknown and I4
bool flag = Weapon.Bolt.IsBoltLocked();
if (m_wasLocked && !flag && Weapon.HasBoltReleaseButton && (int)Handle.CurPos == 4)
{
Handle.Speed_Forward = LaunchSpeed;
}
if ((int)Handle.CurPos == 0 && Handle.Speed_Forward > 0f)
{
Handle.Speed_Forward = 0f;
}
if (!HandleReturnsManually && !flag && !((FVRInteractiveObject)Handle).IsHeld && (int)Handle.CurPos == 4 && Handle.Speed_Forward == 0f)
{
Handle.Speed_Forward = LaunchSpeed;
}
m_wasLocked = flag;
}
}
public class PartRecoilImpulse : MonoBehaviour
{
public enum ImpulseMode
{
Rotation,
Translation
}
public enum ImpulseAxis
{
X,
Y,
Z
}
[Serializable]
public class RecoilPart
{
public Transform Piece;
public ImpulseMode Mode = ImpulseMode.Rotation;
public ImpulseAxis Axis = ImpulseAxis.X;
public Vector2 Range = new Vector2(0f, 45f);
public float ReturnSpeed = 5f;
public float ImpulseStrength = 1f;
[NonSerialized]
public float CurrentLerp = 0f;
}
[Header("Parts")]
public List<RecoilPart> Parts = new List<RecoilPart>();
private FVRFireArm m_firearm;
private void Awake()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
GM.CurrentSceneSettings.ShotFiredEvent += new ShotFired(OnShotFired);
}
private void OnDestroy()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
if ((Object)(object)GM.CurrentSceneSettings != (Object)null)
{
GM.CurrentSceneSettings.ShotFiredEvent -= new ShotFired(OnShotFired);
}
}
private void Start()
{
m_firearm = ((Component)this).GetComponentInParent<FVRFireArm>();
if ((Object)(object)m_firearm == (Object)null)
{
Debug.LogWarning((object)"[PartRecoilImpulse] No FVRFireArm found in parent hierarchy.", (Object)(object)this);
}
for (int i = 0; i < Parts.Count; i++)
{
ApplyToPart(Parts[i]);
}
}
private void OnShotFired(FVRFireArm firearm)
{
if (!((Object)(object)firearm != (Object)(object)m_firearm))
{
for (int i = 0; i < Parts.Count; i++)
{
Parts[i].CurrentLerp = Mathf.Clamp01(Parts[i].ImpulseStrength);
ApplyToPart(Parts[i]);
}
}
}
private void Update()
{
for (int i = 0; i < Parts.Count; i++)
{
RecoilPart recoilPart = Parts[i];
if (recoilPart.CurrentLerp > 0f)
{
recoilPart.CurrentLerp = Mathf.MoveTowards(recoilPart.CurrentLerp, 0f, Time.deltaTime * recoilPart.ReturnSpeed);
ApplyToPart(recoilPart);
}
}
}
private void ApplyToPart(RecoilPart part)
{
//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_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_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)part.Piece == (Object)null)
{
return;
}
float num = Mathf.Lerp(part.Range.x, part.Range.y, part.CurrentLerp);
if (part.Mode == ImpulseMode.Rotation)
{
Vector3 localEulerAngles = part.Piece.localEulerAngles;
if (part.Axis == ImpulseAxis.X)
{
localEulerAngles.x = num;
}
else if (part.Axis == ImpulseAxis.Y)
{
localEulerAngles.y = num;
}
else
{
localEulerAngles.z = num;
}
part.Piece.localEulerAngles = localEulerAngles;
}
else
{
Vector3 localPosition = part.Piece.localPosition;
if (part.Axis == ImpulseAxis.X)
{
localPosition.x = num;
}
else if (part.Axis == ImpulseAxis.Y)
{
localPosition.y = num;
}
else
{
localPosition.z = num;
}
part.Piece.localPosition = localPosition;
}
}
}
public class RPMCalculator : MonoBehaviour
{
[Header("Assign only one bugee here")]
public ClosedBolt ClosedBolt;
public OpenBoltReceiverBolt OpenBolt;
public HandgunSlide HandgunSlide;
[Header("Simulation Settings (Don't touch this bugee unless you know how physics in Unity works)")]
public float SimStepSize = 0.0005f;
public int MaxSimSteps = 100000;
[Header("Forward Calculator - Results")]
public float Result_RPM;
public float Result_CycleTimeMS;
public float Result_RearwardTimeMS;
public float Result_ForwardTimeMS;
[Header("Reverse Calculator - Inputs")]
[Tooltip("The RPM you want the weapon to fire at.")]
public float Reverse_DesiredRPM = 600f;
[Tooltip("What percentage of the cycle the bolt spends travelling rearward. Remainder is the forward (spring) stroke. Typical range: 20 to 50.")]
[Range(1f, 99f)]
public float Reverse_RearwardSplitPercent = 35f;
[Tooltip("The maximum forward speed the spring drives the bolt toward. Pin this to a value that feels right for the weapon, the script will solve SpringStiffness to match.")]
public float Reverse_DesiredSpeedForward = 10f;
[Header("Reverse Calculator - Results")]
public float Reverse_Result_SpeedForward;
public float Reverse_Result_SpeedRearward;
public float Reverse_Result_SpringStiffness;
private float m_zForward;
private float m_zRear;
private float m_speedRearward;
private float m_speedForward;
private float m_springStiffness;
[ContextMenu("Calculate RPM")]
public void Calculate()
{
if (TryReadFields() && ValidateFields() && SimulateRearward(m_speedRearward, out var rearwardTime) && SimulateForward(m_speedForward, m_springStiffness, out var forwardTime))
{
float num = rearwardTime + forwardTime;
Result_RearwardTimeMS = rearwardTime * 1000f;
Result_ForwardTimeMS = forwardTime * 1000f;
Result_CycleTimeMS = num * 1000f;
Result_RPM = 60f / num;
Debug.Log((object)("[RPMCalculator] RPM: " + Result_RPM.ToString("F0") + " | Cycle: " + Result_CycleTimeMS.ToString("F2") + "ms | Rearward: " + Result_RearwardTimeMS.ToString("F2") + "ms | Forward: " + Result_ForwardTimeMS.ToString("F2") + "ms"));
}
}
[ContextMenu("Reverse Calculate this evil bugee ")]
public void ReverseCalculate()
{
if (!TryReadFields())
{
return;
}
if (Reverse_DesiredRPM <= 0f)
{
Debug.LogError((object)"[RPMCalculator] Reverse_DesiredRPM must be greater than 0.");
return;
}
if (Reverse_DesiredSpeedForward <= 0f)
{
Debug.LogError((object)"[RPMCalculator] Reverse_DesiredSpeedForward must be greater than 0.");
return;
}
if (Mathf.Approximately(m_zForward, m_zRear))
{
Debug.LogError((object)"[RPMCalculator] Forward and Rear positions are the same. No travel distance to simulate.");
return;
}
float num = 60f / Reverse_DesiredRPM;
float num2 = num * (Reverse_RearwardSplitPercent / 100f);
float targetForwardTime = num * (1f - Reverse_RearwardSplitPercent / 100f);
float num3 = Mathf.Abs(m_zForward - m_zRear);
float reverse_Result_SpeedRearward = 0f - num3 / num2;
if (!SolveSpringStiffness(targetForwardTime, Reverse_DesiredSpeedForward, out var result))
{
Debug.LogError((object)"[RPMCalculator] Could not solve SpringStiffness. Try increasing Reverse_DesiredSpeedForward or lowering Reverse_DesiredRPM \ufffd the bolt may not be physically able to cross the travel distance in the time available.");
return;
}
Reverse_Result_SpeedRearward = reverse_Result_SpeedRearward;
Reverse_Result_SpeedForward = Reverse_DesiredSpeedForward;
Reverse_Result_SpringStiffness = result;
Debug.Log((object)("[RPMCalculator] Reverse Result for " + Reverse_DesiredRPM.ToString("F0") + " RPM: | Speed_Rearward: " + reverse_Result_SpeedRearward.ToString("F4") + " | Speed_Forward: " + Reverse_DesiredSpeedForward.ToString("F4") + " | SpringStiffness: " + result.ToString("F4")));
}
private bool SolveSpringStiffness(float targetForwardTime, float speedForward, out float result)
{
result = 0f;
float num = Mathf.Abs(m_zForward - m_zRear) / speedForward;
if (targetForwardTime < num)
{
return false;
}
float num2 = 0.001f;
float num3 = 10000f;
for (int i = 0; i < 64; i++)
{
float num4 = (num2 + num3) * 0.5f;
SimulateForward(speedForward, num4, out var forwardTime);
if (forwardTime > targetForwardTime)
{
num2 = num4;
}
else
{
num3 = num4;
}
}
result = (num2 + num3) * 0.5f;
return true;
}
private bool SimulateRearward(float speedRearward, out float rearwardTime)
{
rearwardTime = 0f;
float num = m_zForward;
int num2 = 0;
while (num > m_zRear && num2 < MaxSimSteps)
{
num += speedRearward * SimStepSize;
num = Mathf.Max(num, m_zRear);
rearwardTime += SimStepSize;
num2++;
}
if (num2 >= MaxSimSteps)
{
Debug.LogError((object)"[RPMCalculator] Hit max steps on rearward stroke.");
return false;
}
return true;
}
private bool SimulateForward(float speedForward, float springStiffness, out float forwardTime)
{
forwardTime = 0f;
float num = m_zRear;
float num2 = 0f;
int num3 = 0;
while (num < m_zForward && num3 < MaxSimSteps)
{
num2 = Mathf.MoveTowards(num2, speedForward, SimStepSize * springStiffness);
num += num2 * SimStepSize;
num = Mathf.Min(num, m_zForward);
forwardTime += SimStepSize;
num3++;
}
if (num3 >= MaxSimSteps)
{
forwardTime = float.MaxValue;
return false;
}
return true;
}
private bool TryReadFields()
{
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_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)
//IL_024a: Unknown result type (might be due to invalid IL or missing references)
//IL_024f: Unknown result type (might be due to invalid IL or missing references)
//IL_0269: Unknown result type (might be due to invalid IL or missing references)
//IL_026e: Unknown result type (might be due to invalid IL or missing references)
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_0199: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
int num = 0;
if ((Object)(object)ClosedBolt != (Object)null)
{
num++;
}
if ((Object)(object)OpenBolt != (Object)null)
{
num++;
}
if ((Object)(object)HandgunSlide != (Object)null)
{
num++;
}
if (num == 0)
{
Debug.LogError((object)"[RPMCalculator] No component assigned.");
return false;
}
if (num > 1)
{
Debug.LogError((object)"[RPMCalculator] More than one component assigned. Only assign one at a time.");
return false;
}
if ((Object)(object)ClosedBolt != (Object)null)
{
if ((Object)(object)ClosedBolt.Point_Bolt_Forward == (Object)null || (Object)(object)ClosedBolt.Point_Bolt_Rear == (Object)null)
{
Debug.LogError((object)"[RPMCalculator] ClosedBolt is missing Point_Bolt_Forward or Point_Bolt_Rear.");
return false;
}
m_zForward = ClosedBolt.Point_Bolt_Forward.localPosition.z;
m_zRear = ClosedBolt.Point_Bolt_Rear.localPosition.z;
m_speedRearward = ClosedBolt.Speed_Rearward;
m_speedForward = ClosedBolt.Speed_Forward;
m_springStiffness = ClosedBolt.SpringStiffness;
}
else if ((Object)(object)OpenBolt != (Object)null)
{
if ((Object)(object)OpenBolt.Point_Bolt_Forward == (Object)null || (Object)(object)OpenBolt.Point_Bolt_Rear == (Object)null)
{
Debug.LogError((object)"[RPMCalculator] OpenBoltReceiverBolt is missing Point_Bolt_Forward or Point_Bolt_Rear.");
return false;
}
m_zForward = OpenBolt.Point_Bolt_Forward.localPosition.z;
m_zRear = OpenBolt.Point_Bolt_Rear.localPosition.z;
m_speedRearward = OpenBolt.BoltSpeed_Rearward;
m_speedForward = OpenBolt.BoltSpeed_Forward;
m_springStiffness = OpenBolt.BoltSpringStiffness;
}
else
{
if ((Object)(object)HandgunSlide.Point_Slide_Forward == (Object)null || (Object)(object)HandgunSlide.Point_Slide_Rear == (Object)null)
{
Debug.LogError((object)"[RPMCalculator] HandgunSlide is missing Point_Slide_Forward or Point_Slide_Rear.");
return false;
}
m_zForward = HandgunSlide.Point_Slide_Forward.localPosition.z;
m_zRear = HandgunSlide.Point_Slide_Rear.localPosition.z;
m_speedRearward = HandgunSlide.Speed_Rearward;
m_speedForward = HandgunSlide.Speed_Forward;
m_springStiffness = HandgunSlide.SpringStiffness;
}
return true;
}
private bool ValidateFields()
{
if (Mathf.Approximately(m_zForward, m_zRear))
{
Debug.LogError((object)"[RPMCalculator] Forward and Rear positions are the same.");
return false;
}
if (m_speedRearward >= 0f)
{
Debug.LogError((object)("[RPMCalculator] Rearward speed should be negative. Current value: " + m_speedRearward));
return false;
}
if (m_speedForward <= 0f)
{
Debug.LogError((object)("[RPMCalculator] Forward speed must be greater than 0. Current value: " + m_speedForward));
return false;
}
if (m_springStiffness <= 0f)
{
Debug.LogError((object)("[RPMCalculator] SpringStiffness must be greater than 0. Current value: " + m_springStiffness));
return false;
}
return true;
}
}
public class SecondaryMagPos : MonoBehaviour
{
[Header("References")]
public FVRFireArm FireArm;
public FVRFireArmReloadTriggerWell TriggerWell;
[Header("Mount Override")]
public Transform MountPos;
public Transform EjectPos;
private Transform m_defaultMountPos;
private Transform m_defaultEjectPos;
private Vector3 m_defaultMountLocalPos;
private Quaternion m_defaultMountLocalRot;
private Vector3 m_defaultEjectLocalPos;
private Quaternion m_defaultEjectLocalRot;
private bool m_initialized = false;
private bool m_overrideActive = false;
private FVRFireArmMagazine m_pendingMag;
private int m_pendingStableFrames;
private const int kStableFramesRequired = 2;
private FVRFireArmMagazine m_appliedMag;
private void Start()
{
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)FireArm == (Object)null || (Object)(object)TriggerWell == (Object)null)
{
((Behaviour)this).enabled = false;
return;
}
if ((Object)(object)MountPos == (Object)null)
{
((Behaviour)this).enabled = false;
return;
}
m_defaultMountPos = FireArm.MagazineMountPos;
m_defaultEjectPos = FireArm.MagazineEjectPos;
if ((Object)(object)m_defaultMountPos == (Object)null)
{
((Behaviour)this).enabled = false;
return;
}
m_defaultMountLocalPos = m_defaultMountPos.localPosition;
m_defaultMountLocalRot = m_defaultMountPos.localRotation;
if ((Object)(object)m_defaultEjectPos != (Object)null)
{
m_defaultEjectLocalPos = m_defaultEjectPos.localPosition;
m_defaultEjectLocalRot = m_defaultEjectPos.localRotation;
}
m_initialized = true;
m_pendingMag = null;
m_pendingStableFrames = 0;
m_appliedMag = null;
}
private void Update()
{
//IL_00b1: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
if (!m_initialized)
{
return;
}
FVRFireArmMagazine magazine = FireArm.Magazine;
if ((Object)(object)magazine == (Object)(object)m_pendingMag)
{
if (m_pendingStableFrames < 2)
{
m_pendingStableFrames++;
}
}
else
{
m_pendingMag = magazine;
m_pendingStableFrames = 0;
}
if (m_pendingStableFrames < 2 || (Object)(object)m_pendingMag == (Object)(object)m_appliedMag)
{
return;
}
FireArmMagazineType val = ((!TriggerWell.UsesTypeOverride) ? FireArm.MagazineType : TriggerWell.TypeOverride);
if ((Object)(object)m_pendingMag != (Object)null && m_pendingMag.MagazineType == val)
{
m_overrideActive = true;
m_appliedMag = m_pendingMag;
return;
}
if (m_overrideActive)
{
m_overrideActive = false;
RestoreDefaults();
}
m_appliedMag = null;
}
private void LateUpdate()
{
//IL_0028: 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_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
if (m_initialized && m_overrideActive)
{
m_defaultMountPos.position = MountPos.position;
m_defaultMountPos.rotation = MountPos.rotation;
if ((Object)(object)m_defaultEjectPos != (Object)null && (Object)(object)EjectPos != (Object)null)
{
m_defaultEjectPos.position = EjectPos.position;
m_defaultEjectPos.rotation = EjectPos.rotation;
}
}
}
private void RestoreDefaults()
{
//IL_0008: 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_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
m_defaultMountPos.localPosition = m_defaultMountLocalPos;
m_defaultMountPos.localRotation = m_defaultMountLocalRot;
if ((Object)(object)m_defaultEjectPos != (Object)null)
{
m_defaultEjectPos.localPosition = m_defaultEjectLocalPos;
m_defaultEjectPos.localRotation = m_defaultEjectLocalRot;
}
}
private void OnDisable()
{
if (m_initialized)
{
RestoreDefaults();
}
}
private void OnDestroy()
{
if (m_initialized)
{
RestoreDefaults();
}
}
}
public class SimpleCompass : MonoBehaviour
{
[Header("Target")]
[Tooltip("Assign Forward Z for North Facing, I think.")]
public Transform Target;
[Header("Text Version")]
public Text CompassText;
[Header("Image Version")]
[Tooltip("The arrow that will be rotated to indicate which direction.")]
public RectTransform CompassImage;
private void Update()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)Target == (Object)null))
{
Vector3 forward = Target.forward;
forward.y = 0f;
((Vector3)(ref forward)).Normalize();
float num = Mathf.Atan2(forward.x, forward.z) * 57.29578f;
if (num < 0f)
{
num += 360f;
}
if ((Object)(object)CompassText != (Object)null)
{
CompassText.text = GetCardinalLabel(num) + " " + Mathf.RoundToInt(num) + "°";
}
if ((Object)(object)CompassImage != (Object)null)
{
((Transform)CompassImage).localEulerAngles = new Vector3(0f, 0f, num);
}
}
}
private string GetCardinalLabel(float angle)
{
if (angle < 22.5f || angle >= 337.5f)
{
return "N";
}
if (angle < 67.5f)
{
return "NE";
}
if (angle < 112.5f)
{
return "E";
}
if (angle < 157.5f)
{
return "SE";
}
if (angle < 202.5f)
{
return "S";
}
if (angle < 247.5f)
{
return "SW";
}
if (angle < 292.5f)
{
return "W";
}
return "NW";
}
}
public class InvertClosedBolt : MonoBehaviour
{
public Transform OptionalLockPointOverride;
private void Start()
{
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
ClosedBolt component = ((Component)this).GetComponent<ClosedBolt>();
if ((Object)(object)component == (Object)null)
{
Debug.LogWarning((object)"[InvertClosedBolt] No ClosedBolt component found on this GameObject.");
return;
}
Transform point_Bolt_Forward = component.Point_Bolt_Forward;
component.Point_Bolt_Forward = component.Point_Bolt_Rear;
component.Point_Bolt_Rear = point_Bolt_Forward;
if ((Object)(object)OptionalLockPointOverride != (Object)null)
{
component.Point_Bolt_LockPoint = OptionalLockPointOverride;
}
SetPrivateFloat(component, "m_boltZ_forward", LocalZ(component.Point_Bolt_Forward));
SetPrivateFloat(component, "m_boltZ_rear", LocalZ(component.Point_Bolt_Rear));
SetPrivateFloat(component, "m_boltZ_lock", LocalZ(component.Point_Bolt_LockPoint));
SetPrivateFloat(component, "m_boltZ_current", ((Component)component).transform.localPosition.z);
if (component.UsesAKSafetyLock && (Object)(object)component.Point_Bolt_SafetyLock != (Object)null)
{
SetPrivateFloat(component, "m_boltZ_safetylock", LocalZ(component.Point_Bolt_SafetyLock));
}
component.SnapToRear();
component.UpdateBolt();
}
private static float LocalZ(Transform t)
{
//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)
return (!((Object)(object)t != (Object)null)) ? 0f : t.localPosition.z;
}
private static void SetPrivateFloat(ClosedBolt cb, string name, float value)
{
typeof(ClosedBolt).GetField(name, BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(cb, value);
}
}
public class MagazineStock : MonoBehaviour
{
[Header("References")]
public FVRFireArm Weapon;
public int SecondarySlotIndex = 0;
public Transform Point_Stock;
[Header("Objects to disable when stocked")]
public GameObject[] ObjectsToDisableWhenStocked;
private bool _wasStocked;
private void Update()
{
SecondaryMagazineSlot val = Weapon.SecondaryMagazineSlots[SecondarySlotIndex];
if ((Object)(object)val.Magazine != (Object)null && (Object)(object)((FVRInteractiveObject)val.Magazine).m_hand != (Object)null)
{
Weapon.EjectSecondaryMagFromSlot(SecondarySlotIndex, true);
}
bool flag = (Object)(object)val.Magazine != (Object)null;
if (flag == _wasStocked)
{
return;
}
_wasStocked = flag;
if (flag)
{
Weapon.StockPos = Point_Stock;
Weapon.HasActiveShoulderStock = true;
}
else
{
Weapon.StockPos = null;
Weapon.HasActiveShoulderStock = false;
}
for (int i = 0; i < ObjectsToDisableWhenStocked.Length; i++)
{
if ((Object)(object)ObjectsToDisableWhenStocked[i] != (Object)null)
{
ObjectsToDisableWhenStocked[i].SetActive(!flag);
}
}
}
}
public class RifleToggleLock : MonoBehaviour
{
public ClosedBolt ClosedBolt;
public Transform BarrelSlide;
public Transform BarrelSlideForward;
public Transform BarrelSlideLockPoint;
public Transform TogglePiece1;
public Transform TogglePiece2;
public Transform TogglePiece3;
public Vector2 RotSet1 = new Vector2(0f, -86f);
public Vector2 RotSet2 = new Vector2(0f, 132.864f);
public Vector2 PosSet1 = new Vector2(0.02199817f, -0.02124f);
public float Height = 0.03527606f;
[Header("Motion Curves")]
[Tooltip("Drives BarrelSlide and TogglePiece1.")]
public AnimationCurve MotionCurve = AnimationCurve.Linear(0f, 0f, 1f, 1f);
[Tooltip("Drives TogglePiece2 independently.")]
public AnimationCurve MotionCurvePiece2 = AnimationCurve.Linear(0f, 0f, 1f, 1f);
[Tooltip("Drives TogglePiece3 independently.")]
public AnimationCurve MotionCurvePiece3 = AnimationCurve.Linear(0f, 0f, 1f, 1f);
[Header("Debug")]
public bool DebugOverride = false;
[Range(0f, 1f)]
public float DebugLerp = 0f;
private void Update()
{
//IL_005d: 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_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
float num = ((!DebugOverride) ? (1f - ClosedBolt.GetBoltLerpBetweenRearAndFore()) : DebugLerp);
float num2 = MotionCurve.Evaluate(num);
float num3 = MotionCurvePiece2.Evaluate(num);
float num4 = MotionCurvePiece3.Evaluate(num);
BarrelSlide.localPosition = Vector3.Lerp(BarrelSlideForward.localPosition, BarrelSlideLockPoint.localPosition, num2);
float num5 = Mathf.Lerp(RotSet1.x, RotSet1.y, num2);
float num6 = Mathf.Lerp(RotSet2.x, RotSet2.y, num3);
float num7 = Mathf.Lerp(PosSet1.x, PosSet1.y, num4);
TogglePiece1.localEulerAngles = new Vector3(num5, 0f, 0f);
TogglePiece2.localEulerAngles = new Vector3(num6, 0f, 0f);
TogglePiece3.localPosition = new Vector3(0f, Height, num7);
}
}
internal class AutoReleaseOnMagLoad : MonoBehaviour
{
private FVRFireArm weapon;
private Handgun handgun;
private bool wasLoaded;
public void Start()
{
weapon = ((Component)this).GetComponent<FVRFireArm>();
if (!((Object)(object)weapon == (Object)null) && weapon is Handgun)
{
ref Handgun reference = ref handgun;
FVRFireArm obj = weapon;
reference = (Handgun)(object)((obj is Handgun) ? obj : null);
}
}
public void FixedUpdate()
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Invalid comparison between Unknown and I4
if ((Object)(object)handgun != (Object)null)
{
if ((Object)(object)weapon.Magazine != (Object)null)
{
if (weapon.Magazine.HasARound())
{
if ((int)handgun.Slide.CurPos >= 2 && !wasLoaded)
{
handgun.Slide.ImpartFiringImpulse();
wasLoaded = true;
}
}
else
{
wasLoaded = false;
}
}
else
{
wasLoaded = false;
}
}
else
{
wasLoaded = false;
}
}
}
public class HandgunSlideSafety : MonoBehaviour
{
public HandgunSlide Slide;
public Handgun Handgun;
[Tooltip("Place between Point_Slide_Forward and Point_Slide_LockPoint. Controls how far back the slide can travel with no magazine.")]
public Transform Point_Slide_NoMagLimit;
private FieldInfo _slideZCurrentField;
private float _limitZ;
private bool _rearIsLess;
private bool _initialized;
private void Awake()
{
//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_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
_slideZCurrentField = typeof(HandgunSlide).GetField("m_slideZ_current", BindingFlags.Instance | BindingFlags.NonPublic);
if ((Object)(object)Slide != (Object)null && (Object)(object)Point_Slide_NoMagLimit != (Object)null)
{
_limitZ = Point_Slide_NoMagLimit.localPosition.z;
_rearIsLess = Slide.Point_Slide_Rear.localPosition.z < Slide.Point_Slide_Forward.localPosition.z;
}
_initialized = (Object)(object)Slide != (Object)null && (Object)(object)Handgun != (Object)null && (Object)(object)Point_Slide_NoMagLimit != (Object)null && (object)_slideZCurrentField != null;
}
private void LateUpdate()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
if (_initialized && !((Object)(object)((FVRFireArm)Handgun).Magazine != (Object)null))
{
Vector3 localPosition = ((Component)Slide).transform.localPosition;
if ((!_rearIsLess) ? (localPosition.z > _limitZ) : (localPosition.z < _limitZ))
{
((Component)Slide).transform.localPosition = new Vector3(localPosition.x, localPosition.y, _limitZ);
_slideZCurrentField.SetValue(Slide, _limitZ);
}
}
}
}
[RequireComponent(typeof(Collider))]
public class HandgunSlideControl : FVRInteractiveObject
{
[Serializable]
public class SlideControlSetting
{
public string SettingName;
[Header("Visual")]
public float SelectorPosition;
[Header("Slide Params")]
public float ForwardSpeed;
public float RearwardSpeed;
public float HeldSpeed;
public float SpringStiffness;
}
[Header("References")]
public Handgun Handgun;
public HandgunSlide Slide;
[Header("Settings")]
public SlideControlSetting[] Settings;
private int _index = 0;
[Header("Visual")]
public Transform ControlGeo;
public Axis Axis;
public InterpStyle InterpStyle;
[Header("Audio")]
public AudioEvent AudEvent_Switch;
[Header("UI")]
public GameObject TextRoot;
public TextMesh TextField;
public float TextDisplayDuration = 2f;
private bool _textVisible = false;
private float _textTimer = 0f;
public override void Awake()
{
((FVRInteractiveObject)this).Awake();
if ((Object)(object)Slide == (Object)null)
{
Debug.LogWarning((object)"[HandgunSlideControl] No HandgunSlide assigned.", (Object)(object)this);
}
if ((Object)(object)TextRoot != (Object)null)
{
TextRoot.SetActive(false);
}
if (Settings != null && Settings.Length > 0)
{
ApplySetting(0);
}
}
public override void FVRUpdate()
{
((FVRInteractiveObject)this).FVRUpdate();
if (!_textVisible)
{
return;
}
_textTimer -= Time.deltaTime;
if (_textTimer <= 0f)
{
_textVisible = false;
if ((Object)(object)TextRoot != (Object)null)
{
TextRoot.SetActive(false);
}
}
}
public override void SimpleInteraction(FVRViveHand hand)
{
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
((FVRInteractiveObject)this).SimpleInteraction(hand);
if (Settings != null && Settings.Length != 0)
{
_index++;
if (_index >= Settings.Length)
{
_index = 0;
}
ApplySetting(_index);
if ((Object)(object)Handgun != (Object)null)
{
((FVRFireArm)Handgun).PlayAudioAsHandling(AudEvent_Switch, ((Component)this).transform.position);
}
ShowText(Settings[_index].SettingName);
}
}
private void ApplySetting(int i)
{
//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)
SlideControlSetting slideControlSetting = Settings[i];
if ((Object)(object)ControlGeo != (Object)null && (Object)(object)Handgun != (Object)null)
{
((FVRPhysicalObject)Handgun).SetAnimatedComponent(ControlGeo, slideControlSetting.SelectorPosition, InterpStyle, Axis);
}
if (!((Object)(object)Slide == (Object)null))
{
Slide.Speed_Forward = slideControlSetting.ForwardSpeed;
Slide.Speed_Rearward = slideControlSetting.RearwardSpeed;
Slide.Speed_Held = slideControlSetting.HeldSpeed;
Slide.SpringStiffness = slideControlSetting.SpringStiffness;
}
}
private void ShowText(string settingName)
{
if (!((Object)(object)TextRoot == (Object)null))
{
if ((Object)(object)TextField != (Object)null)
{
TextField.text = settingName;
}
TextRoot.SetActive(true);
_textVisible = true;
_textTimer = TextDisplayDuration;
}
}
}
public class StreamlineDecocker : MonoBehaviour
{
public enum EStreamlineInputType
{
AXButton,
BYButton
}
public enum EInputType
{
TouchpadUp,
TouchpadDown,
TouchpadLeft,
TouchpadRight
}
[Header("Manual Handgun Decocker")]
public Handgun Handgun;
[Header("Streamlined Controls Input")]
public EStreamlineInputType StreamlineInputType;
[Header("Classic Controls Input")]
public EInputType InputType;
[Tooltip("Use this if you wanna use the safety as it is configured on the handgun itself.")]
public bool UsesHandgunSafetyObjectInstead = false;
[Header("Standalone decocker object.")]
public Transform Decocker;
public Axis DecockerAxis;
public InterpStyle DecockerInterpStyle;
public float DecockerReleased;
public float DecockerPressed;
private bool _wasDecocked = false;
public void Update()
{
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: 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_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Handgun == (Object)null)
{
return;
}
FVRViveHand hand = ((FVRInteractiveObject)Handgun).m_hand;
if ((Object)(object)hand != (Object)null && CorrectInput(hand))
{
if (!_wasDecocked)
{
Handgun.DeCockHammer(true, true);
if (!UsesHandgunSafetyObjectInstead)
{
((FVRPhysicalObject)Handgun).SetAnimatedComponent(Decocker, DecockerPressed, DecockerInterpStyle, DecockerAxis);
}
else
{
((FVRPhysicalObject)Handgun).SetAnimatedComponent(Handgun.Safety, Handgun.SafetyOn, Handgun.Safety_Interp, Handgun.SafetyAxis);
}
_wasDecocked = true;
}
}
else if (_wasDecocked)
{
if (!UsesHandgunSafetyObjectInstead)
{
((FVRPhysicalObject)Handgun).SetAnimatedComponent(Decocker, DecockerReleased, DecockerInterpStyle, DecockerAxis);
}
else
{
((FVRPhysicalObject)Handgun).SetAnimatedComponent(Handgun.Safety, Handgun.SafetyOff, Handgun.Safety_Interp, Handgun.SafetyAxis);
}
_wasDecocked = false;
}
}
private bool CorrectInput(FVRViveHand hand)
{
//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_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_0087: 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_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
if (hand.IsInStreamlinedMode)
{
return StreamlineInputType switch
{
EStreamlineInputType.AXButton => hand.Input.AXButtonPressed,
EStreamlineInputType.BYButton => hand.Input.BYButtonDown,
_ => false,
};
}
Vector2 dir;
switch (InputType)
{
case EInputType.TouchpadUp:
dir = Vector2.up;
break;
case EInputType.TouchpadDown:
dir = Vector2.down;
break;
case EInputType.TouchpadLeft:
dir = Vector2.left;
break;
case EInputType.TouchpadRight:
dir = Vector2.right;
break;
default:
return false;
}
return TouchpadDirPressed(hand, dir);
}
private bool TouchpadDirPressed(FVRViveHand hand, Vector2 dir)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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)
Vector2 touchpadAxes = hand.Input.TouchpadAxes;
if (((Vector2)(ref touchpadAxes)).magnitude <= 0.2f)
{
return false;
}
float num = Vector2.Angle(touchpadAxes, dir);
if (num > 45f)
{
return false;
}
if (hand.Input.TouchpadDown || hand.Input.TouchpadPressed)
{
return true;
}
return false;
}
}
