using System;
using System.Runtime.InteropServices;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using UnityEngine;

// Token: 0x020000A2 RID: 162
public class LockPointsManager : Il2CppSystem.Object
{
	// Token: 0x06001316 RID: 4886 RVA: 0x000529B8 File Offset: 0x00050BB8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503431, RefRangeEnd = 503432, XrefRangeStart = 503398, XrefRangeEnd = 503431, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Init()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_Init_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001317 RID: 4887 RVA: 0x000529FC File Offset: 0x00050BFC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503436, RefRangeEnd = 503437, XrefRangeStart = 503432, XrefRangeEnd = 503436, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void AddLockPoints(Il2CppReferenceArray<LockPoint> lockPointArr)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(lockPointArr);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001318 RID: 4888 RVA: 0x00052A58 File Offset: 0x00050C58
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 503437, XrefRangeEnd = 503438, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe int GetLockPointsCount()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockPointsCount_Public_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001319 RID: 4889 RVA: 0x00052AA8 File Offset: 0x00050CA8
	[CallerCount(21)]
	[CachedScanResults(RefRangeStart = 503441, RefRangeEnd = 503462, XrefRangeStart = 503438, XrefRangeEnd = 503441, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetLockPoint(int i)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref i;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
		}
	}

	// Token: 0x0600131A RID: 4890 RVA: 0x00052B10 File Offset: 0x00050D10
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503467, RefRangeEnd = 503468, XrefRangeStart = 503462, XrefRangeEnd = 503467, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetLockPoint(LockPoint lockPoint)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(lockPoint);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
		}
	}

	// Token: 0x0600131B RID: 4891 RVA: 0x00052B80 File Offset: 0x00050D80
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503482, RefRangeEnd = 503483, XrefRangeStart = 503468, XrefRangeEnd = 503482, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void LockReset()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_LockReset_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600131C RID: 4892 RVA: 0x00052BC4 File Offset: 0x00050DC4
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 503484, RefRangeEnd = 503492, XrefRangeStart = 503483, XrefRangeEnd = 503484, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe int GetLockedOnPointsCount()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockedOnPointsCount_Public_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600131D RID: 4893 RVA: 0x00052C14 File Offset: 0x00050E14
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503502, RefRangeEnd = 503503, XrefRangeStart = 503492, XrefRangeEnd = 503502, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Il2CppReferenceArray<Transform> GetLockedOnTargetArray()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockedOnTargetArray_Public_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new Il2CppReferenceArray<Transform>(intPtr3) : null;
	}

	// Token: 0x0600131E RID: 4894 RVA: 0x00052C6C File Offset: 0x00050E6C
	[CallerCount(0)]
	public unsafe void SetPerspectiveLockEnabled(bool isEnabled)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isEnabled;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockEnabled_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600131F RID: 4895 RVA: 0x00052CC0 File Offset: 0x00050EC0
	[CallerCount(0)]
	public unsafe bool GetPerspectiveLockEnabled()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockEnabled_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001320 RID: 4896 RVA: 0x00052D10 File Offset: 0x00050F10
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 11234, RefRangeEnd = 11235, XrefRangeStart = 11234, XrefRangeEnd = 11235, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetPerspectiveLockTarget()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockTarget_Public_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
	}

	// Token: 0x06001321 RID: 4897 RVA: 0x00052D68 File Offset: 0x00050F68
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503504, RefRangeEnd = 503506, XrefRangeStart = 503503, XrefRangeEnd = 503504, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ClearPerspectiveLockTarget()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_ClearPerspectiveLockTarget_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001322 RID: 4898 RVA: 0x00052DAC File Offset: 0x00050FAC
	[CallerCount(0)]
	public unsafe float GetPerspectiveLockDistance()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockDistance_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001323 RID: 4899 RVA: 0x00052DFC File Offset: 0x00050FFC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 223884, RefRangeEnd = 223885, XrefRangeStart = 223884, XrefRangeEnd = 223885, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetPerspectiveLockDistance(float lockDistance)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref lockDistance;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockDistance_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001324 RID: 4900 RVA: 0x00052E50 File Offset: 0x00051050
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503506, RefRangeEnd = 503508, XrefRangeStart = 503506, XrefRangeEnd = 503506, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DefaultPerspectiveLockDistance()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_DefaultPerspectiveLockDistance_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001325 RID: 4901 RVA: 0x00052E94 File Offset: 0x00051094
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 503526, RefRangeEnd = 503530, XrefRangeStart = 503508, XrefRangeEnd = 503526, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CancelLock()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_CancelLock_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001326 RID: 4902 RVA: 0x00052ED8 File Offset: 0x000510D8
	[CallerCount(0)]
	public unsafe void SetAimPointEnabled(bool isEnabled)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isEnabled;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetAimPointEnabled_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001327 RID: 4903 RVA: 0x00052F2C File Offset: 0x0005112C
	[CallerCount(0)]
	public unsafe bool GetAimPointEnabled()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetAimPointEnabled_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001328 RID: 4904 RVA: 0x00052F7C File Offset: 0x0005117C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503622, RefRangeEnd = 503623, XrefRangeStart = 503530, XrefRangeEnd = 503622, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateLockedOnPoint()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_UpdateLockedOnPoint_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001329 RID: 4905 RVA: 0x00052FC0 File Offset: 0x000511C0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503651, RefRangeEnd = 503653, XrefRangeStart = 503623, XrefRangeEnd = 503651, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void AutoLockNearby(Vector3 v3PlayerPos, float fDistance)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3PlayerPos;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fDistance;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_AutoLockNearby_Public_Void_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600132A RID: 4906 RVA: 0x00053028 File Offset: 0x00051228
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503662, RefRangeEnd = 503663, XrefRangeStart = 503653, XrefRangeEnd = 503662, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Transform GetClosest()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetClosest_Public_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new Transform(intPtr3) : null;
	}

	// Token: 0x0600132B RID: 4907 RVA: 0x00053080 File Offset: 0x00051280
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503704, RefRangeEnd = 503705, XrefRangeStart = 503663, XrefRangeEnd = 503704, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SwitchPerspectiveLockTarget(Vector2 direction, Vector2 rootPosition)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref direction;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootPosition;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SwitchPerspectiveLockTarget_Public_Void_Vector2_Vector2_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600132C RID: 4908 RVA: 0x000530E8 File Offset: 0x000512E8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503725, RefRangeEnd = 503726, XrefRangeStart = 503705, XrefRangeEnd = 503725, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe bool TryUpdatePerspectiveLockTarget()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_TryUpdatePerspectiveLockTarget_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600132D RID: 4909 RVA: 0x00053138 File Offset: 0x00051338
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503728, RefRangeEnd = 503730, XrefRangeStart = 503726, XrefRangeEnd = 503728, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateMagicLockMax(PlayerEffectPlay.Magic magicType)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref magicType;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_UpdateMagicLockMax_Public_Void_Magic_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600132E RID: 4910 RVA: 0x0005318C File Offset: 0x0005138C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503738, RefRangeEnd = 503739, XrefRangeStart = 503730, XrefRangeEnd = 503738, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetIceLockNumMax()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_ResetIceLockNumMax_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600132F RID: 4911 RVA: 0x000531D0 File Offset: 0x000513D0
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 503763, RefRangeEnd = 503768, XrefRangeStart = 503739, XrefRangeEnd = 503763, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe bool TryGetDistanceLockData(int index, LockPointsManager.LockSetupData lockSetupData, out LockPointsManager.LockResultData lockResultData)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lockSetupData;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &lockResultData;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_TryGetDistanceLockData_Private_Boolean_Int32_LockSetupData_byref_LockResultData_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001330 RID: 4912 RVA: 0x0005325C File Offset: 0x0005145C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503772, RefRangeEnd = 503774, XrefRangeStart = 503768, XrefRangeEnd = 503772, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void AddLockedOnPoint(LockPoint lockPoint)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(lockPoint);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_AddLockedOnPoint_Private_Void_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001331 RID: 4913 RVA: 0x000532B8 File Offset: 0x000514B8
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503778, RefRangeEnd = 503780, XrefRangeStart = 503774, XrefRangeEnd = 503778, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetLockedOnPoint(int index, LockPoint lockPoint)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(lockPoint);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_SetLockedOnPoint_Private_Void_Int32_LockPoint_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001332 RID: 4914 RVA: 0x00053324 File Offset: 0x00051524
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503800, RefRangeEnd = 503802, XrefRangeStart = 503780, XrefRangeEnd = 503800, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void RemoveLockedOnPoint(int index)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_RemoveLockedOnPoint_Private_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001333 RID: 4915 RVA: 0x00053378 File Offset: 0x00051578
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503804, RefRangeEnd = 503806, XrefRangeStart = 503802, XrefRangeEnd = 503804, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPoint GetLockedOnPoint(int index)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref index;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_GetLockedOnPoint_Private_LockPoint_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new LockPoint(intPtr3) : null;
		}
	}

	// Token: 0x06001334 RID: 4916 RVA: 0x000533E0 File Offset: 0x000515E0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 503806, XrefRangeEnd = 503810, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ClearLockedOnPoints()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_ClearLockedOnPoints_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001335 RID: 4917 RVA: 0x00053424 File Offset: 0x00051624
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 503810, XrefRangeEnd = 503822, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void RefreshLockedOnPoints()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr_RefreshLockedOnPoints_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001336 RID: 4918 RVA: 0x00053468 File Offset: 0x00051668
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503823, RefRangeEnd = 503824, XrefRangeStart = 503822, XrefRangeEnd = 503823, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LockPointsManager()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001337 RID: 4919 RVA: 0x000534B4 File Offset: 0x000516B4
	// Note: this type is marked as 'beforefieldinit'.
	static LockPointsManager()
	{
		Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "LockPointsManager");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr);
		LockPointsManager.NativeFieldInfoPtr_lockPoints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockPoints");
		LockPointsManager.NativeFieldInfoPtr_lockedOnPoints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockedOnPoints");
		LockPointsManager.NativeFieldInfoPtr_lockMask = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockMask");
		LockPointsManager.NativeFieldInfoPtr_isAimPointEnabled = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "isAimPointEnabled");
		LockPointsManager.NativeFieldInfoPtr_lockWaitDelta = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockWaitDelta");
		LockPointsManager.NativeFieldInfoPtr_lockWaitValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "lockWaitValue");
		LockPointsManager.NativeFieldInfoPtr_magicLockMax = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "magicLockMax");
		LockPointsManager.NativeFieldInfoPtr_iceLockRange = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "iceLockRange");
		LockPointsManager.NativeFieldInfoPtr_iceLockWorldRange = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "iceLockWorldRange");
		LockPointsManager.NativeFieldInfoPtr_isPerspectiveLockEnabled = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "isPerspectiveLockEnabled");
		LockPointsManager.NativeFieldInfoPtr_perspectiveLockTarget = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "perspectiveLockTarget");
		LockPointsManager.NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "PERSPECTIVE_LOCK_DISTANCE");
		LockPointsManager.NativeFieldInfoPtr_perspectiveLockDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "perspectiveLockDistance");
		LockPointsManager.NativeMethodInfoPtr_Init_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665074);
		LockPointsManager.NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665075);
		LockPointsManager.NativeMethodInfoPtr_GetLockPointsCount_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665076);
		LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665077);
		LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665078);
		LockPointsManager.NativeMethodInfoPtr_LockReset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665079);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnPointsCount_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665080);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnTargetArray_Public_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665081);
		LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665082);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockEnabled_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665083);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockTarget_Public_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665084);
		LockPointsManager.NativeMethodInfoPtr_ClearPerspectiveLockTarget_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665085);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockDistance_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665086);
		LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockDistance_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665087);
		LockPointsManager.NativeMethodInfoPtr_DefaultPerspectiveLockDistance_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665088);
		LockPointsManager.NativeMethodInfoPtr_CancelLock_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665089);
		LockPointsManager.NativeMethodInfoPtr_SetAimPointEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665090);
		LockPointsManager.NativeMethodInfoPtr_GetAimPointEnabled_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665091);
		LockPointsManager.NativeMethodInfoPtr_UpdateLockedOnPoint_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665092);
		LockPointsManager.NativeMethodInfoPtr_AutoLockNearby_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665093);
		LockPointsManager.NativeMethodInfoPtr_GetClosest_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665094);
		LockPointsManager.NativeMethodInfoPtr_SwitchPerspectiveLockTarget_Public_Void_Vector2_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665095);
		LockPointsManager.NativeMethodInfoPtr_TryUpdatePerspectiveLockTarget_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665096);
		LockPointsManager.NativeMethodInfoPtr_UpdateMagicLockMax_Public_Void_Magic_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665097);
		LockPointsManager.NativeMethodInfoPtr_ResetIceLockNumMax_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665098);
		LockPointsManager.NativeMethodInfoPtr_TryGetDistanceLockData_Private_Boolean_Int32_LockSetupData_byref_LockResultData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665099);
		LockPointsManager.NativeMethodInfoPtr_AddLockedOnPoint_Private_Void_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665100);
		LockPointsManager.NativeMethodInfoPtr_SetLockedOnPoint_Private_Void_Int32_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665101);
		LockPointsManager.NativeMethodInfoPtr_RemoveLockedOnPoint_Private_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665102);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnPoint_Private_LockPoint_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665103);
		LockPointsManager.NativeMethodInfoPtr_ClearLockedOnPoints_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665104);
		LockPointsManager.NativeMethodInfoPtr_RefreshLockedOnPoints_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665105);
		LockPointsManager.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665106);
	}

	// Token: 0x06001338 RID: 4920 RVA: 0x0000A74C File Offset: 0x0000894C
	public LockPointsManager(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x170005CE RID: 1486
	// (get) Token: 0x06001339 RID: 4921 RVA: 0x0005387C File Offset: 0x00051A7C
	// (set) Token: 0x0600133A RID: 4922 RVA: 0x000538B0 File Offset: 0x00051AB0
	public unsafe List<LockPoint> lockPoints
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockPoints);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new List<LockPoint>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockPoints), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005CF RID: 1487
	// (get) Token: 0x0600133B RID: 4923 RVA: 0x000538D8 File Offset: 0x00051AD8
	// (set) Token: 0x0600133C RID: 4924 RVA: 0x0005390C File Offset: 0x00051B0C
	public unsafe List<LockPoint> lockedOnPoints
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockedOnPoints);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new List<LockPoint>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockedOnPoints), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005D0 RID: 1488
	// (get) Token: 0x0600133D RID: 4925 RVA: 0x00053934 File Offset: 0x00051B34
	// (set) Token: 0x0600133E RID: 4926 RVA: 0x0005395C File Offset: 0x00051B5C
	public unsafe LayerMask lockMask
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockMask);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockMask)) = value;
		}
	}

	// Token: 0x170005D1 RID: 1489
	// (get) Token: 0x0600133F RID: 4927 RVA: 0x00053980 File Offset: 0x00051B80
	// (set) Token: 0x06001340 RID: 4928 RVA: 0x000539A8 File Offset: 0x00051BA8
	public unsafe bool isAimPointEnabled
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isAimPointEnabled);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isAimPointEnabled)) = value;
		}
	}

	// Token: 0x170005D2 RID: 1490
	// (get) Token: 0x06001341 RID: 4929 RVA: 0x000539CC File Offset: 0x00051BCC
	// (set) Token: 0x06001342 RID: 4930 RVA: 0x000539F4 File Offset: 0x00051BF4
	public unsafe float lockWaitDelta
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitDelta);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitDelta)) = value;
		}
	}

	// Token: 0x170005D3 RID: 1491
	// (get) Token: 0x06001343 RID: 4931 RVA: 0x00053A18 File Offset: 0x00051C18
	// (set) Token: 0x06001344 RID: 4932 RVA: 0x00053A40 File Offset: 0x00051C40
	public unsafe float lockWaitValue
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitValue);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_lockWaitValue)) = value;
		}
	}

	// Token: 0x170005D4 RID: 1492
	// (get) Token: 0x06001345 RID: 4933 RVA: 0x00053A64 File Offset: 0x00051C64
	// (set) Token: 0x06001346 RID: 4934 RVA: 0x00053A8C File Offset: 0x00051C8C
	public unsafe int magicLockMax
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_magicLockMax);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_magicLockMax)) = value;
		}
	}

	// Token: 0x170005D5 RID: 1493
	// (get) Token: 0x06001347 RID: 4935 RVA: 0x00053AB0 File Offset: 0x00051CB0
	// (set) Token: 0x06001348 RID: 4936 RVA: 0x00053AD8 File Offset: 0x00051CD8
	public unsafe float iceLockRange
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockRange);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockRange)) = value;
		}
	}

	// Token: 0x170005D6 RID: 1494
	// (get) Token: 0x06001349 RID: 4937 RVA: 0x00053AFC File Offset: 0x00051CFC
	// (set) Token: 0x0600134A RID: 4938 RVA: 0x00053B24 File Offset: 0x00051D24
	public unsafe float iceLockWorldRange
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockWorldRange);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_iceLockWorldRange)) = value;
		}
	}

	// Token: 0x170005D7 RID: 1495
	// (get) Token: 0x0600134B RID: 4939 RVA: 0x00053B48 File Offset: 0x00051D48
	// (set) Token: 0x0600134C RID: 4940 RVA: 0x00053B70 File Offset: 0x00051D70
	public unsafe bool isPerspectiveLockEnabled
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isPerspectiveLockEnabled);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_isPerspectiveLockEnabled)) = value;
		}
	}

	// Token: 0x170005D8 RID: 1496
	// (get) Token: 0x0600134D RID: 4941 RVA: 0x00053B94 File Offset: 0x00051D94
	// (set) Token: 0x0600134E RID: 4942 RVA: 0x00053BC8 File Offset: 0x00051DC8
	public unsafe LockPoint perspectiveLockTarget
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockTarget);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new LockPoint(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockTarget), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005D9 RID: 1497
	// (get) Token: 0x0600134F RID: 4943 RVA: 0x00053BF0 File Offset: 0x00051DF0
	// (set) Token: 0x06001350 RID: 4944 RVA: 0x00053C0E File Offset: 0x00051E0E
	public unsafe static float PERSPECTIVE_LOCK_DISTANCE
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(LockPointsManager.NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(LockPointsManager.NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE, (void*)(&value));
		}
	}

	// Token: 0x170005DA RID: 1498
	// (get) Token: 0x06001351 RID: 4945 RVA: 0x00053C20 File Offset: 0x00051E20
	// (set) Token: 0x06001352 RID: 4946 RVA: 0x00053C48 File Offset: 0x00051E48
	public unsafe float perspectiveLockDistance
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockDistance);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LockPointsManager.NativeFieldInfoPtr_perspectiveLockDistance)) = value;
		}
	}

	// Token: 0x04000EFD RID: 3837
	private static readonly IntPtr NativeFieldInfoPtr_lockPoints;

	// Token: 0x04000EFE RID: 3838
	private static readonly IntPtr NativeFieldInfoPtr_lockedOnPoints;

	// Token: 0x04000EFF RID: 3839
	private static readonly IntPtr NativeFieldInfoPtr_lockMask;

	// Token: 0x04000F00 RID: 3840
	private static readonly IntPtr NativeFieldInfoPtr_isAimPointEnabled;

	// Token: 0x04000F01 RID: 3841
	private static readonly IntPtr NativeFieldInfoPtr_lockWaitDelta;

	// Token: 0x04000F02 RID: 3842
	private static readonly IntPtr NativeFieldInfoPtr_lockWaitValue;

	// Token: 0x04000F03 RID: 3843
	private static readonly IntPtr NativeFieldInfoPtr_magicLockMax;

	// Token: 0x04000F04 RID: 3844
	private static readonly IntPtr NativeFieldInfoPtr_iceLockRange;

	// Token: 0x04000F05 RID: 3845
	private static readonly IntPtr NativeFieldInfoPtr_iceLockWorldRange;

	// Token: 0x04000F06 RID: 3846
	private static readonly IntPtr NativeFieldInfoPtr_isPerspectiveLockEnabled;

	// Token: 0x04000F07 RID: 3847
	private static readonly IntPtr NativeFieldInfoPtr_perspectiveLockTarget;

	// Token: 0x04000F08 RID: 3848
	private static readonly IntPtr NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE;

	// Token: 0x04000F09 RID: 3849
	private static readonly IntPtr NativeFieldInfoPtr_perspectiveLockDistance;

	// Token: 0x04000F0A RID: 3850
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_0;

	// Token: 0x04000F0B RID: 3851
	private static readonly IntPtr NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0;

	// Token: 0x04000F0C RID: 3852
	private static readonly IntPtr NativeMethodInfoPtr_GetLockPointsCount_Public_Int32_0;

	// Token: 0x04000F0D RID: 3853
	private static readonly IntPtr NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_Int32_0;

	// Token: 0x04000F0E RID: 3854
	private static readonly IntPtr NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_LockPoint_0;

	// Token: 0x04000F0F RID: 3855
	private static readonly IntPtr NativeMethodInfoPtr_LockReset_Public_Void_0;

	// Token: 0x04000F10 RID: 3856
	private static readonly IntPtr NativeMethodInfoPtr_GetLockedOnPointsCount_Public_Int32_0;

	// Token: 0x04000F11 RID: 3857
	private static readonly IntPtr NativeMethodInfoPtr_GetLockedOnTargetArray_Public_Il2CppReferenceArray_1_Transform_0;

	// Token: 0x04000F12 RID: 3858
	private static readonly IntPtr NativeMethodInfoPtr_SetPerspectiveLockEnabled_Public_Void_Boolean_0;

	// Token: 0x04000F13 RID: 3859
	private static readonly IntPtr NativeMethodInfoPtr_GetPerspectiveLockEnabled_Public_Boolean_0;

	// Token: 0x04000F14 RID: 3860
	private static readonly IntPtr NativeMethodInfoPtr_GetPerspectiveLockTarget_Public_LockPoint_0;

	// Token: 0x04000F15 RID: 3861
	private static readonly IntPtr NativeMethodInfoPtr_ClearPerspectiveLockTarget_Public_Void_0;

	// Token: 0x04000F16 RID: 3862
	private static readonly IntPtr NativeMethodInfoPtr_GetPerspectiveLockDistance_Public_Single_0;

	// Token: 0x04000F17 RID: 3863
	private static readonly IntPtr NativeMethodInfoPtr_SetPerspectiveLockDistance_Public_Void_Single_0;

	// Token: 0x04000F18 RID: 3864
	private static readonly IntPtr NativeMethodInfoPtr_DefaultPerspectiveLockDistance_Public_Void_0;

	// Token: 0x04000F19 RID: 3865
	private static readonly IntPtr NativeMethodInfoPtr_CancelLock_Public_Void_0;

	// Token: 0x04000F1A RID: 3866
	private static readonly IntPtr NativeMethodInfoPtr_SetAimPointEnabled_Public_Void_Boolean_0;

	// Token: 0x04000F1B RID: 3867
	private static readonly IntPtr NativeMethodInfoPtr_GetAimPointEnabled_Public_Boolean_0;

	// Token: 0x04000F1C RID: 3868
	private static readonly IntPtr NativeMethodInfoPtr_UpdateLockedOnPoint_Public_Void_0;

	// Token: 0x04000F1D RID: 3869
	private static readonly IntPtr NativeMethodInfoPtr_AutoLockNearby_Public_Void_Vector3_Single_0;

	// Token: 0x04000F1E RID: 3870
	private static readonly IntPtr NativeMethodInfoPtr_GetClosest_Public_Transform_0;

	// Token: 0x04000F1F RID: 3871
	private static readonly IntPtr NativeMethodInfoPtr_SwitchPerspectiveLockTarget_Public_Void_Vector2_Vector2_0;

	// Token: 0x04000F20 RID: 3872
	private static readonly IntPtr NativeMethodInfoPtr_TryUpdatePerspectiveLockTarget_Public_Boolean_0;

	// Token: 0x04000F21 RID: 3873
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMagicLockMax_Public_Void_Magic_0;

	// Token: 0x04000F22 RID: 3874
	private static readonly IntPtr NativeMethodInfoPtr_ResetIceLockNumMax_Public_Void_0;

	// Token: 0x04000F23 RID: 3875
	private static readonly IntPtr NativeMethodInfoPtr_TryGetDistanceLockData_Private_Boolean_Int32_LockSetupData_byref_LockResultData_0;

	// Token: 0x04000F24 RID: 3876
	private static readonly IntPtr NativeMethodInfoPtr_AddLockedOnPoint_Private_Void_LockPoint_0;

	// Token: 0x04000F25 RID: 3877
	private static readonly IntPtr NativeMethodInfoPtr_SetLockedOnPoint_Private_Void_Int32_LockPoint_0;

	// Token: 0x04000F26 RID: 3878
	private static readonly IntPtr NativeMethodInfoPtr_RemoveLockedOnPoint_Private_Void_Int32_0;

	// Token: 0x04000F27 RID: 3879
	private static readonly IntPtr NativeMethodInfoPtr_GetLockedOnPoint_Private_LockPoint_Int32_0;

	// Token: 0x04000F28 RID: 3880
	private static readonly IntPtr NativeMethodInfoPtr_ClearLockedOnPoints_Private_Void_0;

	// Token: 0x04000F29 RID: 3881
	private static readonly IntPtr NativeMethodInfoPtr_RefreshLockedOnPoints_Private_Void_0;

	// Token: 0x04000F2A RID: 3882
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

	// Token: 0x020000A3 RID: 163
	[StructLayout(LayoutKind.Explicit)]
	public struct LockSetupData
	{
		// Token: 0x170005DB RID: 1499
		// (get) Token: 0x06001353 RID: 4947 RVA: 0x00053C6C File Offset: 0x00051E6C
		public unsafe static LockPointsManager.LockSetupData Default
		{
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 503393, RefRangeEnd = 503398, XrefRangeStart = 503383, XrefRangeEnd = 503393, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LockPointsManager.LockSetupData.NativeMethodInfoPtr_get_Default_Public_Static_get_LockSetupData_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06001354 RID: 4948 RVA: 0x00053CB0 File Offset: 0x00051EB0
		// Note: this type is marked as 'beforefieldinit'.
		static LockSetupData()
		{
			Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "LockSetupData");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr);
			LockPointsManager.LockSetupData.NativeFieldInfoPtr_PlayerCamPos = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, "PlayerCamPos");
			LockPointsManager.LockSetupData.NativeFieldInfoPtr_PlayerPos = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, "PlayerPos");
			LockPointsManager.LockSetupData.NativeFieldInfoPtr_ScreenCentre = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, "ScreenCentre");
			LockPointsManager.LockSetupData.NativeMethodInfoPtr_get_Default_Public_Static_get_LockSetupData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, 100665107);
		}

		// Token: 0x06001355 RID: 4949 RVA: 0x00053D2B File Offset: 0x00051F2B
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, ref this));
		}

		// Token: 0x04000F2B RID: 3883
		private static readonly IntPtr NativeFieldInfoPtr_PlayerCamPos;

		// Token: 0x04000F2C RID: 3884
		private static readonly IntPtr NativeFieldInfoPtr_PlayerPos;

		// Token: 0x04000F2D RID: 3885
		private static readonly IntPtr NativeFieldInfoPtr_ScreenCentre;

		// Token: 0x04000F2E RID: 3886
		private static readonly IntPtr NativeMethodInfoPtr_get_Default_Public_Static_get_LockSetupData_0;

		// Token: 0x04000F2F RID: 3887
		[FieldOffset(0)]
		public Vector3 PlayerCamPos;

		// Token: 0x04000F30 RID: 3888
		[FieldOffset(12)]
		public Vector3 PlayerPos;

		// Token: 0x04000F31 RID: 3889
		[FieldOffset(24)]
		public Vector3 ScreenCentre;
	}

	// Token: 0x020000A4 RID: 164
	[StructLayout(LayoutKind.Explicit)]
	public struct LockResultData
	{
		// Token: 0x06001356 RID: 4950 RVA: 0x00053D40 File Offset: 0x00051F40
		// Note: this type is marked as 'beforefieldinit'.
		static LockResultData()
		{
			Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, "LockResultData");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr);
			LockPointsManager.LockResultData.NativeFieldInfoPtr_WorldDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "WorldDistance");
			LockPointsManager.LockResultData.NativeFieldInfoPtr_ScreenPos = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "ScreenPos");
			LockPointsManager.LockResultData.NativeFieldInfoPtr_ScreenDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "ScreenDistance");
			LockPointsManager.LockResultData.NativeFieldInfoPtr_PlayerDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, "PlayerDistance");
		}

		// Token: 0x06001357 RID: 4951 RVA: 0x00053DBB File Offset: 0x00051FBB
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, ref this));
		}

		// Token: 0x04000F32 RID: 3890
		private static readonly IntPtr NativeFieldInfoPtr_WorldDistance;

		// Token: 0x04000F33 RID: 3891
		private static readonly IntPtr NativeFieldInfoPtr_ScreenPos;

		// Token: 0x04000F34 RID: 3892
		private static readonly IntPtr NativeFieldInfoPtr_ScreenDistance;

		// Token: 0x04000F35 RID: 3893
		private static readonly IntPtr NativeFieldInfoPtr_PlayerDistance;

		// Token: 0x04000F36 RID: 3894
		[FieldOffset(0)]
		public float WorldDistance;

		// Token: 0x04000F37 RID: 3895
		[FieldOffset(4)]
		public Vector3 ScreenPos;

		// Token: 0x04000F38 RID: 3896
		[FieldOffset(16)]
		public float ScreenDistance;

		// Token: 0x04000F39 RID: 3897
		[FieldOffset(20)]
		public float PlayerDistance;
	}
}