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

// Token: 0x02000325 RID: 805
[Serializable]
public class MoveControllerLegacy : Il2CppSystem.Object
{
	// Token: 0x1700260D RID: 9741
	// (get) Token: 0x06006D7B RID: 28027 RVA: 0x001BC978 File Offset: 0x001BAB78
	public unsafe bool IsSky
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06006D7C RID: 28028 RVA: 0x001BC9C8 File Offset: 0x001BABC8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583083, XrefRangeEnd = 583117, 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(MoveControllerLegacy.NativeMethodInfoPtr_Init_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D7D RID: 28029 RVA: 0x001BCA24 File Offset: 0x001BAC24
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583117, XrefRangeEnd = 583135, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Update(float fDeltaTime)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fDeltaTime;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_Update_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D7E RID: 28030 RVA: 0x001BCA78 File Offset: 0x001BAC78
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 583148, RefRangeEnd = 583149, XrefRangeStart = 583135, XrefRangeEnd = 583148, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ActionMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_ActionMove_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D7F RID: 28031 RVA: 0x001BCABC File Offset: 0x001BACBC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 583152, RefRangeEnd = 583153, XrefRangeStart = 583149, XrefRangeEnd = 583152, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ActionRotate(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(MoveControllerLegacy.NativeMethodInfoPtr_ActionRotate_Private_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D80 RID: 28032 RVA: 0x001BCB10 File Offset: 0x001BAD10
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583153, XrefRangeEnd = 583156, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateSpeed()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_CalculateSpeed_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D81 RID: 28033 RVA: 0x001BCB54 File Offset: 0x001BAD54
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 583252, RefRangeEnd = 583253, XrefRangeStart = 583156, XrefRangeEnd = 583252, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DetectGround()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_DetectGround_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D82 RID: 28034 RVA: 0x001BCB98 File Offset: 0x001BAD98
	[CallerCount(0)]
	public unsafe void CalculateGravity()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_CalculateGravity_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D83 RID: 28035 RVA: 0x001BCBDC File Offset: 0x001BADDC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 583276, RefRangeEnd = 583277, XrefRangeStart = 583253, XrefRangeEnd = 583276, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Push()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_Push_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D84 RID: 28036 RVA: 0x001BCC20 File Offset: 0x001BAE20
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583277, XrefRangeEnd = 583282, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Move(Vector3 v3Direction, float fSpeed, Vector3 v3Target)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3Direction;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fSpeed;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref v3Target;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D85 RID: 28037 RVA: 0x001BCC9C File Offset: 0x001BAE9C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583282, XrefRangeEnd = 583290, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void MoveVertical(Vector3 v3Direction, float fSpeed, Vector3 v3Target)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3Direction;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fSpeed;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref v3Target;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D86 RID: 28038 RVA: 0x001BCD18 File Offset: 0x001BAF18
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583290, XrefRangeEnd = 583293, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void LookAt(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(MoveControllerLegacy.NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D87 RID: 28039 RVA: 0x001BCD6C File Offset: 0x001BAF6C
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 487960, RefRangeEnd = 487965, XrefRangeStart = 487960, XrefRangeEnd = 487965, 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(MoveControllerLegacy.NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D88 RID: 28040 RVA: 0x001BCDC0 File Offset: 0x001BAFC0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583293, XrefRangeEnd = 583299, 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(MoveControllerLegacy.NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D89 RID: 28041 RVA: 0x001BCE14 File Offset: 0x001BB014
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583299, XrefRangeEnd = 583300, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetActionMove(Vector3 Direction, float fActionWaitTime, float fActionMoveTime, float fActionMoveSpeed, Vector3 Target, bool bLerpRotate = false)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref Direction;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fActionWaitTime;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fActionMoveTime;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fActionMoveSpeed;
		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 bLerpRotate;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D8A RID: 28042 RVA: 0x001BCEC8 File Offset: 0x001BB0C8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583300, XrefRangeEnd = 583302, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetActionMove(Transform Direction, float fActionWaitTime, float fActionMoveTime, float fActionMoveSpeed, bool bLerpRotate = false)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(Direction);
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fActionWaitTime;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fActionMoveTime;
		ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fActionMoveSpeed;
		ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref bLerpRotate;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D8B RID: 28043 RVA: 0x001BCF70 File Offset: 0x001BB170
	[CallerCount(0)]
	public unsafe void CancelActionMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_CancelActionMove_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D8C RID: 28044 RVA: 0x001BCFB4 File Offset: 0x001BB1B4
	[CallerCount(0)]
	public unsafe void Jump(float fJump)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fJump;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_Jump_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D8D RID: 28045 RVA: 0x001BD008 File Offset: 0x001BB208
	[CallerCount(0)]
	public unsafe void Stop()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_Stop_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006D8E RID: 28046 RVA: 0x001BD04C File Offset: 0x001BB24C
	[CallerCount(0)]
	public unsafe void SetDragMove(float fDragMove)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fDragMove;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D8F RID: 28047 RVA: 0x001BD0A0 File Offset: 0x001BB2A0
	[CallerCount(0)]
	public unsafe void SetDragRotation(float fDragRotation)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fDragRotation;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

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

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

	// Token: 0x06006D92 RID: 28050 RVA: 0x001BD194 File Offset: 0x001BB394
	[CallerCount(0)]
	public unsafe void SetGravity(float fGravity)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fGravity;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetGravity_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D93 RID: 28051 RVA: 0x001BD1E8 File Offset: 0x001BB3E8
	[CallerCount(0)]
	public unsafe void SetFall(float fFall)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fFall;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetFall_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

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

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

	// Token: 0x06006D96 RID: 28054 RVA: 0x001BD2DC File Offset: 0x001BB4DC
	[CallerCount(0)]
	public unsafe bool GetHeightLand()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06006D97 RID: 28055 RVA: 0x001BD32C File Offset: 0x001BB52C
	[CallerCount(0)]
	public unsafe Vector3 GetFloorPoint()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06006D98 RID: 28056 RVA: 0x001BD37C File Offset: 0x001BB57C
	[CallerCount(0)]
	public unsafe void SetFloating(float fFloating)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref fFloating;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetFloating_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

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

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

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

	// Token: 0x06006D9C RID: 28060 RVA: 0x001BD4C0 File Offset: 0x001BB6C0
	[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(MoveControllerLegacy.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: 0x06006D9D RID: 28061 RVA: 0x001BD518 File Offset: 0x001BB718
	[CallerCount(0)]
	public unsafe void SetForcePush(Vector3 v3Push)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3Push;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D9E RID: 28062 RVA: 0x001BD56C File Offset: 0x001BB76C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583302, XrefRangeEnd = 583309, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ProcessPushTarget(Action<Transform> 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(MoveControllerLegacy.NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006D9F RID: 28063 RVA: 0x001BD5C8 File Offset: 0x001BB7C8
	[CallerCount(0)]
	public unsafe float GetFloorDistance()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr_GetFloorDistance_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06006DA0 RID: 28064 RVA: 0x001BD618 File Offset: 0x001BB818
	[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(MoveControllerLegacy.NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006DA1 RID: 28065 RVA: 0x001BD66C File Offset: 0x001BB86C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 583309, XrefRangeEnd = 583312, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe MoveControllerLegacy()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveControllerLegacy.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006DA2 RID: 28066 RVA: 0x001BD6B8 File Offset: 0x001BB8B8
	// Note: this type is marked as 'beforefieldinit'.
	static MoveControllerLegacy()
	{
		Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "MoveControllerLegacy");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr);
		MoveControllerLegacy.NativeFieldInfoPtr_source = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "source");
		MoveControllerLegacy.NativeFieldInfoPtr_character = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "character");
		MoveControllerLegacy.NativeFieldInfoPtr_deltaTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "deltaTime");
		MoveControllerLegacy.NativeFieldInfoPtr_g_v3Move = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_v3Move");
		MoveControllerLegacy.NativeFieldInfoPtr_g_v3ForcePush = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_v3ForcePush");
		MoveControllerLegacy.NativeFieldInfoPtr_g_v3Horizontal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_v3Horizontal");
		MoveControllerLegacy.NativeFieldInfoPtr_g_v3Direction = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_v3Direction");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fEnterSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fEnterSpeed");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fSpeed");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fAngle");
		MoveControllerLegacy.NativeFieldInfoPtr_fAngleH = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "fAngleH");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fDragMove = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fDragMove");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fDragRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fDragRotation");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fGravity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fGravity");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fJump = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fJump");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fFall = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fFall");
		MoveControllerLegacy.NativeFieldInfoPtr_g_bHeightLand = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_bHeightLand");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fFloating = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fFloating");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fFloorDistacne = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fFloorDistacne");
		MoveControllerLegacy.NativeFieldInfoPtr_g_bActionMove = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_bActionMove");
		MoveControllerLegacy.NativeFieldInfoPtr_g_v3ActionDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_v3ActionDirection");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fActionWaitTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fActionWaitTime");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fActionMoveTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fActionMoveTime");
		MoveControllerLegacy.NativeFieldInfoPtr_g_fActionMoveSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_fActionMoveSpeed");
		MoveControllerLegacy.NativeFieldInfoPtr_g_ActionTrigger = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_ActionTrigger");
		MoveControllerLegacy.NativeFieldInfoPtr_g_bActionLerpRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_bActionLerpRotation");
		MoveControllerLegacy.NativeFieldInfoPtr_g_ActionTarget = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_ActionTarget");
		MoveControllerLegacy.NativeFieldInfoPtr_g_v3FloorPoint = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_v3FloorPoint");
		MoveControllerLegacy.NativeFieldInfoPtr_g_bIsSky = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_bIsSky");
		MoveControllerLegacy.NativeFieldInfoPtr_g_BePush = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "g_BePush");
		MoveControllerLegacy.NativeFieldInfoPtr_enableCalculate = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "enableCalculate");
		MoveControllerLegacy.NativeFieldInfoPtr_hitLayer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "hitLayer");
		MoveControllerLegacy.NativeFieldInfoPtr_characterLayer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "characterLayer");
		MoveControllerLegacy.NativeFieldInfoPtr_pushLayer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "pushLayer");
		MoveControllerLegacy.NativeFieldInfoPtr_specialObjectLayer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "specialObjectLayer");
		MoveControllerLegacy.NativeFieldInfoPtr_FLOOR_DISTANCE = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, "FLOOR_DISTANCE");
		MoveControllerLegacy.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671413);
		MoveControllerLegacy.NativeMethodInfoPtr_Init_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671414);
		MoveControllerLegacy.NativeMethodInfoPtr_Update_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671415);
		MoveControllerLegacy.NativeMethodInfoPtr_ActionMove_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671416);
		MoveControllerLegacy.NativeMethodInfoPtr_ActionRotate_Private_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671417);
		MoveControllerLegacy.NativeMethodInfoPtr_CalculateSpeed_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671418);
		MoveControllerLegacy.NativeMethodInfoPtr_DetectGround_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671419);
		MoveControllerLegacy.NativeMethodInfoPtr_CalculateGravity_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671420);
		MoveControllerLegacy.NativeMethodInfoPtr_Push_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671421);
		MoveControllerLegacy.NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671422);
		MoveControllerLegacy.NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671423);
		MoveControllerLegacy.NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671424);
		MoveControllerLegacy.NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671425);
		MoveControllerLegacy.NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671426);
		MoveControllerLegacy.NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671427);
		MoveControllerLegacy.NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671428);
		MoveControllerLegacy.NativeMethodInfoPtr_CancelActionMove_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671429);
		MoveControllerLegacy.NativeMethodInfoPtr_Jump_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671430);
		MoveControllerLegacy.NativeMethodInfoPtr_Stop_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671431);
		MoveControllerLegacy.NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671432);
		MoveControllerLegacy.NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671433);
		MoveControllerLegacy.NativeMethodInfoPtr_GetAimAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671434);
		MoveControllerLegacy.NativeMethodInfoPtr_GetAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671435);
		MoveControllerLegacy.NativeMethodInfoPtr_SetGravity_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671436);
		MoveControllerLegacy.NativeMethodInfoPtr_SetFall_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671437);
		MoveControllerLegacy.NativeMethodInfoPtr_GetJump_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671438);
		MoveControllerLegacy.NativeMethodInfoPtr_GetMaxFall_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671439);
		MoveControllerLegacy.NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671440);
		MoveControllerLegacy.NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671441);
		MoveControllerLegacy.NativeMethodInfoPtr_SetFloating_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671442);
		MoveControllerLegacy.NativeMethodInfoPtr_GetFloating_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671443);
		MoveControllerLegacy.NativeMethodInfoPtr_GetMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671444);
		MoveControllerLegacy.NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671445);
		MoveControllerLegacy.NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671446);
		MoveControllerLegacy.NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671447);
		MoveControllerLegacy.NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671448);
		MoveControllerLegacy.NativeMethodInfoPtr_GetFloorDistance_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671449);
		MoveControllerLegacy.NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671450);
		MoveControllerLegacy.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671451);
	}

	// Token: 0x06006DA3 RID: 28067 RVA: 0x0000A688 File Offset: 0x00008888
	public MoveControllerLegacy(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x170025E9 RID: 9705
	// (get) Token: 0x06006DA4 RID: 28068 RVA: 0x001BDCC4 File Offset: 0x001BBEC4
	// (set) Token: 0x06006DA5 RID: 28069 RVA: 0x001BDCF8 File Offset: 0x001BBEF8
	public unsafe Transform source
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.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(MoveControllerLegacy.NativeFieldInfoPtr_source), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170025EA RID: 9706
	// (get) Token: 0x06006DA6 RID: 28070 RVA: 0x001BDD20 File Offset: 0x001BBF20
	// (set) Token: 0x06006DA7 RID: 28071 RVA: 0x001BDD54 File Offset: 0x001BBF54
	public unsafe CharacterController character
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_character);
			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(MoveControllerLegacy.NativeFieldInfoPtr_character), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170025EB RID: 9707
	// (get) Token: 0x06006DA8 RID: 28072 RVA: 0x001BDD7C File Offset: 0x001BBF7C
	// (set) Token: 0x06006DA9 RID: 28073 RVA: 0x001BDDA4 File Offset: 0x001BBFA4
	public unsafe float deltaTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_deltaTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_deltaTime)) = value;
		}
	}

	// Token: 0x170025EC RID: 9708
	// (get) Token: 0x06006DAA RID: 28074 RVA: 0x001BDDC8 File Offset: 0x001BBFC8
	// (set) Token: 0x06006DAB RID: 28075 RVA: 0x001BDDF0 File Offset: 0x001BBFF0
	public unsafe Vector3 g_v3Move
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3Move);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3Move)) = value;
		}
	}

	// Token: 0x170025ED RID: 9709
	// (get) Token: 0x06006DAC RID: 28076 RVA: 0x001BDE14 File Offset: 0x001BC014
	// (set) Token: 0x06006DAD RID: 28077 RVA: 0x001BDE3C File Offset: 0x001BC03C
	public unsafe Vector3 g_v3ForcePush
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3ForcePush);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3ForcePush)) = value;
		}
	}

	// Token: 0x170025EE RID: 9710
	// (get) Token: 0x06006DAE RID: 28078 RVA: 0x001BDE60 File Offset: 0x001BC060
	// (set) Token: 0x06006DAF RID: 28079 RVA: 0x001BDE88 File Offset: 0x001BC088
	public unsafe Vector3 g_v3Horizontal
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3Horizontal);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3Horizontal)) = value;
		}
	}

	// Token: 0x170025EF RID: 9711
	// (get) Token: 0x06006DB0 RID: 28080 RVA: 0x001BDEAC File Offset: 0x001BC0AC
	// (set) Token: 0x06006DB1 RID: 28081 RVA: 0x001BDED4 File Offset: 0x001BC0D4
	public unsafe Vector3 g_v3Direction
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3Direction);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3Direction)) = value;
		}
	}

	// Token: 0x170025F0 RID: 9712
	// (get) Token: 0x06006DB2 RID: 28082 RVA: 0x001BDEF8 File Offset: 0x001BC0F8
	// (set) Token: 0x06006DB3 RID: 28083 RVA: 0x001BDF20 File Offset: 0x001BC120
	public unsafe float g_fEnterSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fEnterSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fEnterSpeed)) = value;
		}
	}

	// Token: 0x170025F1 RID: 9713
	// (get) Token: 0x06006DB4 RID: 28084 RVA: 0x001BDF44 File Offset: 0x001BC144
	// (set) Token: 0x06006DB5 RID: 28085 RVA: 0x001BDF6C File Offset: 0x001BC16C
	public unsafe float g_fSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fSpeed)) = value;
		}
	}

	// Token: 0x170025F2 RID: 9714
	// (get) Token: 0x06006DB6 RID: 28086 RVA: 0x001BDF90 File Offset: 0x001BC190
	// (set) Token: 0x06006DB7 RID: 28087 RVA: 0x001BDFB8 File Offset: 0x001BC1B8
	public unsafe float g_fAngle
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fAngle);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fAngle)) = value;
		}
	}

	// Token: 0x170025F3 RID: 9715
	// (get) Token: 0x06006DB8 RID: 28088 RVA: 0x001BDFDC File Offset: 0x001BC1DC
	// (set) Token: 0x06006DB9 RID: 28089 RVA: 0x001BE004 File Offset: 0x001BC204
	public unsafe float fAngleH
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_fAngleH);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_fAngleH)) = value;
		}
	}

	// Token: 0x170025F4 RID: 9716
	// (get) Token: 0x06006DBA RID: 28090 RVA: 0x001BE028 File Offset: 0x001BC228
	// (set) Token: 0x06006DBB RID: 28091 RVA: 0x001BE050 File Offset: 0x001BC250
	public unsafe float g_fDragMove
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fDragMove);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fDragMove)) = value;
		}
	}

	// Token: 0x170025F5 RID: 9717
	// (get) Token: 0x06006DBC RID: 28092 RVA: 0x001BE074 File Offset: 0x001BC274
	// (set) Token: 0x06006DBD RID: 28093 RVA: 0x001BE09C File Offset: 0x001BC29C
	public unsafe float g_fDragRotation
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fDragRotation);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fDragRotation)) = value;
		}
	}

	// Token: 0x170025F6 RID: 9718
	// (get) Token: 0x06006DBE RID: 28094 RVA: 0x001BE0C0 File Offset: 0x001BC2C0
	// (set) Token: 0x06006DBF RID: 28095 RVA: 0x001BE0E8 File Offset: 0x001BC2E8
	public unsafe float g_fGravity
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fGravity);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fGravity)) = value;
		}
	}

	// Token: 0x170025F7 RID: 9719
	// (get) Token: 0x06006DC0 RID: 28096 RVA: 0x001BE10C File Offset: 0x001BC30C
	// (set) Token: 0x06006DC1 RID: 28097 RVA: 0x001BE134 File Offset: 0x001BC334
	public unsafe float g_fJump
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fJump);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fJump)) = value;
		}
	}

	// Token: 0x170025F8 RID: 9720
	// (get) Token: 0x06006DC2 RID: 28098 RVA: 0x001BE158 File Offset: 0x001BC358
	// (set) Token: 0x06006DC3 RID: 28099 RVA: 0x001BE180 File Offset: 0x001BC380
	public unsafe float g_fFall
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fFall);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fFall)) = value;
		}
	}

	// Token: 0x170025F9 RID: 9721
	// (get) Token: 0x06006DC4 RID: 28100 RVA: 0x001BE1A4 File Offset: 0x001BC3A4
	// (set) Token: 0x06006DC5 RID: 28101 RVA: 0x001BE1CC File Offset: 0x001BC3CC
	public unsafe bool g_bHeightLand
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bHeightLand);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bHeightLand)) = value;
		}
	}

	// Token: 0x170025FA RID: 9722
	// (get) Token: 0x06006DC6 RID: 28102 RVA: 0x001BE1F0 File Offset: 0x001BC3F0
	// (set) Token: 0x06006DC7 RID: 28103 RVA: 0x001BE218 File Offset: 0x001BC418
	public unsafe float g_fFloating
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fFloating);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fFloating)) = value;
		}
	}

	// Token: 0x170025FB RID: 9723
	// (get) Token: 0x06006DC8 RID: 28104 RVA: 0x001BE23C File Offset: 0x001BC43C
	// (set) Token: 0x06006DC9 RID: 28105 RVA: 0x001BE264 File Offset: 0x001BC464
	public unsafe float g_fFloorDistacne
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fFloorDistacne);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fFloorDistacne)) = value;
		}
	}

	// Token: 0x170025FC RID: 9724
	// (get) Token: 0x06006DCA RID: 28106 RVA: 0x001BE288 File Offset: 0x001BC488
	// (set) Token: 0x06006DCB RID: 28107 RVA: 0x001BE2B0 File Offset: 0x001BC4B0
	public unsafe bool g_bActionMove
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bActionMove);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bActionMove)) = value;
		}
	}

	// Token: 0x170025FD RID: 9725
	// (get) Token: 0x06006DCC RID: 28108 RVA: 0x001BE2D4 File Offset: 0x001BC4D4
	// (set) Token: 0x06006DCD RID: 28109 RVA: 0x001BE2FC File Offset: 0x001BC4FC
	public unsafe Vector3 g_v3ActionDirection
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3ActionDirection);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3ActionDirection)) = value;
		}
	}

	// Token: 0x170025FE RID: 9726
	// (get) Token: 0x06006DCE RID: 28110 RVA: 0x001BE320 File Offset: 0x001BC520
	// (set) Token: 0x06006DCF RID: 28111 RVA: 0x001BE348 File Offset: 0x001BC548
	public unsafe float g_fActionWaitTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fActionWaitTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fActionWaitTime)) = value;
		}
	}

	// Token: 0x170025FF RID: 9727
	// (get) Token: 0x06006DD0 RID: 28112 RVA: 0x001BE36C File Offset: 0x001BC56C
	// (set) Token: 0x06006DD1 RID: 28113 RVA: 0x001BE394 File Offset: 0x001BC594
	public unsafe float g_fActionMoveTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fActionMoveTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fActionMoveTime)) = value;
		}
	}

	// Token: 0x17002600 RID: 9728
	// (get) Token: 0x06006DD2 RID: 28114 RVA: 0x001BE3B8 File Offset: 0x001BC5B8
	// (set) Token: 0x06006DD3 RID: 28115 RVA: 0x001BE3E0 File Offset: 0x001BC5E0
	public unsafe float g_fActionMoveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fActionMoveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_fActionMoveSpeed)) = value;
		}
	}

	// Token: 0x17002601 RID: 9729
	// (get) Token: 0x06006DD4 RID: 28116 RVA: 0x001BE404 File Offset: 0x001BC604
	// (set) Token: 0x06006DD5 RID: 28117 RVA: 0x001BE42C File Offset: 0x001BC62C
	public unsafe Vector3 g_ActionTrigger
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_ActionTrigger);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_ActionTrigger)) = value;
		}
	}

	// Token: 0x17002602 RID: 9730
	// (get) Token: 0x06006DD6 RID: 28118 RVA: 0x001BE450 File Offset: 0x001BC650
	// (set) Token: 0x06006DD7 RID: 28119 RVA: 0x001BE478 File Offset: 0x001BC678
	public unsafe bool g_bActionLerpRotation
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bActionLerpRotation);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bActionLerpRotation)) = value;
		}
	}

	// Token: 0x17002603 RID: 9731
	// (get) Token: 0x06006DD8 RID: 28120 RVA: 0x001BE49C File Offset: 0x001BC69C
	// (set) Token: 0x06006DD9 RID: 28121 RVA: 0x001BE4D0 File Offset: 0x001BC6D0
	public unsafe Transform g_ActionTarget
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_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(MoveControllerLegacy.NativeFieldInfoPtr_g_ActionTarget), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17002604 RID: 9732
	// (get) Token: 0x06006DDA RID: 28122 RVA: 0x001BE4F8 File Offset: 0x001BC6F8
	// (set) Token: 0x06006DDB RID: 28123 RVA: 0x001BE520 File Offset: 0x001BC720
	public unsafe Vector3 g_v3FloorPoint
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3FloorPoint);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_v3FloorPoint)) = value;
		}
	}

	// Token: 0x17002605 RID: 9733
	// (get) Token: 0x06006DDC RID: 28124 RVA: 0x001BE544 File Offset: 0x001BC744
	// (set) Token: 0x06006DDD RID: 28125 RVA: 0x001BE56C File Offset: 0x001BC76C
	public unsafe bool g_bIsSky
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bIsSky);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_bIsSky)) = value;
		}
	}

	// Token: 0x17002606 RID: 9734
	// (get) Token: 0x06006DDE RID: 28126 RVA: 0x001BE590 File Offset: 0x001BC790
	// (set) Token: 0x06006DDF RID: 28127 RVA: 0x001BE5C4 File Offset: 0x001BC7C4
	public unsafe Transform g_BePush
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_g_BePush);
			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(MoveControllerLegacy.NativeFieldInfoPtr_g_BePush), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17002607 RID: 9735
	// (get) Token: 0x06006DE0 RID: 28128 RVA: 0x001BE5EC File Offset: 0x001BC7EC
	// (set) Token: 0x06006DE1 RID: 28129 RVA: 0x001BE614 File Offset: 0x001BC814
	public unsafe bool enableCalculate
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_enableCalculate);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_enableCalculate)) = value;
		}
	}

	// Token: 0x17002608 RID: 9736
	// (get) Token: 0x06006DE2 RID: 28130 RVA: 0x001BE638 File Offset: 0x001BC838
	// (set) Token: 0x06006DE3 RID: 28131 RVA: 0x001BE660 File Offset: 0x001BC860
	public unsafe LayerMask hitLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_hitLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_hitLayer)) = value;
		}
	}

	// Token: 0x17002609 RID: 9737
	// (get) Token: 0x06006DE4 RID: 28132 RVA: 0x001BE684 File Offset: 0x001BC884
	// (set) Token: 0x06006DE5 RID: 28133 RVA: 0x001BE6AC File Offset: 0x001BC8AC
	public unsafe LayerMask characterLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_characterLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_characterLayer)) = value;
		}
	}

	// Token: 0x1700260A RID: 9738
	// (get) Token: 0x06006DE6 RID: 28134 RVA: 0x001BE6D0 File Offset: 0x001BC8D0
	// (set) Token: 0x06006DE7 RID: 28135 RVA: 0x001BE6F8 File Offset: 0x001BC8F8
	public unsafe LayerMask pushLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_pushLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_pushLayer)) = value;
		}
	}

	// Token: 0x1700260B RID: 9739
	// (get) Token: 0x06006DE8 RID: 28136 RVA: 0x001BE71C File Offset: 0x001BC91C
	// (set) Token: 0x06006DE9 RID: 28137 RVA: 0x001BE744 File Offset: 0x001BC944
	public unsafe LayerMask specialObjectLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_specialObjectLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveControllerLegacy.NativeFieldInfoPtr_specialObjectLayer)) = value;
		}
	}

	// Token: 0x1700260C RID: 9740
	// (get) Token: 0x06006DEA RID: 28138 RVA: 0x001BE768 File Offset: 0x001BC968
	// (set) Token: 0x06006DEB RID: 28139 RVA: 0x001BE786 File Offset: 0x001BC986
	public unsafe static float FLOOR_DISTANCE
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(MoveControllerLegacy.NativeFieldInfoPtr_FLOOR_DISTANCE, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(MoveControllerLegacy.NativeFieldInfoPtr_FLOOR_DISTANCE, (void*)(&value));
		}
	}

	// Token: 0x040048D0 RID: 18640
	private static readonly IntPtr NativeFieldInfoPtr_source;

	// Token: 0x040048D1 RID: 18641
	private static readonly IntPtr NativeFieldInfoPtr_character;

	// Token: 0x040048D2 RID: 18642
	private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

	// Token: 0x040048D3 RID: 18643
	private static readonly IntPtr NativeFieldInfoPtr_g_v3Move;

	// Token: 0x040048D4 RID: 18644
	private static readonly IntPtr NativeFieldInfoPtr_g_v3ForcePush;

	// Token: 0x040048D5 RID: 18645
	private static readonly IntPtr NativeFieldInfoPtr_g_v3Horizontal;

	// Token: 0x040048D6 RID: 18646
	private static readonly IntPtr NativeFieldInfoPtr_g_v3Direction;

	// Token: 0x040048D7 RID: 18647
	private static readonly IntPtr NativeFieldInfoPtr_g_fEnterSpeed;

	// Token: 0x040048D8 RID: 18648
	private static readonly IntPtr NativeFieldInfoPtr_g_fSpeed;

	// Token: 0x040048D9 RID: 18649
	private static readonly IntPtr NativeFieldInfoPtr_g_fAngle;

	// Token: 0x040048DA RID: 18650
	private static readonly IntPtr NativeFieldInfoPtr_fAngleH;

	// Token: 0x040048DB RID: 18651
	private static readonly IntPtr NativeFieldInfoPtr_g_fDragMove;

	// Token: 0x040048DC RID: 18652
	private static readonly IntPtr NativeFieldInfoPtr_g_fDragRotation;

	// Token: 0x040048DD RID: 18653
	private static readonly IntPtr NativeFieldInfoPtr_g_fGravity;

	// Token: 0x040048DE RID: 18654
	private static readonly IntPtr NativeFieldInfoPtr_g_fJump;

	// Token: 0x040048DF RID: 18655
	private static readonly IntPtr NativeFieldInfoPtr_g_fFall;

	// Token: 0x040048E0 RID: 18656
	private static readonly IntPtr NativeFieldInfoPtr_g_bHeightLand;

	// Token: 0x040048E1 RID: 18657
	private static readonly IntPtr NativeFieldInfoPtr_g_fFloating;

	// Token: 0x040048E2 RID: 18658
	private static readonly IntPtr NativeFieldInfoPtr_g_fFloorDistacne;

	// Token: 0x040048E3 RID: 18659
	private static readonly IntPtr NativeFieldInfoPtr_g_bActionMove;

	// Token: 0x040048E4 RID: 18660
	private static readonly IntPtr NativeFieldInfoPtr_g_v3ActionDirection;

	// Token: 0x040048E5 RID: 18661
	private static readonly IntPtr NativeFieldInfoPtr_g_fActionWaitTime;

	// Token: 0x040048E6 RID: 18662
	private static readonly IntPtr NativeFieldInfoPtr_g_fActionMoveTime;

	// Token: 0x040048E7 RID: 18663
	private static readonly IntPtr NativeFieldInfoPtr_g_fActionMoveSpeed;

	// Token: 0x040048E8 RID: 18664
	private static readonly IntPtr NativeFieldInfoPtr_g_ActionTrigger;

	// Token: 0x040048E9 RID: 18665
	private static readonly IntPtr NativeFieldInfoPtr_g_bActionLerpRotation;

	// Token: 0x040048EA RID: 18666
	private static readonly IntPtr NativeFieldInfoPtr_g_ActionTarget;

	// Token: 0x040048EB RID: 18667
	private static readonly IntPtr NativeFieldInfoPtr_g_v3FloorPoint;

	// Token: 0x040048EC RID: 18668
	private static readonly IntPtr NativeFieldInfoPtr_g_bIsSky;

	// Token: 0x040048ED RID: 18669
	private static readonly IntPtr NativeFieldInfoPtr_g_BePush;

	// Token: 0x040048EE RID: 18670
	private static readonly IntPtr NativeFieldInfoPtr_enableCalculate;

	// Token: 0x040048EF RID: 18671
	private static readonly IntPtr NativeFieldInfoPtr_hitLayer;

	// Token: 0x040048F0 RID: 18672
	private static readonly IntPtr NativeFieldInfoPtr_characterLayer;

	// Token: 0x040048F1 RID: 18673
	private static readonly IntPtr NativeFieldInfoPtr_pushLayer;

	// Token: 0x040048F2 RID: 18674
	private static readonly IntPtr NativeFieldInfoPtr_specialObjectLayer;

	// Token: 0x040048F3 RID: 18675
	private static readonly IntPtr NativeFieldInfoPtr_FLOOR_DISTANCE;

	// Token: 0x040048F4 RID: 18676
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0;

	// Token: 0x040048F5 RID: 18677
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_Transform_0;

	// Token: 0x040048F6 RID: 18678
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_Single_0;

	// Token: 0x040048F7 RID: 18679
	private static readonly IntPtr NativeMethodInfoPtr_ActionMove_Private_Void_0;

	// Token: 0x040048F8 RID: 18680
	private static readonly IntPtr NativeMethodInfoPtr_ActionRotate_Private_Void_Vector3_0;

	// Token: 0x040048F9 RID: 18681
	private static readonly IntPtr NativeMethodInfoPtr_CalculateSpeed_Private_Void_0;

	// Token: 0x040048FA RID: 18682
	private static readonly IntPtr NativeMethodInfoPtr_DetectGround_Private_Void_0;

	// Token: 0x040048FB RID: 18683
	private static readonly IntPtr NativeMethodInfoPtr_CalculateGravity_Private_Void_0;

	// Token: 0x040048FC RID: 18684
	private static readonly IntPtr NativeMethodInfoPtr_Push_Public_Void_0;

	// Token: 0x040048FD RID: 18685
	private static readonly IntPtr NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x040048FE RID: 18686
	private static readonly IntPtr NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x040048FF RID: 18687
	private static readonly IntPtr NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0;

	// Token: 0x04004900 RID: 18688
	private static readonly IntPtr NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0;

	// Token: 0x04004901 RID: 18689
	private static readonly IntPtr NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0;

	// Token: 0x04004902 RID: 18690
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0;

	// Token: 0x04004903 RID: 18691
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0;

	// Token: 0x04004904 RID: 18692
	private static readonly IntPtr NativeMethodInfoPtr_CancelActionMove_Public_Void_0;

	// Token: 0x04004905 RID: 18693
	private static readonly IntPtr NativeMethodInfoPtr_Jump_Public_Void_Single_0;

	// Token: 0x04004906 RID: 18694
	private static readonly IntPtr NativeMethodInfoPtr_Stop_Public_Void_0;

	// Token: 0x04004907 RID: 18695
	private static readonly IntPtr NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0;

	// Token: 0x04004908 RID: 18696
	private static readonly IntPtr NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0;

	// Token: 0x04004909 RID: 18697
	private static readonly IntPtr NativeMethodInfoPtr_GetAimAngle_Public_Single_0;

	// Token: 0x0400490A RID: 18698
	private static readonly IntPtr NativeMethodInfoPtr_GetAngle_Public_Single_0;

	// Token: 0x0400490B RID: 18699
	private static readonly IntPtr NativeMethodInfoPtr_SetGravity_Public_Void_Single_0;

	// Token: 0x0400490C RID: 18700
	private static readonly IntPtr NativeMethodInfoPtr_SetFall_Public_Void_Single_0;

	// Token: 0x0400490D RID: 18701
	private static readonly IntPtr NativeMethodInfoPtr_GetJump_Public_Single_0;

	// Token: 0x0400490E RID: 18702
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxFall_Public_Single_0;

	// Token: 0x0400490F RID: 18703
	private static readonly IntPtr NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0;

	// Token: 0x04004910 RID: 18704
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0;

	// Token: 0x04004911 RID: 18705
	private static readonly IntPtr NativeMethodInfoPtr_SetFloating_Public_Void_Single_0;

	// Token: 0x04004912 RID: 18706
	private static readonly IntPtr NativeMethodInfoPtr_GetFloating_Public_Single_0;

	// Token: 0x04004913 RID: 18707
	private static readonly IntPtr NativeMethodInfoPtr_GetMove_Public_Vector3_0;

	// Token: 0x04004914 RID: 18708
	private static readonly IntPtr NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0;

	// Token: 0x04004915 RID: 18709
	private static readonly IntPtr NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0;

	// Token: 0x04004916 RID: 18710
	private static readonly IntPtr NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0;

	// Token: 0x04004917 RID: 18711
	private static readonly IntPtr NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_Transform_0;

	// Token: 0x04004918 RID: 18712
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorDistance_Public_Single_0;

	// Token: 0x04004919 RID: 18713
	private static readonly IntPtr NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0;

	// Token: 0x0400491A RID: 18714
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}
