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: 0x020000A1 RID: 161
public class LockPointsManager : Il2CppSystem.Object
{
	// Token: 0x06001301 RID: 4865 RVA: 0x000524E0 File Offset: 0x000506E0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487066, RefRangeEnd = 487067, XrefRangeStart = 487033, XrefRangeEnd = 487066, 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: 0x06001302 RID: 4866 RVA: 0x00052524 File Offset: 0x00050724
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487071, RefRangeEnd = 487072, XrefRangeStart = 487067, XrefRangeEnd = 487071, 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: 0x06001303 RID: 4867 RVA: 0x00052580 File Offset: 0x00050780
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487072, XrefRangeEnd = 487073, 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: 0x06001304 RID: 4868 RVA: 0x000525D0 File Offset: 0x000507D0
	[CallerCount(21)]
	[CachedScanResults(RefRangeStart = 487076, RefRangeEnd = 487097, XrefRangeStart = 487073, XrefRangeEnd = 487076, 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: 0x06001305 RID: 4869 RVA: 0x00052638 File Offset: 0x00050838
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487102, RefRangeEnd = 487103, XrefRangeStart = 487097, XrefRangeEnd = 487102, 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: 0x06001306 RID: 4870 RVA: 0x000526A8 File Offset: 0x000508A8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487117, RefRangeEnd = 487118, XrefRangeStart = 487103, XrefRangeEnd = 487117, 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: 0x06001307 RID: 4871 RVA: 0x000526EC File Offset: 0x000508EC
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 487119, RefRangeEnd = 487127, XrefRangeStart = 487118, XrefRangeEnd = 487119, 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: 0x06001308 RID: 4872 RVA: 0x0005273C File Offset: 0x0005093C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487137, RefRangeEnd = 487138, XrefRangeStart = 487127, XrefRangeEnd = 487137, 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: 0x06001309 RID: 4873 RVA: 0x00052794 File Offset: 0x00050994
	[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: 0x0600130A RID: 4874 RVA: 0x000527E8 File Offset: 0x000509E8
	[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: 0x0600130B RID: 4875 RVA: 0x00052838 File Offset: 0x00050A38
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 10995, RefRangeEnd = 10996, XrefRangeStart = 10995, XrefRangeEnd = 10996, 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: 0x0600130C RID: 4876 RVA: 0x00052890 File Offset: 0x00050A90
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487139, RefRangeEnd = 487141, XrefRangeStart = 487138, XrefRangeEnd = 487139, 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: 0x0600130D RID: 4877 RVA: 0x000528D4 File Offset: 0x00050AD4
	[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: 0x0600130E RID: 4878 RVA: 0x00052924 File Offset: 0x00050B24
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 218257, RefRangeEnd = 218258, XrefRangeStart = 218257, XrefRangeEnd = 218258, 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: 0x0600130F RID: 4879 RVA: 0x00052978 File Offset: 0x00050B78
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487141, RefRangeEnd = 487143, XrefRangeStart = 487141, XrefRangeEnd = 487141, 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: 0x06001310 RID: 4880 RVA: 0x000529BC File Offset: 0x00050BBC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 487161, RefRangeEnd = 487165, XrefRangeStart = 487143, XrefRangeEnd = 487161, 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: 0x06001311 RID: 4881 RVA: 0x00052A00 File Offset: 0x00050C00
	[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: 0x06001312 RID: 4882 RVA: 0x00052A54 File Offset: 0x00050C54
	[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: 0x06001313 RID: 4883 RVA: 0x00052AA4 File Offset: 0x00050CA4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487257, RefRangeEnd = 487258, XrefRangeStart = 487165, XrefRangeEnd = 487257, 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: 0x06001314 RID: 4884 RVA: 0x00052AE8 File Offset: 0x00050CE8
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487286, RefRangeEnd = 487288, XrefRangeStart = 487258, XrefRangeEnd = 487286, 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: 0x06001315 RID: 4885 RVA: 0x00052B50 File Offset: 0x00050D50
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487297, RefRangeEnd = 487298, XrefRangeStart = 487288, XrefRangeEnd = 487297, 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: 0x06001316 RID: 4886 RVA: 0x00052BA8 File Offset: 0x00050DA8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487339, RefRangeEnd = 487340, XrefRangeStart = 487298, XrefRangeEnd = 487339, 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: 0x06001317 RID: 4887 RVA: 0x00052C10 File Offset: 0x00050E10
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487360, RefRangeEnd = 487361, XrefRangeStart = 487340, XrefRangeEnd = 487360, 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: 0x06001318 RID: 4888 RVA: 0x00052C60 File Offset: 0x00050E60
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487363, RefRangeEnd = 487365, XrefRangeStart = 487361, XrefRangeEnd = 487363, 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: 0x06001319 RID: 4889 RVA: 0x00052CB4 File Offset: 0x00050EB4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487373, RefRangeEnd = 487374, XrefRangeStart = 487365, XrefRangeEnd = 487373, 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: 0x0600131A RID: 4890 RVA: 0x00052CF8 File Offset: 0x00050EF8
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 487398, RefRangeEnd = 487403, XrefRangeStart = 487374, XrefRangeEnd = 487398, 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: 0x0600131B RID: 4891 RVA: 0x00052D84 File Offset: 0x00050F84
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487407, RefRangeEnd = 487409, XrefRangeStart = 487403, XrefRangeEnd = 487407, 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: 0x0600131C RID: 4892 RVA: 0x00052DE0 File Offset: 0x00050FE0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487413, RefRangeEnd = 487415, XrefRangeStart = 487409, XrefRangeEnd = 487413, 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: 0x0600131D RID: 4893 RVA: 0x00052E4C File Offset: 0x0005104C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487435, RefRangeEnd = 487437, XrefRangeStart = 487415, XrefRangeEnd = 487435, 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: 0x0600131E RID: 4894 RVA: 0x00052EA0 File Offset: 0x000510A0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487439, RefRangeEnd = 487441, XrefRangeStart = 487437, XrefRangeEnd = 487439, 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: 0x0600131F RID: 4895 RVA: 0x00052F08 File Offset: 0x00051108
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487441, XrefRangeEnd = 487445, 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: 0x06001320 RID: 4896 RVA: 0x00052F4C File Offset: 0x0005114C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487445, XrefRangeEnd = 487457, 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: 0x06001321 RID: 4897 RVA: 0x00052F90 File Offset: 0x00051190
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487458, RefRangeEnd = 487459, XrefRangeStart = 487457, XrefRangeEnd = 487458, 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: 0x06001322 RID: 4898 RVA: 0x00052FDC File Offset: 0x000511DC
	// 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, 100665073);
		LockPointsManager.NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665074);
		LockPointsManager.NativeMethodInfoPtr_GetLockPointsCount_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665075);
		LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665076);
		LockPointsManager.NativeMethodInfoPtr_GetLockPoint_Public_LockPoint_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665077);
		LockPointsManager.NativeMethodInfoPtr_LockReset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665078);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnPointsCount_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665079);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnTargetArray_Public_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665080);
		LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665081);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockEnabled_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665082);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockTarget_Public_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665083);
		LockPointsManager.NativeMethodInfoPtr_ClearPerspectiveLockTarget_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665084);
		LockPointsManager.NativeMethodInfoPtr_GetPerspectiveLockDistance_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665085);
		LockPointsManager.NativeMethodInfoPtr_SetPerspectiveLockDistance_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665086);
		LockPointsManager.NativeMethodInfoPtr_DefaultPerspectiveLockDistance_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665087);
		LockPointsManager.NativeMethodInfoPtr_CancelLock_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665088);
		LockPointsManager.NativeMethodInfoPtr_SetAimPointEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665089);
		LockPointsManager.NativeMethodInfoPtr_GetAimPointEnabled_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665090);
		LockPointsManager.NativeMethodInfoPtr_UpdateLockedOnPoint_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665091);
		LockPointsManager.NativeMethodInfoPtr_AutoLockNearby_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665092);
		LockPointsManager.NativeMethodInfoPtr_GetClosest_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665093);
		LockPointsManager.NativeMethodInfoPtr_SwitchPerspectiveLockTarget_Public_Void_Vector2_Vector2_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665094);
		LockPointsManager.NativeMethodInfoPtr_TryUpdatePerspectiveLockTarget_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665095);
		LockPointsManager.NativeMethodInfoPtr_UpdateMagicLockMax_Public_Void_Magic_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665096);
		LockPointsManager.NativeMethodInfoPtr_ResetIceLockNumMax_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665097);
		LockPointsManager.NativeMethodInfoPtr_TryGetDistanceLockData_Private_Boolean_Int32_LockSetupData_byref_LockResultData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665098);
		LockPointsManager.NativeMethodInfoPtr_AddLockedOnPoint_Private_Void_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665099);
		LockPointsManager.NativeMethodInfoPtr_SetLockedOnPoint_Private_Void_Int32_LockPoint_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665100);
		LockPointsManager.NativeMethodInfoPtr_RemoveLockedOnPoint_Private_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665101);
		LockPointsManager.NativeMethodInfoPtr_GetLockedOnPoint_Private_LockPoint_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665102);
		LockPointsManager.NativeMethodInfoPtr_ClearLockedOnPoints_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665103);
		LockPointsManager.NativeMethodInfoPtr_RefreshLockedOnPoints_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665104);
		LockPointsManager.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LockPointsManager>.NativeClassPtr, 100665105);
	}

	// Token: 0x06001323 RID: 4899 RVA: 0x0000A688 File Offset: 0x00008888
	public LockPointsManager(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x170005C3 RID: 1475
	// (get) Token: 0x06001324 RID: 4900 RVA: 0x000533A4 File Offset: 0x000515A4
	// (set) Token: 0x06001325 RID: 4901 RVA: 0x000533D8 File Offset: 0x000515D8
	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: 0x170005C4 RID: 1476
	// (get) Token: 0x06001326 RID: 4902 RVA: 0x00053400 File Offset: 0x00051600
	// (set) Token: 0x06001327 RID: 4903 RVA: 0x00053434 File Offset: 0x00051634
	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: 0x170005C5 RID: 1477
	// (get) Token: 0x06001328 RID: 4904 RVA: 0x0005345C File Offset: 0x0005165C
	// (set) Token: 0x06001329 RID: 4905 RVA: 0x00053484 File Offset: 0x00051684
	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: 0x170005C6 RID: 1478
	// (get) Token: 0x0600132A RID: 4906 RVA: 0x000534A8 File Offset: 0x000516A8
	// (set) Token: 0x0600132B RID: 4907 RVA: 0x000534D0 File Offset: 0x000516D0
	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: 0x170005C7 RID: 1479
	// (get) Token: 0x0600132C RID: 4908 RVA: 0x000534F4 File Offset: 0x000516F4
	// (set) Token: 0x0600132D RID: 4909 RVA: 0x0005351C File Offset: 0x0005171C
	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: 0x170005C8 RID: 1480
	// (get) Token: 0x0600132E RID: 4910 RVA: 0x00053540 File Offset: 0x00051740
	// (set) Token: 0x0600132F RID: 4911 RVA: 0x00053568 File Offset: 0x00051768
	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: 0x170005C9 RID: 1481
	// (get) Token: 0x06001330 RID: 4912 RVA: 0x0005358C File Offset: 0x0005178C
	// (set) Token: 0x06001331 RID: 4913 RVA: 0x000535B4 File Offset: 0x000517B4
	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: 0x170005CA RID: 1482
	// (get) Token: 0x06001332 RID: 4914 RVA: 0x000535D8 File Offset: 0x000517D8
	// (set) Token: 0x06001333 RID: 4915 RVA: 0x00053600 File Offset: 0x00051800
	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: 0x170005CB RID: 1483
	// (get) Token: 0x06001334 RID: 4916 RVA: 0x00053624 File Offset: 0x00051824
	// (set) Token: 0x06001335 RID: 4917 RVA: 0x0005364C File Offset: 0x0005184C
	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: 0x170005CC RID: 1484
	// (get) Token: 0x06001336 RID: 4918 RVA: 0x00053670 File Offset: 0x00051870
	// (set) Token: 0x06001337 RID: 4919 RVA: 0x00053698 File Offset: 0x00051898
	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: 0x170005CD RID: 1485
	// (get) Token: 0x06001338 RID: 4920 RVA: 0x000536BC File Offset: 0x000518BC
	// (set) Token: 0x06001339 RID: 4921 RVA: 0x000536F0 File Offset: 0x000518F0
	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: 0x170005CE RID: 1486
	// (get) Token: 0x0600133A RID: 4922 RVA: 0x00053718 File Offset: 0x00051918
	// (set) Token: 0x0600133B RID: 4923 RVA: 0x00053736 File Offset: 0x00051936
	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: 0x170005CF RID: 1487
	// (get) Token: 0x0600133C RID: 4924 RVA: 0x00053748 File Offset: 0x00051948
	// (set) Token: 0x0600133D RID: 4925 RVA: 0x00053770 File Offset: 0x00051970
	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: 0x04000EEE RID: 3822
	private static readonly IntPtr NativeFieldInfoPtr_lockPoints;

	// Token: 0x04000EEF RID: 3823
	private static readonly IntPtr NativeFieldInfoPtr_lockedOnPoints;

	// Token: 0x04000EF0 RID: 3824
	private static readonly IntPtr NativeFieldInfoPtr_lockMask;

	// Token: 0x04000EF1 RID: 3825
	private static readonly IntPtr NativeFieldInfoPtr_isAimPointEnabled;

	// Token: 0x04000EF2 RID: 3826
	private static readonly IntPtr NativeFieldInfoPtr_lockWaitDelta;

	// Token: 0x04000EF3 RID: 3827
	private static readonly IntPtr NativeFieldInfoPtr_lockWaitValue;

	// Token: 0x04000EF4 RID: 3828
	private static readonly IntPtr NativeFieldInfoPtr_magicLockMax;

	// Token: 0x04000EF5 RID: 3829
	private static readonly IntPtr NativeFieldInfoPtr_iceLockRange;

	// Token: 0x04000EF6 RID: 3830
	private static readonly IntPtr NativeFieldInfoPtr_iceLockWorldRange;

	// Token: 0x04000EF7 RID: 3831
	private static readonly IntPtr NativeFieldInfoPtr_isPerspectiveLockEnabled;

	// Token: 0x04000EF8 RID: 3832
	private static readonly IntPtr NativeFieldInfoPtr_perspectiveLockTarget;

	// Token: 0x04000EF9 RID: 3833
	private static readonly IntPtr NativeFieldInfoPtr_PERSPECTIVE_LOCK_DISTANCE;

	// Token: 0x04000EFA RID: 3834
	private static readonly IntPtr NativeFieldInfoPtr_perspectiveLockDistance;

	// Token: 0x04000EFB RID: 3835
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_0;

	// Token: 0x04000EFC RID: 3836
	private static readonly IntPtr NativeMethodInfoPtr_AddLockPoints_Public_Void_Il2CppReferenceArray_1_LockPoint_0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// Token: 0x020000A2 RID: 162
	[StructLayout(LayoutKind.Explicit)]
	public struct LockSetupData
	{
		// Token: 0x170005D0 RID: 1488
		// (get) Token: 0x0600133E RID: 4926 RVA: 0x00053794 File Offset: 0x00051994
		public unsafe static LockPointsManager.LockSetupData Default
		{
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 487028, RefRangeEnd = 487033, XrefRangeStart = 487018, XrefRangeEnd = 487028, 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: 0x0600133F RID: 4927 RVA: 0x000537D8 File Offset: 0x000519D8
		// 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, 100665106);
		}

		// Token: 0x06001340 RID: 4928 RVA: 0x00053853 File Offset: 0x00051A53
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<LockPointsManager.LockSetupData>.NativeClassPtr, ref this));
		}

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

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

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

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

		// Token: 0x04000F20 RID: 3872
		[FieldOffset(0)]
		public Vector3 PlayerCamPos;

		// Token: 0x04000F21 RID: 3873
		[FieldOffset(12)]
		public Vector3 PlayerPos;

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

	// Token: 0x020000A3 RID: 163
	[StructLayout(LayoutKind.Explicit)]
	public struct LockResultData
	{
		// Token: 0x06001341 RID: 4929 RVA: 0x00053868 File Offset: 0x00051A68
		// 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: 0x06001342 RID: 4930 RVA: 0x000538E3 File Offset: 0x00051AE3
		public Il2CppSystem.Object BoxIl2CppObject()
		{
			return new Il2CppSystem.Object(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<LockPointsManager.LockResultData>.NativeClassPtr, ref this));
		}

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

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

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

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

		// Token: 0x04000F27 RID: 3879
		[FieldOffset(0)]
		public float WorldDistance;

		// Token: 0x04000F28 RID: 3880
		[FieldOffset(4)]
		public Vector3 ScreenPos;

		// Token: 0x04000F29 RID: 3881
		[FieldOffset(16)]
		public float ScreenDistance;

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