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

// Token: 0x020000A5 RID: 165
[Serializable]
public class MoveController : Il2CppSystem.Object
{
	// Token: 0x17000603 RID: 1539
	// (get) Token: 0x06001358 RID: 4952 RVA: 0x00053DD0 File Offset: 0x00051FD0
	public unsafe bool IsSky
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06001359 RID: 4953 RVA: 0x00053E20 File Offset: 0x00052020
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 503881, RefRangeEnd = 503886, XrefRangeStart = 503824, XrefRangeEnd = 503881, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Init(Transform source)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Init_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600135A RID: 4954 RVA: 0x00053E7C File Offset: 0x0005207C
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 503907, RefRangeEnd = 503914, XrefRangeStart = 503886, XrefRangeEnd = 503907, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Update(float deltaTime)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref deltaTime;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Update_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600135B RID: 4955 RVA: 0x00053ED0 File Offset: 0x000520D0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503927, RefRangeEnd = 503928, XrefRangeStart = 503914, XrefRangeEnd = 503927, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateActionMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateActionMove_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600135C RID: 4956 RVA: 0x00053F14 File Offset: 0x00052114
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 503931, RefRangeEnd = 503933, XrefRangeStart = 503928, XrefRangeEnd = 503931, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateActionRotate(Vector3 direction)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref direction;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateActionRotate_Private_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600135D RID: 4957 RVA: 0x00053F68 File Offset: 0x00052168
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 503933, XrefRangeEnd = 503936, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateMovement()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateMovement_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600135E RID: 4958 RVA: 0x00053FAC File Offset: 0x000521AC
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 503936, XrefRangeEnd = 503937, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateGravity()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateGravity_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600135F RID: 4959 RVA: 0x00053FF0 File Offset: 0x000521F0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 503988, RefRangeEnd = 503989, XrefRangeStart = 503937, XrefRangeEnd = 503988, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculateSlideForce()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculateSlideForce_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

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

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

	// Token: 0x06001362 RID: 4962 RVA: 0x000540D8 File Offset: 0x000522D8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 504040, RefRangeEnd = 504041, XrefRangeStart = 503996, XrefRangeEnd = 504040, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CalculatePushForce()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CalculatePushForce_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

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

	// Token: 0x06001364 RID: 4964 RVA: 0x00054184 File Offset: 0x00052384
	[CallerCount(59)]
	[CachedScanResults(RefRangeStart = 504050, RefRangeEnd = 504109, XrefRangeStart = 504047, XrefRangeEnd = 504050, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Move(Vector3 inputDirection, float inputSpeed, Vector3 lookAtDirection)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref inputDirection;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref inputSpeed;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lookAtDirection;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

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

	// Token: 0x06001366 RID: 4966 RVA: 0x0005427C File Offset: 0x0005247C
	[CallerCount(193)]
	[CachedScanResults(RefRangeStart = 504129, RefRangeEnd = 504322, XrefRangeStart = 504125, XrefRangeEnd = 504129, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void LookAt(Vector3 lookAtDirection)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref lookAtDirection;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

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

	// Token: 0x06001368 RID: 4968 RVA: 0x00054324 File Offset: 0x00052524
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 504331, RefRangeEnd = 504336, XrefRangeStart = 504328, XrefRangeEnd = 504331, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Rotate(Vector3 v3Direction)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref v3Direction;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

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

	// Token: 0x0600136A RID: 4970 RVA: 0x000543CC File Offset: 0x000525CC
	[CallerCount(76)]
	[CachedScanResults(RefRangeStart = 504336, RefRangeEnd = 504412, XrefRangeStart = 504336, XrefRangeEnd = 504336, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetDragMove(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600136B RID: 4971 RVA: 0x00054420 File Offset: 0x00052620
	[CallerCount(103)]
	[CachedScanResults(RefRangeStart = 504412, RefRangeEnd = 504515, XrefRangeStart = 504412, XrefRangeEnd = 504412, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetDragRotation(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

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

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

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

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

	// Token: 0x06001370 RID: 4976 RVA: 0x000545B4 File Offset: 0x000527B4
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 504515, RefRangeEnd = 504520, XrefRangeStart = 504515, XrefRangeEnd = 504515, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Stop()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Stop_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

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

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

	// Token: 0x06001373 RID: 4979 RVA: 0x00054754 File Offset: 0x00052954
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 504678, RefRangeEnd = 504680, XrefRangeStart = 504678, XrefRangeEnd = 504678, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void CancelActionMove()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_CancelActionMove_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06001374 RID: 4980 RVA: 0x00054798 File Offset: 0x00052998
	[CallerCount(21)]
	[CachedScanResults(RefRangeStart = 504680, RefRangeEnd = 504701, XrefRangeStart = 504680, XrefRangeEnd = 504680, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Jump(float force)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref force;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_Jump_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

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

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

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

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

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

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

	// Token: 0x0600137B RID: 4987 RVA: 0x000549D4 File Offset: 0x00052BD4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 504722, RefRangeEnd = 504723, XrefRangeStart = 504709, XrefRangeEnd = 504722, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Vector3 GetFloorPoint()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x0600137C RID: 4988 RVA: 0x00054A24 File Offset: 0x00052C24
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 504733, RefRangeEnd = 504740, XrefRangeStart = 504723, XrefRangeEnd = 504733, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe float GetFloorDistance()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr_GetFloorDistance_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

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

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

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

	// Token: 0x06001380 RID: 4992 RVA: 0x00054B78 File Offset: 0x00052D78
	[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(MoveController.NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new CharacterController(intPtr3) : null;
	}

	// Token: 0x06001381 RID: 4993 RVA: 0x00054BD0 File Offset: 0x00052DD0
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 504757, RefRangeEnd = 504760, XrefRangeStart = 504752, XrefRangeEnd = 504757, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe MoveController()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<MoveController>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(MoveController.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

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

	// Token: 0x06001383 RID: 4995 RVA: 0x0000A74C File Offset: 0x0000894C
	public MoveController(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x170005DC RID: 1500
	// (get) Token: 0x06001384 RID: 4996 RVA: 0x000552A0 File Offset: 0x000534A0
	// (set) Token: 0x06001385 RID: 4997 RVA: 0x000552D4 File Offset: 0x000534D4
	public unsafe Transform source
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_source);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Transform(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_source), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005DD RID: 1501
	// (get) Token: 0x06001386 RID: 4998 RVA: 0x000552FC File Offset: 0x000534FC
	// (set) Token: 0x06001387 RID: 4999 RVA: 0x00055330 File Offset: 0x00053530
	public unsafe CharacterController controller
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_controller);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new CharacterController(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_controller), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005DE RID: 1502
	// (get) Token: 0x06001388 RID: 5000 RVA: 0x00055358 File Offset: 0x00053558
	// (set) Token: 0x06001389 RID: 5001 RVA: 0x00055380 File Offset: 0x00053580
	public unsafe float speedDragFactor
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_speedDragFactor);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_speedDragFactor)) = value;
		}
	}

	// Token: 0x170005DF RID: 1503
	// (get) Token: 0x0600138A RID: 5002 RVA: 0x000553A4 File Offset: 0x000535A4
	// (set) Token: 0x0600138B RID: 5003 RVA: 0x000553CC File Offset: 0x000535CC
	public unsafe float rotationDragFactor
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationDragFactor);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationDragFactor)) = value;
		}
	}

	// Token: 0x170005E0 RID: 1504
	// (get) Token: 0x0600138C RID: 5004 RVA: 0x000553F0 File Offset: 0x000535F0
	// (set) Token: 0x0600138D RID: 5005 RVA: 0x00055418 File Offset: 0x00053618
	public unsafe float deltaTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_deltaTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_deltaTime)) = value;
		}
	}

	// Token: 0x170005E1 RID: 1505
	// (get) Token: 0x0600138E RID: 5006 RVA: 0x0005543C File Offset: 0x0005363C
	// (set) Token: 0x0600138F RID: 5007 RVA: 0x00055464 File Offset: 0x00053664
	public unsafe Vector3 inputDirection
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputDirection);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputDirection)) = value;
		}
	}

	// Token: 0x170005E2 RID: 1506
	// (get) Token: 0x06001390 RID: 5008 RVA: 0x00055488 File Offset: 0x00053688
	// (set) Token: 0x06001391 RID: 5009 RVA: 0x000554B0 File Offset: 0x000536B0
	public unsafe float inputSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_inputSpeed)) = value;
		}
	}

	// Token: 0x170005E3 RID: 1507
	// (get) Token: 0x06001392 RID: 5010 RVA: 0x000554D4 File Offset: 0x000536D4
	// (set) Token: 0x06001393 RID: 5011 RVA: 0x000554FC File Offset: 0x000536FC
	public unsafe Vector3 movement
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movement);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movement)) = value;
		}
	}

	// Token: 0x170005E4 RID: 1508
	// (get) Token: 0x06001394 RID: 5012 RVA: 0x00055520 File Offset: 0x00053720
	// (set) Token: 0x06001395 RID: 5013 RVA: 0x00055548 File Offset: 0x00053748
	public unsafe Vector3 movementXZ
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movementXZ);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_movementXZ)) = value;
		}
	}

	// Token: 0x170005E5 RID: 1509
	// (get) Token: 0x06001396 RID: 5014 RVA: 0x0005556C File Offset: 0x0005376C
	// (set) Token: 0x06001397 RID: 5015 RVA: 0x00055594 File Offset: 0x00053794
	public unsafe float moveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_moveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_moveSpeed)) = value;
		}
	}

	// Token: 0x170005E6 RID: 1510
	// (get) Token: 0x06001398 RID: 5016 RVA: 0x000555B8 File Offset: 0x000537B8
	// (set) Token: 0x06001399 RID: 5017 RVA: 0x000555E0 File Offset: 0x000537E0
	public unsafe float rotationAngle
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationAngle);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_rotationAngle)) = value;
		}
	}

	// Token: 0x170005E7 RID: 1511
	// (get) Token: 0x0600139A RID: 5018 RVA: 0x00055604 File Offset: 0x00053804
	// (set) Token: 0x0600139B RID: 5019 RVA: 0x0005562C File Offset: 0x0005382C
	public unsafe bool isGrounded
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isGrounded);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isGrounded)) = value;
		}
	}

	// Token: 0x170005E8 RID: 1512
	// (get) Token: 0x0600139C RID: 5020 RVA: 0x00055650 File Offset: 0x00053850
	// (set) Token: 0x0600139D RID: 5021 RVA: 0x00055678 File Offset: 0x00053878
	public unsafe bool isSky
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSky);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSky)) = value;
		}
	}

	// Token: 0x170005E9 RID: 1513
	// (get) Token: 0x0600139E RID: 5022 RVA: 0x0005569C File Offset: 0x0005389C
	// (set) Token: 0x0600139F RID: 5023 RVA: 0x000556C4 File Offset: 0x000538C4
	public unsafe float verticalForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_verticalForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_verticalForce)) = value;
		}
	}

	// Token: 0x170005EA RID: 1514
	// (get) Token: 0x060013A0 RID: 5024 RVA: 0x000556E8 File Offset: 0x000538E8
	// (set) Token: 0x060013A1 RID: 5025 RVA: 0x00055710 File Offset: 0x00053910
	public unsafe float floatingTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_floatingTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_floatingTimer)) = value;
		}
	}

	// Token: 0x170005EB RID: 1515
	// (get) Token: 0x060013A2 RID: 5026 RVA: 0x00055734 File Offset: 0x00053934
	// (set) Token: 0x060013A3 RID: 5027 RVA: 0x0005575C File Offset: 0x0005395C
	public unsafe bool isActionMove
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isActionMove);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isActionMove)) = value;
		}
	}

	// Token: 0x170005EC RID: 1516
	// (get) Token: 0x060013A4 RID: 5028 RVA: 0x00055780 File Offset: 0x00053980
	// (set) Token: 0x060013A5 RID: 5029 RVA: 0x000557B4 File Offset: 0x000539B4
	public unsafe Transform actionTarget
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTarget);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Transform(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTarget), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005ED RID: 1517
	// (get) Token: 0x060013A6 RID: 5030 RVA: 0x000557DC File Offset: 0x000539DC
	// (set) Token: 0x060013A7 RID: 5031 RVA: 0x00055804 File Offset: 0x00053A04
	public unsafe Vector3 actionDirection
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDirection);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDirection)) = value;
		}
	}

	// Token: 0x170005EE RID: 1518
	// (get) Token: 0x060013A8 RID: 5032 RVA: 0x00055828 File Offset: 0x00053A28
	// (set) Token: 0x060013A9 RID: 5033 RVA: 0x00055850 File Offset: 0x00053A50
	public unsafe Vector3 actionTrigger
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTrigger);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionTrigger)) = value;
		}
	}

	// Token: 0x170005EF RID: 1519
	// (get) Token: 0x060013AA RID: 5034 RVA: 0x00055874 File Offset: 0x00053A74
	// (set) Token: 0x060013AB RID: 5035 RVA: 0x0005589C File Offset: 0x00053A9C
	public unsafe float actionDelayTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDelayTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionDelayTimer)) = value;
		}
	}

	// Token: 0x170005F0 RID: 1520
	// (get) Token: 0x060013AC RID: 5036 RVA: 0x000558C0 File Offset: 0x00053AC0
	// (set) Token: 0x060013AD RID: 5037 RVA: 0x000558E8 File Offset: 0x00053AE8
	public unsafe float actionMoveTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveTimer)) = value;
		}
	}

	// Token: 0x170005F1 RID: 1521
	// (get) Token: 0x060013AE RID: 5038 RVA: 0x0005590C File Offset: 0x00053B0C
	// (set) Token: 0x060013AF RID: 5039 RVA: 0x00055934 File Offset: 0x00053B34
	public unsafe float actionMoveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionMoveSpeed)) = value;
		}
	}

	// Token: 0x170005F2 RID: 1522
	// (get) Token: 0x060013B0 RID: 5040 RVA: 0x00055958 File Offset: 0x00053B58
	// (set) Token: 0x060013B1 RID: 5041 RVA: 0x00055980 File Offset: 0x00053B80
	public unsafe bool actionRotationLerp
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionRotationLerp);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_actionRotationLerp)) = value;
		}
	}

	// Token: 0x170005F3 RID: 1523
	// (get) Token: 0x060013B2 RID: 5042 RVA: 0x000559A4 File Offset: 0x00053BA4
	// (set) Token: 0x060013B3 RID: 5043 RVA: 0x000559CC File Offset: 0x00053BCC
	public unsafe bool isSliding
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSliding);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_isSliding)) = value;
		}
	}

	// Token: 0x170005F4 RID: 1524
	// (get) Token: 0x060013B4 RID: 5044 RVA: 0x000559F0 File Offset: 0x00053BF0
	// (set) Token: 0x060013B5 RID: 5045 RVA: 0x00055A18 File Offset: 0x00053C18
	public unsafe bool sideWallFixed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_sideWallFixed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_sideWallFixed)) = value;
		}
	}

	// Token: 0x170005F5 RID: 1525
	// (get) Token: 0x060013B6 RID: 5046 RVA: 0x00055A3C File Offset: 0x00053C3C
	// (set) Token: 0x060013B7 RID: 5047 RVA: 0x00055A64 File Offset: 0x00053C64
	public unsafe Vector3 lastMovementForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastMovementForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastMovementForce)) = value;
		}
	}

	// Token: 0x170005F6 RID: 1526
	// (get) Token: 0x060013B8 RID: 5048 RVA: 0x00055A88 File Offset: 0x00053C88
	// (set) Token: 0x060013B9 RID: 5049 RVA: 0x00055AB0 File Offset: 0x00053CB0
	public unsafe Vector3 slideForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_slideForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_slideForce)) = value;
		}
	}

	// Token: 0x170005F7 RID: 1527
	// (get) Token: 0x060013BA RID: 5050 RVA: 0x00055AD4 File Offset: 0x00053CD4
	// (set) Token: 0x060013BB RID: 5051 RVA: 0x00055AFC File Offset: 0x00053CFC
	public unsafe Vector3 pushForce
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushForce);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushForce)) = value;
		}
	}

	// Token: 0x170005F8 RID: 1528
	// (get) Token: 0x060013BC RID: 5052 RVA: 0x00055B20 File Offset: 0x00053D20
	// (set) Token: 0x060013BD RID: 5053 RVA: 0x00055B48 File Offset: 0x00053D48
	public unsafe int lastPushAmount
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastPushAmount);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_lastPushAmount)) = value;
		}
	}

	// Token: 0x170005F9 RID: 1529
	// (get) Token: 0x060013BE RID: 5054 RVA: 0x00055B6C File Offset: 0x00053D6C
	// (set) Token: 0x060013BF RID: 5055 RVA: 0x00055BA0 File Offset: 0x00053DA0
	public unsafe Il2CppReferenceArray<DamageObject> pushTargets
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushTargets);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Il2CppReferenceArray<DamageObject>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushTargets), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005FA RID: 1530
	// (get) Token: 0x060013C0 RID: 5056 RVA: 0x00055BC8 File Offset: 0x00053DC8
	// (set) Token: 0x060013C1 RID: 5057 RVA: 0x00055BF0 File Offset: 0x00053DF0
	public unsafe LayerMask hitLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_hitLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_hitLayer)) = value;
		}
	}

	// Token: 0x170005FB RID: 1531
	// (get) Token: 0x060013C2 RID: 5058 RVA: 0x00055C14 File Offset: 0x00053E14
	// (set) Token: 0x060013C3 RID: 5059 RVA: 0x00055C3C File Offset: 0x00053E3C
	public unsafe LayerMask pushLayer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushLayer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_pushLayer)) = value;
		}
	}

	// Token: 0x170005FC RID: 1532
	// (get) Token: 0x060013C4 RID: 5060 RVA: 0x00055C60 File Offset: 0x00053E60
	// (set) Token: 0x060013C5 RID: 5061 RVA: 0x00055C94 File Offset: 0x00053E94
	public unsafe NPCManage npcSelf
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_npcSelf);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new NPCManage(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_npcSelf), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170005FD RID: 1533
	// (get) Token: 0x060013C6 RID: 5062 RVA: 0x00055CBC File Offset: 0x00053EBC
	// (set) Token: 0x060013C7 RID: 5063 RVA: 0x00055CE4 File Offset: 0x00053EE4
	public unsafe float gravity
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_gravity);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_gravity)) = value;
		}
	}

	// Token: 0x170005FE RID: 1534
	// (get) Token: 0x060013C8 RID: 5064 RVA: 0x00055D08 File Offset: 0x00053F08
	// (set) Token: 0x060013C9 RID: 5065 RVA: 0x00055D30 File Offset: 0x00053F30
	public unsafe float fallSpeedMax
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_fallSpeedMax);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_fallSpeedMax)) = value;
		}
	}

	// Token: 0x170005FF RID: 1535
	// (get) Token: 0x060013CA RID: 5066 RVA: 0x00055D54 File Offset: 0x00053F54
	// (set) Token: 0x060013CB RID: 5067 RVA: 0x00055D7C File Offset: 0x00053F7C
	public unsafe bool enableCalculate
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_enableCalculate);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_enableCalculate)) = value;
		}
	}

	// Token: 0x17000600 RID: 1536
	// (get) Token: 0x060013CC RID: 5068 RVA: 0x00055DA0 File Offset: 0x00053FA0
	// (set) Token: 0x060013CD RID: 5069 RVA: 0x00055DBE File Offset: 0x00053FBE
	public unsafe static float HIT_GROUND_RADIUS
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(MoveController.NativeFieldInfoPtr_HIT_GROUND_RADIUS, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(MoveController.NativeFieldInfoPtr_HIT_GROUND_RADIUS, (void*)(&value));
		}
	}

	// Token: 0x17000601 RID: 1537
	// (get) Token: 0x060013CE RID: 5070 RVA: 0x00055DD0 File Offset: 0x00053FD0
	// (set) Token: 0x060013CF RID: 5071 RVA: 0x00055DF8 File Offset: 0x00053FF8
	public unsafe bool IsCenterSky
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_IsCenterSky);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_IsCenterSky)) = value;
		}
	}

	// Token: 0x17000602 RID: 1538
	// (get) Token: 0x060013D0 RID: 5072 RVA: 0x00055E1C File Offset: 0x0005401C
	// (set) Token: 0x060013D1 RID: 5073 RVA: 0x00055E44 File Offset: 0x00054044
	public unsafe bool IsOverEnemy
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_IsOverEnemy);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(MoveController.NativeFieldInfoPtr_IsOverEnemy)) = value;
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// Token: 0x04000F7A RID: 3962
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0;

	// Token: 0x04000F7B RID: 3963
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0;

	// Token: 0x04000F7C RID: 3964
	private static readonly IntPtr NativeMethodInfoPtr_CancelActionMove_Public_Void_0;

	// Token: 0x04000F7D RID: 3965
	private static readonly IntPtr NativeMethodInfoPtr_Jump_Public_Void_Single_0;

	// Token: 0x04000F7E RID: 3966
	private static readonly IntPtr NativeMethodInfoPtr_GetJump_Public_Single_0;

	// Token: 0x04000F7F RID: 3967
	private static readonly IntPtr NativeMethodInfoPtr_SetFloating_Public_Void_Single_0;

	// Token: 0x04000F80 RID: 3968
	private static readonly IntPtr NativeMethodInfoPtr_GetFloating_Public_Single_0;

	// Token: 0x04000F81 RID: 3969
	private static readonly IntPtr NativeMethodInfoPtr_SetFall_Public_Void_Single_0;

	// Token: 0x04000F82 RID: 3970
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxFall_Public_Single_0;

	// Token: 0x04000F83 RID: 3971
	private static readonly IntPtr NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0;

	// Token: 0x04000F84 RID: 3972
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0;

	// Token: 0x04000F85 RID: 3973
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorDistance_Public_Single_0;

	// Token: 0x04000F86 RID: 3974
	private static readonly IntPtr NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0;

	// Token: 0x04000F87 RID: 3975
	private static readonly IntPtr NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_DamageObject_0;

	// Token: 0x04000F88 RID: 3976
	private static readonly IntPtr NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0;

	// Token: 0x04000F89 RID: 3977
	private static readonly IntPtr NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0;

	// Token: 0x04000F8A RID: 3978
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}