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

// Token: 0x020000BB RID: 187
[Serializable]
public class MoveController : Il2CppSystem.Object
{
	// Token: 0x1700064D RID: 1613
	// (get) Token: 0x060014B4 RID: 5300 RVA: 0x00059DD4 File Offset: 0x00057FD4
	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: 0x060014B5 RID: 5301 RVA: 0x00059E24 File Offset: 0x00058024
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 509652, RefRangeEnd = 509657, XrefRangeStart = 509595, XrefRangeEnd = 509652, 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: 0x060014B6 RID: 5302 RVA: 0x00059E80 File Offset: 0x00058080
	[CallerCount(7)]
	[CachedScanResults(RefRangeStart = 509678, RefRangeEnd = 509685, XrefRangeStart = 509657, XrefRangeEnd = 509678, 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: 0x060014B7 RID: 5303 RVA: 0x00059ED4 File Offset: 0x000580D4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509698, RefRangeEnd = 509699, XrefRangeStart = 509685, XrefRangeEnd = 509698, 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: 0x060014B8 RID: 5304 RVA: 0x00059F18 File Offset: 0x00058118
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509702, RefRangeEnd = 509704, XrefRangeStart = 509699, XrefRangeEnd = 509702, 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: 0x060014B9 RID: 5305 RVA: 0x00059F6C File Offset: 0x0005816C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 509704, XrefRangeEnd = 509707, 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: 0x060014BA RID: 5306 RVA: 0x00059FB0 File Offset: 0x000581B0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 509707, XrefRangeEnd = 509708, 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: 0x060014BB RID: 5307 RVA: 0x00059FF4 File Offset: 0x000581F4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509759, RefRangeEnd = 509760, XrefRangeStart = 509708, XrefRangeEnd = 509759, 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: 0x060014BC RID: 5308 RVA: 0x0005A038 File Offset: 0x00058238
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 509760, XrefRangeEnd = 509762, 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: 0x060014BD RID: 5309 RVA: 0x0005A08C File Offset: 0x0005828C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 509762, XrefRangeEnd = 509767, 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: 0x060014BE RID: 5310 RVA: 0x0005A0DC File Offset: 0x000582DC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 509811, RefRangeEnd = 509812, XrefRangeStart = 509767, XrefRangeEnd = 509811, 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: 0x060014BF RID: 5311 RVA: 0x0005A120 File Offset: 0x00058320
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 509816, RefRangeEnd = 509818, XrefRangeStart = 509812, XrefRangeEnd = 509816, 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: 0x060014C0 RID: 5312 RVA: 0x0005A188 File Offset: 0x00058388
	[CallerCount(67)]
	[CachedScanResults(RefRangeStart = 509821, RefRangeEnd = 509888, XrefRangeStart = 509818, XrefRangeEnd = 509821, 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: 0x060014C1 RID: 5313 RVA: 0x0005A204 File Offset: 0x00058404
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 509896, RefRangeEnd = 509906, XrefRangeStart = 509888, XrefRangeEnd = 509896, 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: 0x060014C2 RID: 5314 RVA: 0x0005A280 File Offset: 0x00058480
	[CallerCount(210)]
	[CachedScanResults(RefRangeStart = 509910, RefRangeEnd = 510120, XrefRangeStart = 509906, XrefRangeEnd = 509910, 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: 0x060014C3 RID: 5315 RVA: 0x0005A2D4 File Offset: 0x000584D4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 510120, XrefRangeEnd = 510126, 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: 0x060014C4 RID: 5316 RVA: 0x0005A328 File Offset: 0x00058528
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 510129, RefRangeEnd = 510134, XrefRangeStart = 510126, XrefRangeEnd = 510129, 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: 0x060014C5 RID: 5317 RVA: 0x0005A37C File Offset: 0x0005857C
	[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: 0x060014C6 RID: 5318 RVA: 0x0005A3D0 File Offset: 0x000585D0
	[CallerCount(91)]
	[CachedScanResults(RefRangeStart = 510134, RefRangeEnd = 510225, XrefRangeStart = 510134, XrefRangeEnd = 510134, 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: 0x060014C7 RID: 5319 RVA: 0x0005A424 File Offset: 0x00058624
	[CallerCount(144)]
	[CachedScanResults(RefRangeStart = 510225, RefRangeEnd = 510369, XrefRangeStart = 510225, XrefRangeEnd = 510225, 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: 0x060014C8 RID: 5320 RVA: 0x0005A478 File Offset: 0x00058678
	[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: 0x060014C9 RID: 5321 RVA: 0x0005A4C8 File Offset: 0x000586C8
	[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: 0x060014CA RID: 5322 RVA: 0x0005A518 File Offset: 0x00058718
	[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: 0x060014CB RID: 5323 RVA: 0x0005A568 File Offset: 0x00058768
	[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: 0x060014CC RID: 5324 RVA: 0x0005A5B8 File Offset: 0x000587B8
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 510369, RefRangeEnd = 510374, XrefRangeStart = 510369, XrefRangeEnd = 510369, 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: 0x060014CD RID: 5325 RVA: 0x0005A5FC File Offset: 0x000587FC
	[CallerCount(178)]
	[CachedScanResults(RefRangeStart = 510375, RefRangeEnd = 510553, XrefRangeStart = 510374, XrefRangeEnd = 510375, 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: 0x060014CE RID: 5326 RVA: 0x0005A6B0 File Offset: 0x000588B0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 510553, XrefRangeEnd = 510556, 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: 0x060014CF RID: 5327 RVA: 0x0005A758 File Offset: 0x00058958
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 510556, RefRangeEnd = 510559, XrefRangeStart = 510556, XrefRangeEnd = 510556, 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: 0x060014D0 RID: 5328 RVA: 0x0005A79C File Offset: 0x0005899C
	[CallerCount(25)]
	[CachedScanResults(RefRangeStart = 510559, RefRangeEnd = 510584, XrefRangeStart = 510559, XrefRangeEnd = 510559, 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: 0x060014D1 RID: 5329 RVA: 0x0005A7F0 File Offset: 0x000589F0
	[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: 0x060014D2 RID: 5330 RVA: 0x0005A840 File Offset: 0x00058A40
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 510584, RefRangeEnd = 510589, XrefRangeStart = 510584, XrefRangeEnd = 510584, 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: 0x060014D3 RID: 5331 RVA: 0x0005A894 File Offset: 0x00058A94
	[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: 0x060014D4 RID: 5332 RVA: 0x0005A8E4 File Offset: 0x00058AE4
	[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: 0x060014D5 RID: 5333 RVA: 0x0005A938 File Offset: 0x00058B38
	[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: 0x060014D6 RID: 5334 RVA: 0x0005A988 File Offset: 0x00058B88
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 510589, RefRangeEnd = 510592, XrefRangeStart = 510589, XrefRangeEnd = 510589, 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: 0x060014D7 RID: 5335 RVA: 0x0005A9D8 File Offset: 0x00058BD8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 510605, RefRangeEnd = 510606, XrefRangeStart = 510592, XrefRangeEnd = 510605, 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: 0x060014D8 RID: 5336 RVA: 0x0005AA28 File Offset: 0x00058C28
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 510616, RefRangeEnd = 510625, XrefRangeStart = 510606, XrefRangeEnd = 510616, 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: 0x060014D9 RID: 5337 RVA: 0x0005AA78 File Offset: 0x00058C78
	[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: 0x060014DA RID: 5338 RVA: 0x0005AACC File Offset: 0x00058CCC
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 510633, RefRangeEnd = 510637, XrefRangeStart = 510625, XrefRangeEnd = 510633, 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: 0x060014DB RID: 5339 RVA: 0x0005AB28 File Offset: 0x00058D28
	[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: 0x060014DC RID: 5340 RVA: 0x0005AB7C File Offset: 0x00058D7C
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 7527, RefRangeEnd = 7537, XrefRangeStart = 7527, XrefRangeEnd = 7537, 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: 0x060014DD RID: 5341 RVA: 0x0005ABD4 File Offset: 0x00058DD4
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 510642, RefRangeEnd = 510645, XrefRangeStart = 510637, XrefRangeEnd = 510642, 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: 0x060014DE RID: 5342 RVA: 0x0005AC20 File Offset: 0x00058E20
	// 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, 100665274);
		MoveController.NativeMethodInfoPtr_Init_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665275);
		MoveController.NativeMethodInfoPtr_Update_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665276);
		MoveController.NativeMethodInfoPtr_CalculateActionMove_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665277);
		MoveController.NativeMethodInfoPtr_CalculateActionRotate_Private_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665278);
		MoveController.NativeMethodInfoPtr_CalculateMovement_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665279);
		MoveController.NativeMethodInfoPtr_CalculateGravity_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665280);
		MoveController.NativeMethodInfoPtr_CalculateSlideForce_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665281);
		MoveController.NativeMethodInfoPtr_StartSliding_Private_Void_RaycastHit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665282);
		MoveController.NativeMethodInfoPtr_IsBottomCenterGrounded_Private_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665283);
		MoveController.NativeMethodInfoPtr_CalculatePushForce_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665284);
		MoveController.NativeMethodInfoPtr_GetPushDirection_Private_Vector3_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665285);
		MoveController.NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665286);
		MoveController.NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665287);
		MoveController.NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665288);
		MoveController.NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665289);
		MoveController.NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665290);
		MoveController.NativeMethodInfoPtr_SetGravity_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665291);
		MoveController.NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665292);
		MoveController.NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665293);
		MoveController.NativeMethodInfoPtr_GetMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665294);
		MoveController.NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665295);
		MoveController.NativeMethodInfoPtr_GetAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665296);
		MoveController.NativeMethodInfoPtr_GetAimAngle_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665297);
		MoveController.NativeMethodInfoPtr_Stop_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665298);
		MoveController.NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665299);
		MoveController.NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665300);
		MoveController.NativeMethodInfoPtr_CancelActionMove_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665301);
		MoveController.NativeMethodInfoPtr_Jump_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665302);
		MoveController.NativeMethodInfoPtr_GetJump_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665303);
		MoveController.NativeMethodInfoPtr_SetFloating_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665304);
		MoveController.NativeMethodInfoPtr_GetFloating_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665305);
		MoveController.NativeMethodInfoPtr_SetFall_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665306);
		MoveController.NativeMethodInfoPtr_GetMaxFall_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665307);
		MoveController.NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665308);
		MoveController.NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665309);
		MoveController.NativeMethodInfoPtr_GetFloorDistance_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665310);
		MoveController.NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665311);
		MoveController.NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_DamageObject_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665312);
		MoveController.NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665313);
		MoveController.NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665314);
		MoveController.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<MoveController>.NativeClassPtr, 100665315);
	}

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

	// Token: 0x17000626 RID: 1574
	// (get) Token: 0x060014E0 RID: 5344 RVA: 0x0005B2A4 File Offset: 0x000594A4
	// (set) Token: 0x060014E1 RID: 5345 RVA: 0x0005B2D8 File Offset: 0x000594D8
	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: 0x17000627 RID: 1575
	// (get) Token: 0x060014E2 RID: 5346 RVA: 0x0005B300 File Offset: 0x00059500
	// (set) Token: 0x060014E3 RID: 5347 RVA: 0x0005B334 File Offset: 0x00059534
	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: 0x17000628 RID: 1576
	// (get) Token: 0x060014E4 RID: 5348 RVA: 0x0005B35C File Offset: 0x0005955C
	// (set) Token: 0x060014E5 RID: 5349 RVA: 0x0005B384 File Offset: 0x00059584
	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: 0x17000629 RID: 1577
	// (get) Token: 0x060014E6 RID: 5350 RVA: 0x0005B3A8 File Offset: 0x000595A8
	// (set) Token: 0x060014E7 RID: 5351 RVA: 0x0005B3D0 File Offset: 0x000595D0
	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: 0x1700062A RID: 1578
	// (get) Token: 0x060014E8 RID: 5352 RVA: 0x0005B3F4 File Offset: 0x000595F4
	// (set) Token: 0x060014E9 RID: 5353 RVA: 0x0005B41C File Offset: 0x0005961C
	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: 0x1700062B RID: 1579
	// (get) Token: 0x060014EA RID: 5354 RVA: 0x0005B440 File Offset: 0x00059640
	// (set) Token: 0x060014EB RID: 5355 RVA: 0x0005B468 File Offset: 0x00059668
	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: 0x1700062C RID: 1580
	// (get) Token: 0x060014EC RID: 5356 RVA: 0x0005B48C File Offset: 0x0005968C
	// (set) Token: 0x060014ED RID: 5357 RVA: 0x0005B4B4 File Offset: 0x000596B4
	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: 0x1700062D RID: 1581
	// (get) Token: 0x060014EE RID: 5358 RVA: 0x0005B4D8 File Offset: 0x000596D8
	// (set) Token: 0x060014EF RID: 5359 RVA: 0x0005B500 File Offset: 0x00059700
	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: 0x1700062E RID: 1582
	// (get) Token: 0x060014F0 RID: 5360 RVA: 0x0005B524 File Offset: 0x00059724
	// (set) Token: 0x060014F1 RID: 5361 RVA: 0x0005B54C File Offset: 0x0005974C
	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: 0x1700062F RID: 1583
	// (get) Token: 0x060014F2 RID: 5362 RVA: 0x0005B570 File Offset: 0x00059770
	// (set) Token: 0x060014F3 RID: 5363 RVA: 0x0005B598 File Offset: 0x00059798
	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: 0x17000630 RID: 1584
	// (get) Token: 0x060014F4 RID: 5364 RVA: 0x0005B5BC File Offset: 0x000597BC
	// (set) Token: 0x060014F5 RID: 5365 RVA: 0x0005B5E4 File Offset: 0x000597E4
	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: 0x17000631 RID: 1585
	// (get) Token: 0x060014F6 RID: 5366 RVA: 0x0005B608 File Offset: 0x00059808
	// (set) Token: 0x060014F7 RID: 5367 RVA: 0x0005B630 File Offset: 0x00059830
	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: 0x17000632 RID: 1586
	// (get) Token: 0x060014F8 RID: 5368 RVA: 0x0005B654 File Offset: 0x00059854
	// (set) Token: 0x060014F9 RID: 5369 RVA: 0x0005B67C File Offset: 0x0005987C
	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: 0x17000633 RID: 1587
	// (get) Token: 0x060014FA RID: 5370 RVA: 0x0005B6A0 File Offset: 0x000598A0
	// (set) Token: 0x060014FB RID: 5371 RVA: 0x0005B6C8 File Offset: 0x000598C8
	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: 0x17000634 RID: 1588
	// (get) Token: 0x060014FC RID: 5372 RVA: 0x0005B6EC File Offset: 0x000598EC
	// (set) Token: 0x060014FD RID: 5373 RVA: 0x0005B714 File Offset: 0x00059914
	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: 0x17000635 RID: 1589
	// (get) Token: 0x060014FE RID: 5374 RVA: 0x0005B738 File Offset: 0x00059938
	// (set) Token: 0x060014FF RID: 5375 RVA: 0x0005B760 File Offset: 0x00059960
	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: 0x17000636 RID: 1590
	// (get) Token: 0x06001500 RID: 5376 RVA: 0x0005B784 File Offset: 0x00059984
	// (set) Token: 0x06001501 RID: 5377 RVA: 0x0005B7B8 File Offset: 0x000599B8
	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: 0x17000637 RID: 1591
	// (get) Token: 0x06001502 RID: 5378 RVA: 0x0005B7E0 File Offset: 0x000599E0
	// (set) Token: 0x06001503 RID: 5379 RVA: 0x0005B808 File Offset: 0x00059A08
	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: 0x17000638 RID: 1592
	// (get) Token: 0x06001504 RID: 5380 RVA: 0x0005B82C File Offset: 0x00059A2C
	// (set) Token: 0x06001505 RID: 5381 RVA: 0x0005B854 File Offset: 0x00059A54
	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: 0x17000639 RID: 1593
	// (get) Token: 0x06001506 RID: 5382 RVA: 0x0005B878 File Offset: 0x00059A78
	// (set) Token: 0x06001507 RID: 5383 RVA: 0x0005B8A0 File Offset: 0x00059AA0
	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: 0x1700063A RID: 1594
	// (get) Token: 0x06001508 RID: 5384 RVA: 0x0005B8C4 File Offset: 0x00059AC4
	// (set) Token: 0x06001509 RID: 5385 RVA: 0x0005B8EC File Offset: 0x00059AEC
	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: 0x1700063B RID: 1595
	// (get) Token: 0x0600150A RID: 5386 RVA: 0x0005B910 File Offset: 0x00059B10
	// (set) Token: 0x0600150B RID: 5387 RVA: 0x0005B938 File Offset: 0x00059B38
	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: 0x1700063C RID: 1596
	// (get) Token: 0x0600150C RID: 5388 RVA: 0x0005B95C File Offset: 0x00059B5C
	// (set) Token: 0x0600150D RID: 5389 RVA: 0x0005B984 File Offset: 0x00059B84
	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: 0x1700063D RID: 1597
	// (get) Token: 0x0600150E RID: 5390 RVA: 0x0005B9A8 File Offset: 0x00059BA8
	// (set) Token: 0x0600150F RID: 5391 RVA: 0x0005B9D0 File Offset: 0x00059BD0
	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: 0x1700063E RID: 1598
	// (get) Token: 0x06001510 RID: 5392 RVA: 0x0005B9F4 File Offset: 0x00059BF4
	// (set) Token: 0x06001511 RID: 5393 RVA: 0x0005BA1C File Offset: 0x00059C1C
	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: 0x1700063F RID: 1599
	// (get) Token: 0x06001512 RID: 5394 RVA: 0x0005BA40 File Offset: 0x00059C40
	// (set) Token: 0x06001513 RID: 5395 RVA: 0x0005BA68 File Offset: 0x00059C68
	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: 0x17000640 RID: 1600
	// (get) Token: 0x06001514 RID: 5396 RVA: 0x0005BA8C File Offset: 0x00059C8C
	// (set) Token: 0x06001515 RID: 5397 RVA: 0x0005BAB4 File Offset: 0x00059CB4
	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: 0x17000641 RID: 1601
	// (get) Token: 0x06001516 RID: 5398 RVA: 0x0005BAD8 File Offset: 0x00059CD8
	// (set) Token: 0x06001517 RID: 5399 RVA: 0x0005BB00 File Offset: 0x00059D00
	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: 0x17000642 RID: 1602
	// (get) Token: 0x06001518 RID: 5400 RVA: 0x0005BB24 File Offset: 0x00059D24
	// (set) Token: 0x06001519 RID: 5401 RVA: 0x0005BB4C File Offset: 0x00059D4C
	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: 0x17000643 RID: 1603
	// (get) Token: 0x0600151A RID: 5402 RVA: 0x0005BB70 File Offset: 0x00059D70
	// (set) Token: 0x0600151B RID: 5403 RVA: 0x0005BBA4 File Offset: 0x00059DA4
	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: 0x17000644 RID: 1604
	// (get) Token: 0x0600151C RID: 5404 RVA: 0x0005BBCC File Offset: 0x00059DCC
	// (set) Token: 0x0600151D RID: 5405 RVA: 0x0005BBF4 File Offset: 0x00059DF4
	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: 0x17000645 RID: 1605
	// (get) Token: 0x0600151E RID: 5406 RVA: 0x0005BC18 File Offset: 0x00059E18
	// (set) Token: 0x0600151F RID: 5407 RVA: 0x0005BC40 File Offset: 0x00059E40
	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: 0x17000646 RID: 1606
	// (get) Token: 0x06001520 RID: 5408 RVA: 0x0005BC64 File Offset: 0x00059E64
	// (set) Token: 0x06001521 RID: 5409 RVA: 0x0005BC98 File Offset: 0x00059E98
	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: 0x17000647 RID: 1607
	// (get) Token: 0x06001522 RID: 5410 RVA: 0x0005BCC0 File Offset: 0x00059EC0
	// (set) Token: 0x06001523 RID: 5411 RVA: 0x0005BCE8 File Offset: 0x00059EE8
	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: 0x17000648 RID: 1608
	// (get) Token: 0x06001524 RID: 5412 RVA: 0x0005BD0C File Offset: 0x00059F0C
	// (set) Token: 0x06001525 RID: 5413 RVA: 0x0005BD34 File Offset: 0x00059F34
	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: 0x17000649 RID: 1609
	// (get) Token: 0x06001526 RID: 5414 RVA: 0x0005BD58 File Offset: 0x00059F58
	// (set) Token: 0x06001527 RID: 5415 RVA: 0x0005BD80 File Offset: 0x00059F80
	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: 0x1700064A RID: 1610
	// (get) Token: 0x06001528 RID: 5416 RVA: 0x0005BDA4 File Offset: 0x00059FA4
	// (set) Token: 0x06001529 RID: 5417 RVA: 0x0005BDC2 File Offset: 0x00059FC2
	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: 0x1700064B RID: 1611
	// (get) Token: 0x0600152A RID: 5418 RVA: 0x0005BDD4 File Offset: 0x00059FD4
	// (set) Token: 0x0600152B RID: 5419 RVA: 0x0005BDFC File Offset: 0x00059FFC
	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: 0x1700064C RID: 1612
	// (get) Token: 0x0600152C RID: 5420 RVA: 0x0005BE20 File Offset: 0x0005A020
	// (set) Token: 0x0600152D RID: 5421 RVA: 0x0005BE48 File Offset: 0x0005A048
	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: 0x0400103A RID: 4154
	private static readonly IntPtr NativeFieldInfoPtr_source;

	// Token: 0x0400103B RID: 4155
	private static readonly IntPtr NativeFieldInfoPtr_controller;

	// Token: 0x0400103C RID: 4156
	private static readonly IntPtr NativeFieldInfoPtr_speedDragFactor;

	// Token: 0x0400103D RID: 4157
	private static readonly IntPtr NativeFieldInfoPtr_rotationDragFactor;

	// Token: 0x0400103E RID: 4158
	private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

	// Token: 0x0400103F RID: 4159
	private static readonly IntPtr NativeFieldInfoPtr_inputDirection;

	// Token: 0x04001040 RID: 4160
	private static readonly IntPtr NativeFieldInfoPtr_inputSpeed;

	// Token: 0x04001041 RID: 4161
	private static readonly IntPtr NativeFieldInfoPtr_movement;

	// Token: 0x04001042 RID: 4162
	private static readonly IntPtr NativeFieldInfoPtr_movementXZ;

	// Token: 0x04001043 RID: 4163
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeed;

	// Token: 0x04001044 RID: 4164
	private static readonly IntPtr NativeFieldInfoPtr_rotationAngle;

	// Token: 0x04001045 RID: 4165
	private static readonly IntPtr NativeFieldInfoPtr_isGrounded;

	// Token: 0x04001046 RID: 4166
	private static readonly IntPtr NativeFieldInfoPtr_isSky;

	// Token: 0x04001047 RID: 4167
	private static readonly IntPtr NativeFieldInfoPtr_verticalForce;

	// Token: 0x04001048 RID: 4168
	private static readonly IntPtr NativeFieldInfoPtr_floatingTimer;

	// Token: 0x04001049 RID: 4169
	private static readonly IntPtr NativeFieldInfoPtr_isActionMove;

	// Token: 0x0400104A RID: 4170
	private static readonly IntPtr NativeFieldInfoPtr_actionTarget;

	// Token: 0x0400104B RID: 4171
	private static readonly IntPtr NativeFieldInfoPtr_actionDirection;

	// Token: 0x0400104C RID: 4172
	private static readonly IntPtr NativeFieldInfoPtr_actionTrigger;

	// Token: 0x0400104D RID: 4173
	private static readonly IntPtr NativeFieldInfoPtr_actionDelayTimer;

	// Token: 0x0400104E RID: 4174
	private static readonly IntPtr NativeFieldInfoPtr_actionMoveTimer;

	// Token: 0x0400104F RID: 4175
	private static readonly IntPtr NativeFieldInfoPtr_actionMoveSpeed;

	// Token: 0x04001050 RID: 4176
	private static readonly IntPtr NativeFieldInfoPtr_actionRotationLerp;

	// Token: 0x04001051 RID: 4177
	private static readonly IntPtr NativeFieldInfoPtr_isSliding;

	// Token: 0x04001052 RID: 4178
	private static readonly IntPtr NativeFieldInfoPtr_sideWallFixed;

	// Token: 0x04001053 RID: 4179
	private static readonly IntPtr NativeFieldInfoPtr_lastMovementForce;

	// Token: 0x04001054 RID: 4180
	private static readonly IntPtr NativeFieldInfoPtr_slideForce;

	// Token: 0x04001055 RID: 4181
	private static readonly IntPtr NativeFieldInfoPtr_pushForce;

	// Token: 0x04001056 RID: 4182
	private static readonly IntPtr NativeFieldInfoPtr_lastPushAmount;

	// Token: 0x04001057 RID: 4183
	private static readonly IntPtr NativeFieldInfoPtr_pushTargets;

	// Token: 0x04001058 RID: 4184
	private static readonly IntPtr NativeFieldInfoPtr_hitLayer;

	// Token: 0x04001059 RID: 4185
	private static readonly IntPtr NativeFieldInfoPtr_pushLayer;

	// Token: 0x0400105A RID: 4186
	private static readonly IntPtr NativeFieldInfoPtr_npcSelf;

	// Token: 0x0400105B RID: 4187
	private static readonly IntPtr NativeFieldInfoPtr_gravity;

	// Token: 0x0400105C RID: 4188
	private static readonly IntPtr NativeFieldInfoPtr_fallSpeedMax;

	// Token: 0x0400105D RID: 4189
	private static readonly IntPtr NativeFieldInfoPtr_enableCalculate;

	// Token: 0x0400105E RID: 4190
	private static readonly IntPtr NativeFieldInfoPtr_HIT_GROUND_RADIUS;

	// Token: 0x0400105F RID: 4191
	private static readonly IntPtr NativeFieldInfoPtr_IsCenterSky;

	// Token: 0x04001060 RID: 4192
	private static readonly IntPtr NativeFieldInfoPtr_IsOverEnemy;

	// Token: 0x04001061 RID: 4193
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0;

	// Token: 0x04001062 RID: 4194
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_Transform_0;

	// Token: 0x04001063 RID: 4195
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_Single_0;

	// Token: 0x04001064 RID: 4196
	private static readonly IntPtr NativeMethodInfoPtr_CalculateActionMove_Private_Void_0;

	// Token: 0x04001065 RID: 4197
	private static readonly IntPtr NativeMethodInfoPtr_CalculateActionRotate_Private_Void_Vector3_0;

	// Token: 0x04001066 RID: 4198
	private static readonly IntPtr NativeMethodInfoPtr_CalculateMovement_Private_Void_0;

	// Token: 0x04001067 RID: 4199
	private static readonly IntPtr NativeMethodInfoPtr_CalculateGravity_Private_Void_0;

	// Token: 0x04001068 RID: 4200
	private static readonly IntPtr NativeMethodInfoPtr_CalculateSlideForce_Private_Void_0;

	// Token: 0x04001069 RID: 4201
	private static readonly IntPtr NativeMethodInfoPtr_StartSliding_Private_Void_RaycastHit_0;

	// Token: 0x0400106A RID: 4202
	private static readonly IntPtr NativeMethodInfoPtr_IsBottomCenterGrounded_Private_Boolean_0;

	// Token: 0x0400106B RID: 4203
	private static readonly IntPtr NativeMethodInfoPtr_CalculatePushForce_Private_Void_0;

	// Token: 0x0400106C RID: 4204
	private static readonly IntPtr NativeMethodInfoPtr_GetPushDirection_Private_Vector3_Transform_0;

	// Token: 0x0400106D RID: 4205
	private static readonly IntPtr NativeMethodInfoPtr_Move_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x0400106E RID: 4206
	private static readonly IntPtr NativeMethodInfoPtr_MoveVertical_Public_Void_Vector3_Single_Vector3_0;

	// Token: 0x0400106F RID: 4207
	private static readonly IntPtr NativeMethodInfoPtr_LookAt_Public_Void_Vector3_0;

	// Token: 0x04001070 RID: 4208
	private static readonly IntPtr NativeMethodInfoPtr_LookAtVertical_Public_Void_Vector3_0;

	// Token: 0x04001071 RID: 4209
	private static readonly IntPtr NativeMethodInfoPtr_Rotate_Public_Void_Vector3_0;

	// Token: 0x04001072 RID: 4210
	private static readonly IntPtr NativeMethodInfoPtr_SetGravity_Public_Void_Single_0;

	// Token: 0x04001073 RID: 4211
	private static readonly IntPtr NativeMethodInfoPtr_SetDragMove_Public_Void_Single_0;

	// Token: 0x04001074 RID: 4212
	private static readonly IntPtr NativeMethodInfoPtr_SetDragRotation_Public_Void_Single_0;

	// Token: 0x04001075 RID: 4213
	private static readonly IntPtr NativeMethodInfoPtr_GetMove_Public_Vector3_0;

	// Token: 0x04001076 RID: 4214
	private static readonly IntPtr NativeMethodInfoPtr_GetHorizontalMove_Public_Vector3_0;

	// Token: 0x04001077 RID: 4215
	private static readonly IntPtr NativeMethodInfoPtr_GetAngle_Public_Single_0;

	// Token: 0x04001078 RID: 4216
	private static readonly IntPtr NativeMethodInfoPtr_GetAimAngle_Public_Single_0;

	// Token: 0x04001079 RID: 4217
	private static readonly IntPtr NativeMethodInfoPtr_Stop_Public_Void_0;

	// Token: 0x0400107A RID: 4218
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Vector3_Single_Single_Single_Vector3_Boolean_0;

	// Token: 0x0400107B RID: 4219
	private static readonly IntPtr NativeMethodInfoPtr_SetActionMove_Public_Void_Transform_Single_Single_Single_Boolean_0;

	// Token: 0x0400107C RID: 4220
	private static readonly IntPtr NativeMethodInfoPtr_CancelActionMove_Public_Void_0;

	// Token: 0x0400107D RID: 4221
	private static readonly IntPtr NativeMethodInfoPtr_Jump_Public_Void_Single_0;

	// Token: 0x0400107E RID: 4222
	private static readonly IntPtr NativeMethodInfoPtr_GetJump_Public_Single_0;

	// Token: 0x0400107F RID: 4223
	private static readonly IntPtr NativeMethodInfoPtr_SetFloating_Public_Void_Single_0;

	// Token: 0x04001080 RID: 4224
	private static readonly IntPtr NativeMethodInfoPtr_GetFloating_Public_Single_0;

	// Token: 0x04001081 RID: 4225
	private static readonly IntPtr NativeMethodInfoPtr_SetFall_Public_Void_Single_0;

	// Token: 0x04001082 RID: 4226
	private static readonly IntPtr NativeMethodInfoPtr_GetMaxFall_Public_Single_0;

	// Token: 0x04001083 RID: 4227
	private static readonly IntPtr NativeMethodInfoPtr_GetHeightLand_Public_Boolean_0;

	// Token: 0x04001084 RID: 4228
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorPoint_Public_Vector3_0;

	// Token: 0x04001085 RID: 4229
	private static readonly IntPtr NativeMethodInfoPtr_GetFloorDistance_Public_Single_0;

	// Token: 0x04001086 RID: 4230
	private static readonly IntPtr NativeMethodInfoPtr_SetForcePush_Public_Void_Vector3_0;

	// Token: 0x04001087 RID: 4231
	private static readonly IntPtr NativeMethodInfoPtr_ProcessPushTarget_Public_Void_Action_1_DamageObject_0;

	// Token: 0x04001088 RID: 4232
	private static readonly IntPtr NativeMethodInfoPtr_EnableCalculate_Public_Void_Boolean_0;

	// Token: 0x04001089 RID: 4233
	private static readonly IntPtr NativeMethodInfoPtr_GetCharacterController_Public_CharacterController_0;

	// Token: 0x0400108A RID: 4234
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}
