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

// Token: 0x0200032E RID: 814
[Serializable]
public class MoveControllerLegacy : Il2CppSystem.Object
{
	// Token: 0x1700263F RID: 9791
	// (get) Token: 0x06006E2B RID: 28203 RVA: 0x001BF588 File Offset: 0x001BD788
	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: 0x06006E2C RID: 28204 RVA: 0x001BF5D8 File Offset: 0x001BD7D8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600694, XrefRangeEnd = 600728, 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: 0x06006E2D RID: 28205 RVA: 0x001BF634 File Offset: 0x001BD834
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600728, XrefRangeEnd = 600746, 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: 0x06006E2E RID: 28206 RVA: 0x001BF688 File Offset: 0x001BD888
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 600759, RefRangeEnd = 600760, XrefRangeStart = 600746, XrefRangeEnd = 600759, 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: 0x06006E2F RID: 28207 RVA: 0x001BF6CC File Offset: 0x001BD8CC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 600763, RefRangeEnd = 600764, XrefRangeStart = 600760, XrefRangeEnd = 600763, 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: 0x06006E30 RID: 28208 RVA: 0x001BF720 File Offset: 0x001BD920
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600764, XrefRangeEnd = 600767, 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: 0x06006E31 RID: 28209 RVA: 0x001BF764 File Offset: 0x001BD964
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 600863, RefRangeEnd = 600864, XrefRangeStart = 600767, XrefRangeEnd = 600863, 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: 0x06006E32 RID: 28210 RVA: 0x001BF7A8 File Offset: 0x001BD9A8
	[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: 0x06006E33 RID: 28211 RVA: 0x001BF7EC File Offset: 0x001BD9EC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 600887, RefRangeEnd = 600888, XrefRangeStart = 600864, XrefRangeEnd = 600887, 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: 0x06006E34 RID: 28212 RVA: 0x001BF830 File Offset: 0x001BDA30
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600888, XrefRangeEnd = 600893, 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: 0x06006E35 RID: 28213 RVA: 0x001BF8AC File Offset: 0x001BDAAC
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600893, XrefRangeEnd = 600901, 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: 0x06006E36 RID: 28214 RVA: 0x001BF928 File Offset: 0x001BDB28
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600901, XrefRangeEnd = 600904, 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: 0x06006E37 RID: 28215 RVA: 0x001BF97C File Offset: 0x001BDB7C
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 504331, RefRangeEnd = 504336, XrefRangeStart = 504331, XrefRangeEnd = 504336, 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: 0x06006E38 RID: 28216 RVA: 0x001BF9D0 File Offset: 0x001BDBD0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600904, XrefRangeEnd = 600910, 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: 0x06006E39 RID: 28217 RVA: 0x001BFA24 File Offset: 0x001BDC24
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600910, XrefRangeEnd = 600911, 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: 0x06006E3A RID: 28218 RVA: 0x001BFAD8 File Offset: 0x001BDCD8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600911, XrefRangeEnd = 600913, 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: 0x06006E3B RID: 28219 RVA: 0x001BFB80 File Offset: 0x001BDD80
	[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: 0x06006E3C RID: 28220 RVA: 0x001BFBC4 File Offset: 0x001BDDC4
	[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: 0x06006E3D RID: 28221 RVA: 0x001BFC18 File Offset: 0x001BDE18
	[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: 0x06006E3E RID: 28222 RVA: 0x001BFC5C File Offset: 0x001BDE5C
	[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: 0x06006E3F RID: 28223 RVA: 0x001BFCB0 File Offset: 0x001BDEB0
	[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: 0x06006E40 RID: 28224 RVA: 0x001BFD04 File Offset: 0x001BDF04
	[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: 0x06006E41 RID: 28225 RVA: 0x001BFD54 File Offset: 0x001BDF54
	[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: 0x06006E42 RID: 28226 RVA: 0x001BFDA4 File Offset: 0x001BDFA4
	[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: 0x06006E43 RID: 28227 RVA: 0x001BFDF8 File Offset: 0x001BDFF8
	[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: 0x06006E44 RID: 28228 RVA: 0x001BFE4C File Offset: 0x001BE04C
	[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: 0x06006E45 RID: 28229 RVA: 0x001BFE9C File Offset: 0x001BE09C
	[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: 0x06006E46 RID: 28230 RVA: 0x001BFEEC File Offset: 0x001BE0EC
	[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: 0x06006E47 RID: 28231 RVA: 0x001BFF3C File Offset: 0x001BE13C
	[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: 0x06006E48 RID: 28232 RVA: 0x001BFF8C File Offset: 0x001BE18C
	[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: 0x06006E49 RID: 28233 RVA: 0x001BFFE0 File Offset: 0x001BE1E0
	[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: 0x06006E4A RID: 28234 RVA: 0x001C0030 File Offset: 0x001BE230
	[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: 0x06006E4B RID: 28235 RVA: 0x001C0080 File Offset: 0x001BE280
	[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: 0x06006E4C RID: 28236 RVA: 0x001C00D0 File Offset: 0x001BE2D0
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 7455, RefRangeEnd = 7465, XrefRangeStart = 7455, XrefRangeEnd = 7465, 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: 0x06006E4D RID: 28237 RVA: 0x001C0128 File Offset: 0x001BE328
	[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: 0x06006E4E RID: 28238 RVA: 0x001C017C File Offset: 0x001BE37C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600913, XrefRangeEnd = 600920, 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: 0x06006E4F RID: 28239 RVA: 0x001C01D8 File Offset: 0x001BE3D8
	[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: 0x06006E50 RID: 28240 RVA: 0x001C0228 File Offset: 0x001BE428
	[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: 0x06006E51 RID: 28241 RVA: 0x001C027C File Offset: 0x001BE47C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600920, XrefRangeEnd = 600923, 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: 0x06006E52 RID: 28242 RVA: 0x001C02C8 File Offset: 0x001BE4C8
	// 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, 100671463);
		MoveControllerLegacy.NativeMethodInfoPtr_Init_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671464);
		MoveControllerLegacy.NativeMethodInfoPtr_Update_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671465);
		MoveControllerLegacy.NativeMethodInfoPtr_ActionMove_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671466);
		MoveControllerLegacy.NativeMethodInfoPtr_ActionRotate_Private_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671467);
		MoveControllerLegacy.NativeMethodInfoPtr_CalculateSpeed_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671468);
		MoveControllerLegacy.NativeMethodInfoPtr_DetectGround_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671469);
		MoveControllerLegacy.NativeMethodInfoPtr_CalculateGravity_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671470);
		MoveControllerLegacy.NativeMethodInfoPtr_Push_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671471);
		MoveControllerLegacy.NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671472);
		MoveControllerLegacy.NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671473);
		MoveControllerLegacy.NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671474);
		MoveControllerLegacy.NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671475);
		MoveControllerLegacy.NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671476);
		MoveControllerLegacy.NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671477);
		MoveControllerLegacy.NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671478);
		MoveControllerLegacy.NativeMethodInfoPtr_CancelActionMove_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671479);
		MoveControllerLegacy.NativeMethodInfoPtr_Jump_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671480);
		MoveControllerLegacy.NativeMethodInfoPtr_Stop_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671481);
		MoveControllerLegacy.NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671482);
		MoveControllerLegacy.NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671483);
		MoveControllerLegacy.NativeMethodInfoPtr_GetAimAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671484);
		MoveControllerLegacy.NativeMethodInfoPtr_GetAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671485);
		MoveControllerLegacy.NativeMethodInfoPtr_SetGravity_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671486);
		MoveControllerLegacy.NativeMethodInfoPtr_SetFall_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671487);
		MoveControllerLegacy.NativeMethodInfoPtr_GetJump_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671488);
		MoveControllerLegacy.NativeMethodInfoPtr_GetMaxFall_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671489);
		MoveControllerLegacy.NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671490);
		MoveControllerLegacy.NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671491);
		MoveControllerLegacy.NativeMethodInfoPtr_SetFloating_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671492);
		MoveControllerLegacy.NativeMethodInfoPtr_GetFloating_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671493);
		MoveControllerLegacy.NativeMethodInfoPtr_GetMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671494);
		MoveControllerLegacy.NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671495);
		MoveControllerLegacy.NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671496);
		MoveControllerLegacy.NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671497);
		MoveControllerLegacy.NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671498);
		MoveControllerLegacy.NativeMethodInfoPtr_GetFloorDistance_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671499);
		MoveControllerLegacy.NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671500);
		MoveControllerLegacy.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveControllerLegacy>.NativeClassPtr, 100671501);
	}

	// Token: 0x06006E53 RID: 28243 RVA: 0x0000A74C File Offset: 0x0000894C
	public MoveControllerLegacy(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x1700261B RID: 9755
	// (get) Token: 0x06006E54 RID: 28244 RVA: 0x001C08D4 File Offset: 0x001BEAD4
	// (set) Token: 0x06006E55 RID: 28245 RVA: 0x001C0908 File Offset: 0x001BEB08
	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: 0x1700261C RID: 9756
	// (get) Token: 0x06006E56 RID: 28246 RVA: 0x001C0930 File Offset: 0x001BEB30
	// (set) Token: 0x06006E57 RID: 28247 RVA: 0x001C0964 File Offset: 0x001BEB64
	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: 0x1700261D RID: 9757
	// (get) Token: 0x06006E58 RID: 28248 RVA: 0x001C098C File Offset: 0x001BEB8C
	// (set) Token: 0x06006E59 RID: 28249 RVA: 0x001C09B4 File Offset: 0x001BEBB4
	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: 0x1700261E RID: 9758
	// (get) Token: 0x06006E5A RID: 28250 RVA: 0x001C09D8 File Offset: 0x001BEBD8
	// (set) Token: 0x06006E5B RID: 28251 RVA: 0x001C0A00 File Offset: 0x001BEC00
	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: 0x1700261F RID: 9759
	// (get) Token: 0x06006E5C RID: 28252 RVA: 0x001C0A24 File Offset: 0x001BEC24
	// (set) Token: 0x06006E5D RID: 28253 RVA: 0x001C0A4C File Offset: 0x001BEC4C
	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: 0x17002620 RID: 9760
	// (get) Token: 0x06006E5E RID: 28254 RVA: 0x001C0A70 File Offset: 0x001BEC70
	// (set) Token: 0x06006E5F RID: 28255 RVA: 0x001C0A98 File Offset: 0x001BEC98
	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: 0x17002621 RID: 9761
	// (get) Token: 0x06006E60 RID: 28256 RVA: 0x001C0ABC File Offset: 0x001BECBC
	// (set) Token: 0x06006E61 RID: 28257 RVA: 0x001C0AE4 File Offset: 0x001BECE4
	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: 0x17002622 RID: 9762
	// (get) Token: 0x06006E62 RID: 28258 RVA: 0x001C0B08 File Offset: 0x001BED08
	// (set) Token: 0x06006E63 RID: 28259 RVA: 0x001C0B30 File Offset: 0x001BED30
	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: 0x17002623 RID: 9763
	// (get) Token: 0x06006E64 RID: 28260 RVA: 0x001C0B54 File Offset: 0x001BED54
	// (set) Token: 0x06006E65 RID: 28261 RVA: 0x001C0B7C File Offset: 0x001BED7C
	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: 0x17002624 RID: 9764
	// (get) Token: 0x06006E66 RID: 28262 RVA: 0x001C0BA0 File Offset: 0x001BEDA0
	// (set) Token: 0x06006E67 RID: 28263 RVA: 0x001C0BC8 File Offset: 0x001BEDC8
	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: 0x17002625 RID: 9765
	// (get) Token: 0x06006E68 RID: 28264 RVA: 0x001C0BEC File Offset: 0x001BEDEC
	// (set) Token: 0x06006E69 RID: 28265 RVA: 0x001C0C14 File Offset: 0x001BEE14
	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: 0x17002626 RID: 9766
	// (get) Token: 0x06006E6A RID: 28266 RVA: 0x001C0C38 File Offset: 0x001BEE38
	// (set) Token: 0x06006E6B RID: 28267 RVA: 0x001C0C60 File Offset: 0x001BEE60
	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: 0x17002627 RID: 9767
	// (get) Token: 0x06006E6C RID: 28268 RVA: 0x001C0C84 File Offset: 0x001BEE84
	// (set) Token: 0x06006E6D RID: 28269 RVA: 0x001C0CAC File Offset: 0x001BEEAC
	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: 0x17002628 RID: 9768
	// (get) Token: 0x06006E6E RID: 28270 RVA: 0x001C0CD0 File Offset: 0x001BEED0
	// (set) Token: 0x06006E6F RID: 28271 RVA: 0x001C0CF8 File Offset: 0x001BEEF8
	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: 0x17002629 RID: 9769
	// (get) Token: 0x06006E70 RID: 28272 RVA: 0x001C0D1C File Offset: 0x001BEF1C
	// (set) Token: 0x06006E71 RID: 28273 RVA: 0x001C0D44 File Offset: 0x001BEF44
	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: 0x1700262A RID: 9770
	// (get) Token: 0x06006E72 RID: 28274 RVA: 0x001C0D68 File Offset: 0x001BEF68
	// (set) Token: 0x06006E73 RID: 28275 RVA: 0x001C0D90 File Offset: 0x001BEF90
	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: 0x1700262B RID: 9771
	// (get) Token: 0x06006E74 RID: 28276 RVA: 0x001C0DB4 File Offset: 0x001BEFB4
	// (set) Token: 0x06006E75 RID: 28277 RVA: 0x001C0DDC File Offset: 0x001BEFDC
	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: 0x1700262C RID: 9772
	// (get) Token: 0x06006E76 RID: 28278 RVA: 0x001C0E00 File Offset: 0x001BF000
	// (set) Token: 0x06006E77 RID: 28279 RVA: 0x001C0E28 File Offset: 0x001BF028
	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: 0x1700262D RID: 9773
	// (get) Token: 0x06006E78 RID: 28280 RVA: 0x001C0E4C File Offset: 0x001BF04C
	// (set) Token: 0x06006E79 RID: 28281 RVA: 0x001C0E74 File Offset: 0x001BF074
	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: 0x1700262E RID: 9774
	// (get) Token: 0x06006E7A RID: 28282 RVA: 0x001C0E98 File Offset: 0x001BF098
	// (set) Token: 0x06006E7B RID: 28283 RVA: 0x001C0EC0 File Offset: 0x001BF0C0
	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: 0x1700262F RID: 9775
	// (get) Token: 0x06006E7C RID: 28284 RVA: 0x001C0EE4 File Offset: 0x001BF0E4
	// (set) Token: 0x06006E7D RID: 28285 RVA: 0x001C0F0C File Offset: 0x001BF10C
	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: 0x17002630 RID: 9776
	// (get) Token: 0x06006E7E RID: 28286 RVA: 0x001C0F30 File Offset: 0x001BF130
	// (set) Token: 0x06006E7F RID: 28287 RVA: 0x001C0F58 File Offset: 0x001BF158
	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: 0x17002631 RID: 9777
	// (get) Token: 0x06006E80 RID: 28288 RVA: 0x001C0F7C File Offset: 0x001BF17C
	// (set) Token: 0x06006E81 RID: 28289 RVA: 0x001C0FA4 File Offset: 0x001BF1A4
	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: 0x17002632 RID: 9778
	// (get) Token: 0x06006E82 RID: 28290 RVA: 0x001C0FC8 File Offset: 0x001BF1C8
	// (set) Token: 0x06006E83 RID: 28291 RVA: 0x001C0FF0 File Offset: 0x001BF1F0
	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: 0x17002633 RID: 9779
	// (get) Token: 0x06006E84 RID: 28292 RVA: 0x001C1014 File Offset: 0x001BF214
	// (set) Token: 0x06006E85 RID: 28293 RVA: 0x001C103C File Offset: 0x001BF23C
	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: 0x17002634 RID: 9780
	// (get) Token: 0x06006E86 RID: 28294 RVA: 0x001C1060 File Offset: 0x001BF260
	// (set) Token: 0x06006E87 RID: 28295 RVA: 0x001C1088 File Offset: 0x001BF288
	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: 0x17002635 RID: 9781
	// (get) Token: 0x06006E88 RID: 28296 RVA: 0x001C10AC File Offset: 0x001BF2AC
	// (set) Token: 0x06006E89 RID: 28297 RVA: 0x001C10E0 File Offset: 0x001BF2E0
	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: 0x17002636 RID: 9782
	// (get) Token: 0x06006E8A RID: 28298 RVA: 0x001C1108 File Offset: 0x001BF308
	// (set) Token: 0x06006E8B RID: 28299 RVA: 0x001C1130 File Offset: 0x001BF330
	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: 0x17002637 RID: 9783
	// (get) Token: 0x06006E8C RID: 28300 RVA: 0x001C1154 File Offset: 0x001BF354
	// (set) Token: 0x06006E8D RID: 28301 RVA: 0x001C117C File Offset: 0x001BF37C
	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: 0x17002638 RID: 9784
	// (get) Token: 0x06006E8E RID: 28302 RVA: 0x001C11A0 File Offset: 0x001BF3A0
	// (set) Token: 0x06006E8F RID: 28303 RVA: 0x001C11D4 File Offset: 0x001BF3D4
	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: 0x17002639 RID: 9785
	// (get) Token: 0x06006E90 RID: 28304 RVA: 0x001C11FC File Offset: 0x001BF3FC
	// (set) Token: 0x06006E91 RID: 28305 RVA: 0x001C1224 File Offset: 0x001BF424
	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: 0x1700263A RID: 9786
	// (get) Token: 0x06006E92 RID: 28306 RVA: 0x001C1248 File Offset: 0x001BF448
	// (set) Token: 0x06006E93 RID: 28307 RVA: 0x001C1270 File Offset: 0x001BF470
	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: 0x1700263B RID: 9787
	// (get) Token: 0x06006E94 RID: 28308 RVA: 0x001C1294 File Offset: 0x001BF494
	// (set) Token: 0x06006E95 RID: 28309 RVA: 0x001C12BC File Offset: 0x001BF4BC
	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: 0x1700263C RID: 9788
	// (get) Token: 0x06006E96 RID: 28310 RVA: 0x001C12E0 File Offset: 0x001BF4E0
	// (set) Token: 0x06006E97 RID: 28311 RVA: 0x001C1308 File Offset: 0x001BF508
	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: 0x1700263D RID: 9789
	// (get) Token: 0x06006E98 RID: 28312 RVA: 0x001C132C File Offset: 0x001BF52C
	// (set) Token: 0x06006E99 RID: 28313 RVA: 0x001C1354 File Offset: 0x001BF554
	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: 0x1700263E RID: 9790
	// (get) Token: 0x06006E9A RID: 28314 RVA: 0x001C1378 File Offset: 0x001BF578
	// (set) Token: 0x06006E9B RID: 28315 RVA: 0x001C1396 File Offset: 0x001BF596
	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: 0x04004944 RID: 18756
	private static readonly IntPtr NativeFieldInfoPtr_source;

	// Token: 0x04004945 RID: 18757
	private static readonly IntPtr NativeFieldInfoPtr_character;

	// Token: 0x04004946 RID: 18758
	private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

	// Token: 0x04004947 RID: 18759
	private static readonly IntPtr NativeFieldInfoPtr_g_v3Move;

	// Token: 0x04004948 RID: 18760
	private static readonly IntPtr NativeFieldInfoPtr_g_v3ForcePush;

	// Token: 0x04004949 RID: 18761
	private static readonly IntPtr NativeFieldInfoPtr_g_v3Horizontal;

	// Token: 0x0400494A RID: 18762
	private static readonly IntPtr NativeFieldInfoPtr_g_v3Direction;

	// Token: 0x0400494B RID: 18763
	private static readonly IntPtr NativeFieldInfoPtr_g_fEnterSpeed;

	// Token: 0x0400494C RID: 18764
	private static readonly IntPtr NativeFieldInfoPtr_g_fSpeed;

	// Token: 0x0400494D RID: 18765
	private static readonly IntPtr NativeFieldInfoPtr_g_fAngle;

	// Token: 0x0400494E RID: 18766
	private static readonly IntPtr NativeFieldInfoPtr_fAngleH;

	// Token: 0x0400494F RID: 18767
	private static readonly IntPtr NativeFieldInfoPtr_g_fDragMove;

	// Token: 0x04004950 RID: 18768
	private static readonly IntPtr NativeFieldInfoPtr_g_fDragRotation;

	// Token: 0x04004951 RID: 18769
	private static readonly IntPtr NativeFieldInfoPtr_g_fGravity;

	// Token: 0x04004952 RID: 18770
	private static readonly IntPtr NativeFieldInfoPtr_g_fJump;

	// Token: 0x04004953 RID: 18771
	private static readonly IntPtr NativeFieldInfoPtr_g_fFall;

	// Token: 0x04004954 RID: 18772
	private static readonly IntPtr NativeFieldInfoPtr_g_bHeightLand;

	// Token: 0x04004955 RID: 18773
	private static readonly IntPtr NativeFieldInfoPtr_g_fFloating;

	// Token: 0x04004956 RID: 18774
	private static readonly IntPtr NativeFieldInfoPtr_g_fFloorDistacne;

	// Token: 0x04004957 RID: 18775
	private static readonly IntPtr NativeFieldInfoPtr_g_bActionMove;

	// Token: 0x04004958 RID: 18776
	private static readonly IntPtr NativeFieldInfoPtr_g_v3ActionDirection;

	// Token: 0x04004959 RID: 18777
	private static readonly IntPtr NativeFieldInfoPtr_g_fActionWaitTime;

	// Token: 0x0400495A RID: 18778
	private static readonly IntPtr NativeFieldInfoPtr_g_fActionMoveTime;

	// Token: 0x0400495B RID: 18779
	private static readonly IntPtr NativeFieldInfoPtr_g_fActionMoveSpeed;

	// Token: 0x0400495C RID: 18780
	private static readonly IntPtr NativeFieldInfoPtr_g_ActionTrigger;

	// Token: 0x0400495D RID: 18781
	private static readonly IntPtr NativeFieldInfoPtr_g_bActionLerpRotation;

	// Token: 0x0400495E RID: 18782
	private static readonly IntPtr NativeFieldInfoPtr_g_ActionTarget;

	// Token: 0x0400495F RID: 18783
	private static readonly IntPtr NativeFieldInfoPtr_g_v3FloorPoint;

	// Token: 0x04004960 RID: 18784
	private static readonly IntPtr NativeFieldInfoPtr_g_bIsSky;

	// Token: 0x04004961 RID: 18785
	private static readonly IntPtr NativeFieldInfoPtr_g_BePush;

	// Token: 0x04004962 RID: 18786
	private static readonly IntPtr NativeFieldInfoPtr_enableCalculate;

	// Token: 0x04004963 RID: 18787
	private static readonly IntPtr NativeFieldInfoPtr_hitLayer;

	// Token: 0x04004964 RID: 18788
	private static readonly IntPtr NativeFieldInfoPtr_characterLayer;

	// Token: 0x04004965 RID: 18789
	private static readonly IntPtr NativeFieldInfoPtr_pushLayer;

	// Token: 0x04004966 RID: 18790
	private static readonly IntPtr NativeFieldInfoPtr_specialObjectLayer;

	// Token: 0x04004967 RID: 18791
	private static readonly IntPtr NativeFieldInfoPtr_FLOOR_DISTANCE;

	// Token: 0x04004968 RID: 18792
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0;

	// Token: 0x04004969 RID: 18793
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_Transform_0;

	// Token: 0x0400496A RID: 18794
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_Single_0;

	// Token: 0x0400496B RID: 18795
	private static readonly IntPtr NativeMethodInfoPtr_ActionMove_Private_Void_0;

	// Token: 0x0400496C RID: 18796
	private static readonly IntPtr NativeMethodInfoPtr_ActionRotate_Private_Void_Vector3_0;

	// Token: 0x0400496D RID: 18797
	private static readonly IntPtr NativeMethodInfoPtr_CalculateSpeed_Private_Void_0;

	// Token: 0x0400496E RID: 18798
	private static readonly IntPtr NativeMethodInfoPtr_DetectGround_Private_Void_0;

	// Token: 0x0400496F RID: 18799
	private static readonly IntPtr NativeMethodInfoPtr_CalculateGravity_Private_Void_0;

	// Token: 0x04004970 RID: 18800
	private static readonly IntPtr NativeMethodInfoPtr_Push_Public_Void_0;

	// Token: 0x04004971 RID: 18801
	private static readonly IntPtr NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x04004972 RID: 18802
	private static readonly IntPtr NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x04004973 RID: 18803
	private static readonly IntPtr NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0;

	// Token: 0x04004974 RID: 18804
	private static readonly IntPtr NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0;

	// Token: 0x04004975 RID: 18805
	private static readonly IntPtr NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0;

	// Token: 0x04004976 RID: 18806
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0;

	// Token: 0x04004977 RID: 18807
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0;

	// Token: 0x04004978 RID: 18808
	private static readonly IntPtr NativeMethodInfoPtr_CancelActionMove_Public_Void_0;

	// Token: 0x04004979 RID: 18809
	private static readonly IntPtr NativeMethodInfoPtr_Jump_Public_Void_Single_0;

	// Token: 0x0400497A RID: 18810
	private static readonly IntPtr NativeMethodInfoPtr_Stop_Public_Void_0;

	// Token: 0x0400497B RID: 18811
	private static readonly IntPtr NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0;

	// Token: 0x0400497C RID: 18812
	private static readonly IntPtr NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0;

	// Token: 0x0400497D RID: 18813
	private static readonly IntPtr NativeMethodInfoPtr_GetAimAngle_Public_Single_0;

	// Token: 0x0400497E RID: 18814
	private static readonly IntPtr NativeMethodInfoPtr_GetAngle_Public_Single_0;

	// Token: 0x0400497F RID: 18815
	private static readonly IntPtr NativeMethodInfoPtr_SetGravity_Public_Void_Single_0;

	// Token: 0x04004980 RID: 18816
	private static readonly IntPtr NativeMethodInfoPtr_SetFall_Public_Void_Single_0;

	// Token: 0x04004981 RID: 18817
	private static readonly IntPtr NativeMethodInfoPtr_GetJump_Public_Single_0;

	// Token: 0x04004982 RID: 18818
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxFall_Public_Single_0;

	// Token: 0x04004983 RID: 18819
	private static readonly IntPtr NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0;

	// Token: 0x04004984 RID: 18820
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0;

	// Token: 0x04004985 RID: 18821
	private static readonly IntPtr NativeMethodInfoPtr_SetFloating_Public_Void_Single_0;

	// Token: 0x04004986 RID: 18822
	private static readonly IntPtr NativeMethodInfoPtr_GetFloating_Public_Single_0;

	// Token: 0x04004987 RID: 18823
	private static readonly IntPtr NativeMethodInfoPtr_GetMove_Public_Vector3_0;

	// Token: 0x04004988 RID: 18824
	private static readonly IntPtr NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0;

	// Token: 0x04004989 RID: 18825
	private static readonly IntPtr NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0;

	// Token: 0x0400498A RID: 18826
	private static readonly IntPtr NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0;

	// Token: 0x0400498B RID: 18827
	private static readonly IntPtr NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_Transform_0;

	// Token: 0x0400498C RID: 18828
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorDistance_Public_Single_0;

	// Token: 0x0400498D RID: 18829
	private static readonly IntPtr NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0;

	// Token: 0x0400498E RID: 18830
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}