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

// Token: 0x020000A4 RID: 164
[Serializable]
public class MoveController : Il2CppSystem.Object
{
	// Token: 0x170005F6 RID: 1526
	// (get) Token: 0x06001343 RID: 4931 RVA: 0x000538F8 File Offset: 0x00051AF8
	public unsafe bool IsSky
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06001344 RID: 4932 RVA: 0x00053948 File Offset: 0x00051B48
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 487516, RefRangeEnd = 487521, XrefRangeStart = 487459, XrefRangeEnd = 487516, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Init(Transform source)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Init_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001345 RID: 4933 RVA: 0x000539A4 File Offset: 0x00051BA4
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 487542, RefRangeEnd = 487549, XrefRangeStart = 487521, XrefRangeEnd = 487542, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Update(float deltaTime)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref deltaTime;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Update_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001346 RID: 4934 RVA: 0x000539F8 File Offset: 0x00051BF8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487562, RefRangeEnd = 487563, XrefRangeStart = 487549, XrefRangeEnd = 487562, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateActionMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateActionMove_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001347 RID: 4935 RVA: 0x00053A3C File Offset: 0x00051C3C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487566, RefRangeEnd = 487568, XrefRangeStart = 487563, XrefRangeEnd = 487566, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateActionRotate(Vector3 direction)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref direction;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateActionRotate_Private_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001348 RID: 4936 RVA: 0x00053A90 File Offset: 0x00051C90
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487568, XrefRangeEnd = 487571, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateMovement()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateMovement_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001349 RID: 4937 RVA: 0x00053AD4 File Offset: 0x00051CD4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487571, XrefRangeEnd = 487572, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateGravity()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateGravity_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600134A RID: 4938 RVA: 0x00053B18 File Offset: 0x00051D18
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487616, RefRangeEnd = 487617, XrefRangeStart = 487572, XrefRangeEnd = 487616, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateSlideForce()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateSlideForce_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600134B RID: 4939 RVA: 0x00053B5C File Offset: 0x00051D5C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487617, XrefRangeEnd = 487619, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void StartSliding(RaycastHit hit)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref hit;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_StartSliding_Private_Void_RaycastHit_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600134C RID: 4940 RVA: 0x00053BB0 File Offset: 0x00051DB0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487619, XrefRangeEnd = 487624, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe bool IsBottomCenterGrounded()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_IsBottomCenterGrounded_Private_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600134D RID: 4941 RVA: 0x00053C00 File Offset: 0x00051E00
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 487668, RefRangeEnd = 487669, XrefRangeStart = 487624, XrefRangeEnd = 487668, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculatePushForce()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculatePushForce_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600134E RID: 4942 RVA: 0x00053C44 File Offset: 0x00051E44
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 487673, RefRangeEnd = 487675, XrefRangeStart = 487669, XrefRangeEnd = 487673, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Vector3 GetPushDirection(Transform target)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(target);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetPushDirection_Private_Vector3_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x0600134F RID: 4943 RVA: 0x00053CAC File Offset: 0x00051EAC
	[CallerCount(60)]
	[CachedScanResults(RefRangeStart = 487678, RefRangeEnd = 487738, XrefRangeStart = 487675, XrefRangeEnd = 487678, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Move(Vector3 inputDirection, float inputSpeed, Vector3 lookAtDirection)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref inputDirection;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref inputSpeed;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lookAtDirection;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001350 RID: 4944 RVA: 0x00053D28 File Offset: 0x00051F28
	[CallerCount(8)]
	[CachedScanResults(RefRangeStart = 487746, RefRangeEnd = 487754, XrefRangeStart = 487738, XrefRangeEnd = 487746, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void MoveVertical(Vector3 inputDirection, float inputSpeed, Vector3 lookAtDirection)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref inputDirection;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref inputSpeed;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lookAtDirection;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001351 RID: 4945 RVA: 0x00053DA4 File Offset: 0x00051FA4
	[CallerCount(193)]
	[CachedScanResults(RefRangeStart = 487758, RefRangeEnd = 487951, XrefRangeStart = 487754, XrefRangeEnd = 487758, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void LookAt(Vector3 lookAtDirection)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref lookAtDirection;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001352 RID: 4946 RVA: 0x00053DF8 File Offset: 0x00051FF8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 487951, XrefRangeEnd = 487957, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void LookAtVertical(Vector3 v3Direction)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3Direction;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001353 RID: 4947 RVA: 0x00053E4C File Offset: 0x0005204C
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 487960, RefRangeEnd = 487965, XrefRangeStart = 487957, XrefRangeEnd = 487960, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Rotate(Vector3 v3Direction)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3Direction;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001354 RID: 4948 RVA: 0x00053EA0 File Offset: 0x000520A0
	[CallerCount(0)]
	public unsafe void SetGravity(float gravity)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref gravity;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetGravity_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001355 RID: 4949 RVA: 0x00053EF4 File Offset: 0x000520F4
	[CallerCount(79)]
	[CachedScanResults(RefRangeStart = 487965, RefRangeEnd = 488044, XrefRangeStart = 487965, XrefRangeEnd = 487965, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetDragMove(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001356 RID: 4950 RVA: 0x00053F48 File Offset: 0x00052148
	[CallerCount(124)]
	[CachedScanResults(RefRangeStart = 488044, RefRangeEnd = 488168, XrefRangeStart = 488044, XrefRangeEnd = 488044, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetDragRotation(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001357 RID: 4951 RVA: 0x00053F9C File Offset: 0x0005219C
	[CallerCount(0)]
	public unsafe Vector3 GetMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetMove_Public_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001358 RID: 4952 RVA: 0x00053FEC File Offset: 0x000521EC
	[CallerCount(0)]
	public unsafe Vector3 GetHorizontalMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001359 RID: 4953 RVA: 0x0005403C File Offset: 0x0005223C
	[CallerCount(0)]
	public unsafe float GetAngle()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetAngle_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600135A RID: 4954 RVA: 0x0005408C File Offset: 0x0005228C
	[CallerCount(0)]
	public unsafe float GetAimAngle()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetAimAngle_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600135B RID: 4955 RVA: 0x000540DC File Offset: 0x000522DC
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 488168, RefRangeEnd = 488173, XrefRangeStart = 488168, XrefRangeEnd = 488168, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Stop()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Stop_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600135C RID: 4956 RVA: 0x00054120 File Offset: 0x00052320
	[CallerCount(148)]
	[CachedScanResults(RefRangeStart = 488174, RefRangeEnd = 488322, XrefRangeStart = 488173, XrefRangeEnd = 488174, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetActionMove(Vector3 target, float actionDelayTimer, float actionMoveTimer, float actionMoveSpeed, Vector3 Target, bool actionRotationLerp = false)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref target;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionDelayTimer;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionMoveTimer;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionMoveSpeed;
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref Target;
		ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionRotationLerp;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600135D RID: 4957 RVA: 0x000541D4 File Offset: 0x000523D4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 488322, XrefRangeEnd = 488325, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetActionMove(Transform target, float actionDelayTimer, float actionMoveTimer, float actionMoveSpeed, bool actionRotationLerp = false)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(target);
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionDelayTimer;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionMoveTimer;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionMoveSpeed;
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref actionRotationLerp;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600135E RID: 4958 RVA: 0x0005427C File Offset: 0x0005247C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 488325, RefRangeEnd = 488327, XrefRangeStart = 488325, XrefRangeEnd = 488325, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CancelActionMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CancelActionMove_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600135F RID: 4959 RVA: 0x000542C0 File Offset: 0x000524C0
	[CallerCount(20)]
	[CachedScanResults(RefRangeStart = 488327, RefRangeEnd = 488347, XrefRangeStart = 488327, XrefRangeEnd = 488327, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Jump(float force)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref force;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Jump_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001360 RID: 4960 RVA: 0x00054314 File Offset: 0x00052514
	[CallerCount(0)]
	public unsafe float GetJump()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetJump_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001361 RID: 4961 RVA: 0x00054364 File Offset: 0x00052564
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 488347, RefRangeEnd = 488352, XrefRangeStart = 488347, XrefRangeEnd = 488347, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetFloating(float duration)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref duration;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetFloating_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001362 RID: 4962 RVA: 0x000543B8 File Offset: 0x000525B8
	[CallerCount(0)]
	public unsafe float GetFloating()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetFloating_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001363 RID: 4963 RVA: 0x00054408 File Offset: 0x00052608
	[CallerCount(0)]
	public unsafe void SetFall(float fallSpeedMax)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fallSpeedMax;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetFall_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001364 RID: 4964 RVA: 0x0005445C File Offset: 0x0005265C
	[CallerCount(0)]
	public unsafe float GetMaxFall()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetMaxFall_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001365 RID: 4965 RVA: 0x000544AC File Offset: 0x000526AC
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 488352, RefRangeEnd = 488355, XrefRangeStart = 488352, XrefRangeEnd = 488352, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe bool GetHeightLand()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001366 RID: 4966 RVA: 0x000544FC File Offset: 0x000526FC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 488368, RefRangeEnd = 488369, XrefRangeStart = 488355, XrefRangeEnd = 488368, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Vector3 GetFloorPoint()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001367 RID: 4967 RVA: 0x0005454C File Offset: 0x0005274C
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 488379, RefRangeEnd = 488386, XrefRangeStart = 488369, XrefRangeEnd = 488379, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe float GetFloorDistance()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetFloorDistance_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06001368 RID: 4968 RVA: 0x0005459C File Offset: 0x0005279C
	[CallerCount(0)]
	public unsafe void SetForcePush(Vector3 pushForce)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref pushForce;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06001369 RID: 4969 RVA: 0x000545F0 File Offset: 0x000527F0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 488394, RefRangeEnd = 488398, XrefRangeStart = 488386, XrefRangeEnd = 488394, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ProcessPushTarget(Action<DamageObject> processor)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(processor);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_DamageObject_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600136A RID: 4970 RVA: 0x0005464C File Offset: 0x0005284C
	[CallerCount(0)]
	public unsafe void EnableCalculate(bool enable)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref enable;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600136B RID: 4971 RVA: 0x000546A0 File Offset: 0x000528A0
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 7233, RefRangeEnd = 7243, XrefRangeStart = 7233, XrefRangeEnd = 7243, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe CharacterController GetCharacterController()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new CharacterController(intPtr3) : null;
	}

	// Token: 0x0600136C RID: 4972 RVA: 0x000546F8 File Offset: 0x000528F8
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 488403, RefRangeEnd = 488406, XrefRangeStart = 488398, XrefRangeEnd = 488403, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe MoveController()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<MoveController>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600136D RID: 4973 RVA: 0x00054744 File Offset: 0x00052944
	// Note: this type is marked as 'beforefieldinit'.
	static MoveController()
	{
		Il2CppClassPointerStore<MoveController>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "MoveController");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<MoveController>.NativeClassPtr);
		MoveController.NativeFieldInfoPtr_source = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "source");
		MoveController.NativeFieldInfoPtr_controller = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "controller");
		MoveController.NativeFieldInfoPtr_speedDragFactor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "speedDragFactor");
		MoveController.NativeFieldInfoPtr_rotationDragFactor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "rotationDragFactor");
		MoveController.NativeFieldInfoPtr_deltaTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "deltaTime");
		MoveController.NativeFieldInfoPtr_inputDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "inputDirection");
		MoveController.NativeFieldInfoPtr_inputSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "inputSpeed");
		MoveController.NativeFieldInfoPtr_movement = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "movement");
		MoveController.NativeFieldInfoPtr_movementXZ = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "movementXZ");
		MoveController.NativeFieldInfoPtr_moveSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "moveSpeed");
		MoveController.NativeFieldInfoPtr_rotationAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "rotationAngle");
		MoveController.NativeFieldInfoPtr_isGrounded = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "isGrounded");
		MoveController.NativeFieldInfoPtr_isSky = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "isSky");
		MoveController.NativeFieldInfoPtr_verticalForce = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "verticalForce");
		MoveController.NativeFieldInfoPtr_floatingTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "floatingTimer");
		MoveController.NativeFieldInfoPtr_isActionMove = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "isActionMove");
		MoveController.NativeFieldInfoPtr_actionTarget = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "actionTarget");
		MoveController.NativeFieldInfoPtr_actionDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "actionDirection");
		MoveController.NativeFieldInfoPtr_actionTrigger = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "actionTrigger");
		MoveController.NativeFieldInfoPtr_actionDelayTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "actionDelayTimer");
		MoveController.NativeFieldInfoPtr_actionMoveTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "actionMoveTimer");
		MoveController.NativeFieldInfoPtr_actionMoveSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "actionMoveSpeed");
		MoveController.NativeFieldInfoPtr_actionRotationLerp = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "actionRotationLerp");
		MoveController.NativeFieldInfoPtr_isSliding = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "isSliding");
		MoveController.NativeFieldInfoPtr_sideWallFixed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "sideWallFixed");
		MoveController.NativeFieldInfoPtr_lastMovementForce = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "lastMovementForce");
		MoveController.NativeFieldInfoPtr_slideForce = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "slideForce");
		MoveController.NativeFieldInfoPtr_pushForce = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "pushForce");
		MoveController.NativeFieldInfoPtr_lastPushAmount = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "lastPushAmount");
		MoveController.NativeFieldInfoPtr_pushTargets = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "pushTargets");
		MoveController.NativeFieldInfoPtr_hitLayer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "hitLayer");
		MoveController.NativeFieldInfoPtr_pushLayer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "pushLayer");
		MoveController.NativeFieldInfoPtr_npcSelf = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "npcSelf");
		MoveController.NativeFieldInfoPtr_gravity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "gravity");
		MoveController.NativeFieldInfoPtr_fallSpeedMax = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "fallSpeedMax");
		MoveController.NativeFieldInfoPtr_enableCalculate = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "enableCalculate");
		MoveController.NativeFieldInfoPtr_HIT_GROUND_RADIUS = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveController>.NativeClassPtr, "HIT_GROUND_RADIUS");
		MoveController.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665107);
		MoveController.NativeMethodInfoPtr_Init_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665108);
		MoveController.NativeMethodInfoPtr_Update_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665109);
		MoveController.NativeMethodInfoPtr_CalculateActionMove_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665110);
		MoveController.NativeMethodInfoPtr_CalculateActionRotate_Private_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665111);
		MoveController.NativeMethodInfoPtr_CalculateMovement_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665112);
		MoveController.NativeMethodInfoPtr_CalculateGravity_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665113);
		MoveController.NativeMethodInfoPtr_CalculateSlideForce_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665114);
		MoveController.NativeMethodInfoPtr_StartSliding_Private_Void_RaycastHit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665115);
		MoveController.NativeMethodInfoPtr_IsBottomCenterGrounded_Private_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665116);
		MoveController.NativeMethodInfoPtr_CalculatePushForce_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665117);
		MoveController.NativeMethodInfoPtr_GetPushDirection_Private_Vector3_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665118);
		MoveController.NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665119);
		MoveController.NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665120);
		MoveController.NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665121);
		MoveController.NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665122);
		MoveController.NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665123);
		MoveController.NativeMethodInfoPtr_SetGravity_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665124);
		MoveController.NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665125);
		MoveController.NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665126);
		MoveController.NativeMethodInfoPtr_GetMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665127);
		MoveController.NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665128);
		MoveController.NativeMethodInfoPtr_GetAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665129);
		MoveController.NativeMethodInfoPtr_GetAimAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665130);
		MoveController.NativeMethodInfoPtr_Stop_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665131);
		MoveController.NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665132);
		MoveController.NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665133);
		MoveController.NativeMethodInfoPtr_CancelActionMove_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665134);
		MoveController.NativeMethodInfoPtr_Jump_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665135);
		MoveController.NativeMethodInfoPtr_GetJump_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665136);
		MoveController.NativeMethodInfoPtr_SetFloating_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665137);
		MoveController.NativeMethodInfoPtr_GetFloating_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665138);
		MoveController.NativeMethodInfoPtr_SetFall_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665139);
		MoveController.NativeMethodInfoPtr_GetMaxFall_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665140);
		MoveController.NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665141);
		MoveController.NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665142);
		MoveController.NativeMethodInfoPtr_GetFloorDistance_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665143);
		MoveController.NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665144);
		MoveController.NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_DamageObject_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665145);
		MoveController.NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665146);
		MoveController.NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665147);
		MoveController.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665148);
	}

	// Token: 0x0600136E RID: 4974 RVA: 0x0000A688 File Offset: 0x00008888
	public MoveController(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x170005D1 RID: 1489
	// (get) Token: 0x0600136F RID: 4975 RVA: 0x00054DA0 File Offset: 0x00052FA0
	// (set) Token: 0x06001370 RID: 4976 RVA: 0x00054DD4 File Offset: 0x00052FD4
	public unsafe Transform source
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_source);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Transform(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_source), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005D2 RID: 1490
	// (get) Token: 0x06001371 RID: 4977 RVA: 0x00054DFC File Offset: 0x00052FFC
	// (set) Token: 0x06001372 RID: 4978 RVA: 0x00054E30 File Offset: 0x00053030
	public unsafe CharacterController controller
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_controller);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new CharacterController(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_controller), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005D3 RID: 1491
	// (get) Token: 0x06001373 RID: 4979 RVA: 0x00054E58 File Offset: 0x00053058
	// (set) Token: 0x06001374 RID: 4980 RVA: 0x00054E80 File Offset: 0x00053080
	public unsafe float speedDragFactor
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_speedDragFactor);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_speedDragFactor)) = value;
		}
	}

	// Token: 0x170005D4 RID: 1492
	// (get) Token: 0x06001375 RID: 4981 RVA: 0x00054EA4 File Offset: 0x000530A4
	// (set) Token: 0x06001376 RID: 4982 RVA: 0x00054ECC File Offset: 0x000530CC
	public unsafe float rotationDragFactor
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationDragFactor);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationDragFactor)) = value;
		}
	}

	// Token: 0x170005D5 RID: 1493
	// (get) Token: 0x06001377 RID: 4983 RVA: 0x00054EF0 File Offset: 0x000530F0
	// (set) Token: 0x06001378 RID: 4984 RVA: 0x00054F18 File Offset: 0x00053118
	public unsafe float deltaTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_deltaTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_deltaTime)) = value;
		}
	}

	// Token: 0x170005D6 RID: 1494
	// (get) Token: 0x06001379 RID: 4985 RVA: 0x00054F3C File Offset: 0x0005313C
	// (set) Token: 0x0600137A RID: 4986 RVA: 0x00054F64 File Offset: 0x00053164
	public unsafe Vector3 inputDirection
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputDirection);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputDirection)) = value;
		}
	}

	// Token: 0x170005D7 RID: 1495
	// (get) Token: 0x0600137B RID: 4987 RVA: 0x00054F88 File Offset: 0x00053188
	// (set) Token: 0x0600137C RID: 4988 RVA: 0x00054FB0 File Offset: 0x000531B0
	public unsafe float inputSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputSpeed)) = value;
		}
	}

	// Token: 0x170005D8 RID: 1496
	// (get) Token: 0x0600137D RID: 4989 RVA: 0x00054FD4 File Offset: 0x000531D4
	// (set) Token: 0x0600137E RID: 4990 RVA: 0x00054FFC File Offset: 0x000531FC
	public unsafe Vector3 movement
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movement);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movement)) = value;
		}
	}

	// Token: 0x170005D9 RID: 1497
	// (get) Token: 0x0600137F RID: 4991 RVA: 0x00055020 File Offset: 0x00053220
	// (set) Token: 0x06001380 RID: 4992 RVA: 0x00055048 File Offset: 0x00053248
	public unsafe Vector3 movementXZ
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movementXZ);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movementXZ)) = value;
		}
	}

	// Token: 0x170005DA RID: 1498
	// (get) Token: 0x06001381 RID: 4993 RVA: 0x0005506C File Offset: 0x0005326C
	// (set) Token: 0x06001382 RID: 4994 RVA: 0x00055094 File Offset: 0x00053294
	public unsafe float moveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_moveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_moveSpeed)) = value;
		}
	}

	// Token: 0x170005DB RID: 1499
	// (get) Token: 0x06001383 RID: 4995 RVA: 0x000550B8 File Offset: 0x000532B8
	// (set) Token: 0x06001384 RID: 4996 RVA: 0x000550E0 File Offset: 0x000532E0
	public unsafe float rotationAngle
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationAngle);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationAngle)) = value;
		}
	}

	// Token: 0x170005DC RID: 1500
	// (get) Token: 0x06001385 RID: 4997 RVA: 0x00055104 File Offset: 0x00053304
	// (set) Token: 0x06001386 RID: 4998 RVA: 0x0005512C File Offset: 0x0005332C
	public unsafe bool isGrounded
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isGrounded);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isGrounded)) = value;
		}
	}

	// Token: 0x170005DD RID: 1501
	// (get) Token: 0x06001387 RID: 4999 RVA: 0x00055150 File Offset: 0x00053350
	// (set) Token: 0x06001388 RID: 5000 RVA: 0x00055178 File Offset: 0x00053378
	public unsafe bool isSky
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSky);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSky)) = value;
		}
	}

	// Token: 0x170005DE RID: 1502
	// (get) Token: 0x06001389 RID: 5001 RVA: 0x0005519C File Offset: 0x0005339C
	// (set) Token: 0x0600138A RID: 5002 RVA: 0x000551C4 File Offset: 0x000533C4
	public unsafe float verticalForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_verticalForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_verticalForce)) = value;
		}
	}

	// Token: 0x170005DF RID: 1503
	// (get) Token: 0x0600138B RID: 5003 RVA: 0x000551E8 File Offset: 0x000533E8
	// (set) Token: 0x0600138C RID: 5004 RVA: 0x00055210 File Offset: 0x00053410
	public unsafe float floatingTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_floatingTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_floatingTimer)) = value;
		}
	}

	// Token: 0x170005E0 RID: 1504
	// (get) Token: 0x0600138D RID: 5005 RVA: 0x00055234 File Offset: 0x00053434
	// (set) Token: 0x0600138E RID: 5006 RVA: 0x0005525C File Offset: 0x0005345C
	public unsafe bool isActionMove
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isActionMove);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isActionMove)) = value;
		}
	}

	// Token: 0x170005E1 RID: 1505
	// (get) Token: 0x0600138F RID: 5007 RVA: 0x00055280 File Offset: 0x00053480
	// (set) Token: 0x06001390 RID: 5008 RVA: 0x000552B4 File Offset: 0x000534B4
	public unsafe Transform actionTarget
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTarget);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Transform(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTarget), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005E2 RID: 1506
	// (get) Token: 0x06001391 RID: 5009 RVA: 0x000552DC File Offset: 0x000534DC
	// (set) Token: 0x06001392 RID: 5010 RVA: 0x00055304 File Offset: 0x00053504
	public unsafe Vector3 actionDirection
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDirection);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDirection)) = value;
		}
	}

	// Token: 0x170005E3 RID: 1507
	// (get) Token: 0x06001393 RID: 5011 RVA: 0x00055328 File Offset: 0x00053528
	// (set) Token: 0x06001394 RID: 5012 RVA: 0x00055350 File Offset: 0x00053550
	public unsafe Vector3 actionTrigger
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTrigger);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTrigger)) = value;
		}
	}

	// Token: 0x170005E4 RID: 1508
	// (get) Token: 0x06001395 RID: 5013 RVA: 0x00055374 File Offset: 0x00053574
	// (set) Token: 0x06001396 RID: 5014 RVA: 0x0005539C File Offset: 0x0005359C
	public unsafe float actionDelayTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDelayTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDelayTimer)) = value;
		}
	}

	// Token: 0x170005E5 RID: 1509
	// (get) Token: 0x06001397 RID: 5015 RVA: 0x000553C0 File Offset: 0x000535C0
	// (set) Token: 0x06001398 RID: 5016 RVA: 0x000553E8 File Offset: 0x000535E8
	public unsafe float actionMoveTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveTimer)) = value;
		}
	}

	// Token: 0x170005E6 RID: 1510
	// (get) Token: 0x06001399 RID: 5017 RVA: 0x0005540C File Offset: 0x0005360C
	// (set) Token: 0x0600139A RID: 5018 RVA: 0x00055434 File Offset: 0x00053634
	public unsafe float actionMoveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveSpeed)) = value;
		}
	}

	// Token: 0x170005E7 RID: 1511
	// (get) Token: 0x0600139B RID: 5019 RVA: 0x00055458 File Offset: 0x00053658
	// (set) Token: 0x0600139C RID: 5020 RVA: 0x00055480 File Offset: 0x00053680
	public unsafe bool actionRotationLerp
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionRotationLerp);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionRotationLerp)) = value;
		}
	}

	// Token: 0x170005E8 RID: 1512
	// (get) Token: 0x0600139D RID: 5021 RVA: 0x000554A4 File Offset: 0x000536A4
	// (set) Token: 0x0600139E RID: 5022 RVA: 0x000554CC File Offset: 0x000536CC
	public unsafe bool isSliding
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSliding);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSliding)) = value;
		}
	}

	// Token: 0x170005E9 RID: 1513
	// (get) Token: 0x0600139F RID: 5023 RVA: 0x000554F0 File Offset: 0x000536F0
	// (set) Token: 0x060013A0 RID: 5024 RVA: 0x00055518 File Offset: 0x00053718
	public unsafe bool sideWallFixed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_sideWallFixed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_sideWallFixed)) = value;
		}
	}

	// Token: 0x170005EA RID: 1514
	// (get) Token: 0x060013A1 RID: 5025 RVA: 0x0005553C File Offset: 0x0005373C
	// (set) Token: 0x060013A2 RID: 5026 RVA: 0x00055564 File Offset: 0x00053764
	public unsafe Vector3 lastMovementForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastMovementForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastMovementForce)) = value;
		}
	}

	// Token: 0x170005EB RID: 1515
	// (get) Token: 0x060013A3 RID: 5027 RVA: 0x00055588 File Offset: 0x00053788
	// (set) Token: 0x060013A4 RID: 5028 RVA: 0x000555B0 File Offset: 0x000537B0
	public unsafe Vector3 slideForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_slideForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_slideForce)) = value;
		}
	}

	// Token: 0x170005EC RID: 1516
	// (get) Token: 0x060013A5 RID: 5029 RVA: 0x000555D4 File Offset: 0x000537D4
	// (set) Token: 0x060013A6 RID: 5030 RVA: 0x000555FC File Offset: 0x000537FC
	public unsafe Vector3 pushForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushForce)) = value;
		}
	}

	// Token: 0x170005ED RID: 1517
	// (get) Token: 0x060013A7 RID: 5031 RVA: 0x00055620 File Offset: 0x00053820
	// (set) Token: 0x060013A8 RID: 5032 RVA: 0x00055648 File Offset: 0x00053848
	public unsafe int lastPushAmount
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastPushAmount);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastPushAmount)) = value;
		}
	}

	// Token: 0x170005EE RID: 1518
	// (get) Token: 0x060013A9 RID: 5033 RVA: 0x0005566C File Offset: 0x0005386C
	// (set) Token: 0x060013AA RID: 5034 RVA: 0x000556A0 File Offset: 0x000538A0
	public unsafe Il2CppReferenceArray<DamageObject> pushTargets
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushTargets);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Il2CppReferenceArray<DamageObject>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushTargets), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005EF RID: 1519
	// (get) Token: 0x060013AB RID: 5035 RVA: 0x000556C8 File Offset: 0x000538C8
	// (set) Token: 0x060013AC RID: 5036 RVA: 0x000556F0 File Offset: 0x000538F0
	public unsafe LayerMask hitLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_hitLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_hitLayer)) = value;
		}
	}

	// Token: 0x170005F0 RID: 1520
	// (get) Token: 0x060013AD RID: 5037 RVA: 0x00055714 File Offset: 0x00053914
	// (set) Token: 0x060013AE RID: 5038 RVA: 0x0005573C File Offset: 0x0005393C
	public unsafe LayerMask pushLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushLayer)) = value;
		}
	}

	// Token: 0x170005F1 RID: 1521
	// (get) Token: 0x060013AF RID: 5039 RVA: 0x00055760 File Offset: 0x00053960
	// (set) Token: 0x060013B0 RID: 5040 RVA: 0x00055794 File Offset: 0x00053994
	public unsafe NPCManage npcSelf
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_npcSelf);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new NPCManage(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_npcSelf), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005F2 RID: 1522
	// (get) Token: 0x060013B1 RID: 5041 RVA: 0x000557BC File Offset: 0x000539BC
	// (set) Token: 0x060013B2 RID: 5042 RVA: 0x000557E4 File Offset: 0x000539E4
	public unsafe float gravity
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_gravity);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_gravity)) = value;
		}
	}

	// Token: 0x170005F3 RID: 1523
	// (get) Token: 0x060013B3 RID: 5043 RVA: 0x00055808 File Offset: 0x00053A08
	// (set) Token: 0x060013B4 RID: 5044 RVA: 0x00055830 File Offset: 0x00053A30
	public unsafe float fallSpeedMax
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_fallSpeedMax);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_fallSpeedMax)) = value;
		}
	}

	// Token: 0x170005F4 RID: 1524
	// (get) Token: 0x060013B5 RID: 5045 RVA: 0x00055854 File Offset: 0x00053A54
	// (set) Token: 0x060013B6 RID: 5046 RVA: 0x0005587C File Offset: 0x00053A7C
	public unsafe bool enableCalculate
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_enableCalculate);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_enableCalculate)) = value;
		}
	}

	// Token: 0x170005F5 RID: 1525
	// (get) Token: 0x060013B7 RID: 5047 RVA: 0x000558A0 File Offset: 0x00053AA0
	// (set) Token: 0x060013B8 RID: 5048 RVA: 0x000558BE File Offset: 0x00053ABE
	public unsafe static float HIT_GROUND_RADIUS
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(MoveController.NativeFieldInfoPtr_HIT_GROUND_RADIUS, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(MoveController.NativeFieldInfoPtr_HIT_GROUND_RADIUS, (void*)(&value));
		}
	}

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

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

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

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

	// Token: 0x04000F2F RID: 3887
	private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

	// Token: 0x04000F30 RID: 3888
	private static readonly IntPtr NativeFieldInfoPtr_inputDirection;

	// Token: 0x04000F31 RID: 3889
	private static readonly IntPtr NativeFieldInfoPtr_inputSpeed;

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

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

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

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

	// Token: 0x04000F36 RID: 3894
	private static readonly IntPtr NativeFieldInfoPtr_isGrounded;

	// Token: 0x04000F37 RID: 3895
	private static readonly IntPtr NativeFieldInfoPtr_isSky;

	// Token: 0x04000F38 RID: 3896
	private static readonly IntPtr NativeFieldInfoPtr_verticalForce;

	// Token: 0x04000F39 RID: 3897
	private static readonly IntPtr NativeFieldInfoPtr_floatingTimer;

	// Token: 0x04000F3A RID: 3898
	private static readonly IntPtr NativeFieldInfoPtr_isActionMove;

	// Token: 0x04000F3B RID: 3899
	private static readonly IntPtr NativeFieldInfoPtr_actionTarget;

	// Token: 0x04000F3C RID: 3900
	private static readonly IntPtr NativeFieldInfoPtr_actionDirection;

	// Token: 0x04000F3D RID: 3901
	private static readonly IntPtr NativeFieldInfoPtr_actionTrigger;

	// Token: 0x04000F3E RID: 3902
	private static readonly IntPtr NativeFieldInfoPtr_actionDelayTimer;

	// Token: 0x04000F3F RID: 3903
	private static readonly IntPtr NativeFieldInfoPtr_actionMoveTimer;

	// Token: 0x04000F40 RID: 3904
	private static readonly IntPtr NativeFieldInfoPtr_actionMoveSpeed;

	// Token: 0x04000F41 RID: 3905
	private static readonly IntPtr NativeFieldInfoPtr_actionRotationLerp;

	// Token: 0x04000F42 RID: 3906
	private static readonly IntPtr NativeFieldInfoPtr_isSliding;

	// Token: 0x04000F43 RID: 3907
	private static readonly IntPtr NativeFieldInfoPtr_sideWallFixed;

	// Token: 0x04000F44 RID: 3908
	private static readonly IntPtr NativeFieldInfoPtr_lastMovementForce;

	// Token: 0x04000F45 RID: 3909
	private static readonly IntPtr NativeFieldInfoPtr_slideForce;

	// Token: 0x04000F46 RID: 3910
	private static readonly IntPtr NativeFieldInfoPtr_pushForce;

	// Token: 0x04000F47 RID: 3911
	private static readonly IntPtr NativeFieldInfoPtr_lastPushAmount;

	// Token: 0x04000F48 RID: 3912
	private static readonly IntPtr NativeFieldInfoPtr_pushTargets;

	// Token: 0x04000F49 RID: 3913
	private static readonly IntPtr NativeFieldInfoPtr_hitLayer;

	// Token: 0x04000F4A RID: 3914
	private static readonly IntPtr NativeFieldInfoPtr_pushLayer;

	// Token: 0x04000F4B RID: 3915
	private static readonly IntPtr NativeFieldInfoPtr_npcSelf;

	// Token: 0x04000F4C RID: 3916
	private static readonly IntPtr NativeFieldInfoPtr_gravity;

	// Token: 0x04000F4D RID: 3917
	private static readonly IntPtr NativeFieldInfoPtr_fallSpeedMax;

	// Token: 0x04000F4E RID: 3918
	private static readonly IntPtr NativeFieldInfoPtr_enableCalculate;

	// Token: 0x04000F4F RID: 3919
	private static readonly IntPtr NativeFieldInfoPtr_HIT_GROUND_RADIUS;

	// Token: 0x04000F50 RID: 3920
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0;

	// Token: 0x04000F51 RID: 3921
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_Transform_0;

	// Token: 0x04000F52 RID: 3922
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_Single_0;

	// Token: 0x04000F53 RID: 3923
	private static readonly IntPtr NativeMethodInfoPtr_CalculateActionMove_Private_Void_0;

	// Token: 0x04000F54 RID: 3924
	private static readonly IntPtr NativeMethodInfoPtr_CalculateActionRotate_Private_Void_Vector3_0;

	// Token: 0x04000F55 RID: 3925
	private static readonly IntPtr NativeMethodInfoPtr_CalculateMovement_Private_Void_0;

	// Token: 0x04000F56 RID: 3926
	private static readonly IntPtr NativeMethodInfoPtr_CalculateGravity_Private_Void_0;

	// Token: 0x04000F57 RID: 3927
	private static readonly IntPtr NativeMethodInfoPtr_CalculateSlideForce_Private_Void_0;

	// Token: 0x04000F58 RID: 3928
	private static readonly IntPtr NativeMethodInfoPtr_StartSliding_Private_Void_RaycastHit_0;

	// Token: 0x04000F59 RID: 3929
	private static readonly IntPtr NativeMethodInfoPtr_IsBottomCenterGrounded_Private_Boolean_0;

	// Token: 0x04000F5A RID: 3930
	private static readonly IntPtr NativeMethodInfoPtr_CalculatePushForce_Private_Void_0;

	// Token: 0x04000F5B RID: 3931
	private static readonly IntPtr NativeMethodInfoPtr_GetPushDirection_Private_Vector3_Transform_0;

	// Token: 0x04000F5C RID: 3932
	private static readonly IntPtr NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x04000F5D RID: 3933
	private static readonly IntPtr NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x04000F5E RID: 3934
	private static readonly IntPtr NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0;

	// Token: 0x04000F5F RID: 3935
	private static readonly IntPtr NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0;

	// Token: 0x04000F60 RID: 3936
	private static readonly IntPtr NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0;

	// Token: 0x04000F61 RID: 3937
	private static readonly IntPtr NativeMethodInfoPtr_SetGravity_Public_Void_Single_0;

	// Token: 0x04000F62 RID: 3938
	private static readonly IntPtr NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0;

	// Token: 0x04000F63 RID: 3939
	private static readonly IntPtr NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0;

	// Token: 0x04000F64 RID: 3940
	private static readonly IntPtr NativeMethodInfoPtr_GetMove_Public_Vector3_0;

	// Token: 0x04000F65 RID: 3941
	private static readonly IntPtr NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0;

	// Token: 0x04000F66 RID: 3942
	private static readonly IntPtr NativeMethodInfoPtr_GetAngle_Public_Single_0;

	// Token: 0x04000F67 RID: 3943
	private static readonly IntPtr NativeMethodInfoPtr_GetAimAngle_Public_Single_0;

	// Token: 0x04000F68 RID: 3944
	private static readonly IntPtr NativeMethodInfoPtr_Stop_Public_Void_0;

	// Token: 0x04000F69 RID: 3945
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0;

	// Token: 0x04000F6A RID: 3946
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0;

	// Token: 0x04000F6B RID: 3947
	private static readonly IntPtr NativeMethodInfoPtr_CancelActionMove_Public_Void_0;

	// Token: 0x04000F6C RID: 3948
	private static readonly IntPtr NativeMethodInfoPtr_Jump_Public_Void_Single_0;

	// Token: 0x04000F6D RID: 3949
	private static readonly IntPtr NativeMethodInfoPtr_GetJump_Public_Single_0;

	// Token: 0x04000F6E RID: 3950
	private static readonly IntPtr NativeMethodInfoPtr_SetFloating_Public_Void_Single_0;

	// Token: 0x04000F6F RID: 3951
	private static readonly IntPtr NativeMethodInfoPtr_GetFloating_Public_Single_0;

	// Token: 0x04000F70 RID: 3952
	private static readonly IntPtr NativeMethodInfoPtr_SetFall_Public_Void_Single_0;

	// Token: 0x04000F71 RID: 3953
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxFall_Public_Single_0;

	// Token: 0x04000F72 RID: 3954
	private static readonly IntPtr NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0;

	// Token: 0x04000F73 RID: 3955
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0;

	// Token: 0x04000F74 RID: 3956
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorDistance_Public_Single_0;

	// Token: 0x04000F75 RID: 3957
	private static readonly IntPtr NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0;

	// Token: 0x04000F76 RID: 3958
	private static readonly IntPtr NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_DamageObject_0;

	// Token: 0x04000F77 RID: 3959
	private static readonly IntPtr NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0;

	// Token: 0x04000F78 RID: 3960
	private static readonly IntPtr NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0;

	// Token: 0x04000F79 RID: 3961
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}
