#pragma once

/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/

// Package: Mover

#include "Basic.hpp"

#include "Mover_classes.hpp"
#include "Mover_parameters.hpp"


SDK_NAMESPACE_START

// Function Mover.AirMovementUtils.ComputeControlledFreeMove
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFreeMoveParams&           InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FProposedMove                    ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FProposedMove UAirMovementUtils::ComputeControlledFreeMove(const struct FFreeMoveParams& InParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AirMovementUtils", "ComputeControlledFreeMove");

	Params::AirMovementUtils_ComputeControlledFreeMove Parms{};

	Parms.InParams = std::move(InParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.AirMovementUtils.IsValidLandingSpot
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   FloorSweepDistance                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFloorCheckResult&               OutFloorResult                                         (Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAirMovementUtils::IsValidLandingSpot(const struct FMovingComponentSet& MovingComps, const struct FVector& Location, const struct FHitResult& Hit, float FloorSweepDistance, float MaxWalkSlopeCosine, struct FFloorCheckResult& OutFloorResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AirMovementUtils", "IsValidLandingSpot");

	Params::AirMovementUtils_IsValidLandingSpot Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Location = std::move(Location);
	Parms.Hit = std::move(Hit);
	Parms.FloorSweepDistance = FloorSweepDistance;
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;
	Parms.OutFloorResult = std::move(OutFloorResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	OutFloorResult = std::move(Parms.OutFloorResult);

	return Parms.ReturnValue;
}


// Function Mover.AirMovementUtils.TestFallingMoveAlongHitSurface
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   OriginalMoveDelta                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationAtHit                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     TargetRotation                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bHandleImpact                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FloorSweepDistance                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      InOutHit                                               (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FFloorCheckResult&               OutFloorResult                                         (Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 InOutMoveRecord                                        (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAirMovementUtils::TestFallingMoveAlongHitSurface(const struct FMovingComponentSet& MovingComps, const struct FVector& OriginalMoveDelta, const struct FVector& LocationAtHit, const struct FQuat& TargetRotation, bool bHandleImpact, float FloorSweepDistance, float MaxWalkSlopeCosine, struct FHitResult& InOutHit, struct FFloorCheckResult& OutFloorResult, struct FMovementRecord& InOutMoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AirMovementUtils", "TestFallingMoveAlongHitSurface");

	Params::AirMovementUtils_TestFallingMoveAlongHitSurface Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.OriginalMoveDelta = std::move(OriginalMoveDelta);
	Parms.LocationAtHit = std::move(LocationAtHit);
	Parms.TargetRotation = std::move(TargetRotation);
	Parms.bHandleImpact = bHandleImpact;
	Parms.FloorSweepDistance = FloorSweepDistance;
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;
	Parms.InOutHit = std::move(InOutHit);
	Parms.OutFloorResult = std::move(OutFloorResult);
	Parms.InOutMoveRecord = std::move(InOutMoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	InOutHit = std::move(Parms.InOutHit);
	OutFloorResult = std::move(Parms.OutFloorResult);
	InOutMoveRecord = std::move(Parms.InOutMoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.AirMovementUtils.TryMoveToFallAlongSurface
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PctOfDeltaToMove                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Normal                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      Hit                                                    (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bHandleImpact                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FloorSweepDistance                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFloorCheckResult&               OutFloorResult                                         (Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 MoveRecord                                             (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAirMovementUtils::TryMoveToFallAlongSurface(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, float PctOfDeltaToMove, const struct FQuat& Rotation, const struct FVector& Normal, struct FHitResult& Hit, bool bHandleImpact, float FloorSweepDistance, float MaxWalkSlopeCosine, struct FFloorCheckResult& OutFloorResult, struct FMovementRecord& MoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AirMovementUtils", "TryMoveToFallAlongSurface");

	Params::AirMovementUtils_TryMoveToFallAlongSurface Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.PctOfDeltaToMove = PctOfDeltaToMove;
	Parms.Rotation = std::move(Rotation);
	Parms.Normal = std::move(Normal);
	Parms.Hit = std::move(Hit);
	Parms.bHandleImpact = bHandleImpact;
	Parms.FloorSweepDistance = FloorSweepDistance;
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;
	Parms.OutFloorResult = std::move(OutFloorResult);
	Parms.MoveRecord = std::move(MoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Hit = std::move(Parms.Hit);
	OutFloorResult = std::move(Parms.OutFloorResult);
	MoveRecord = std::move(Parms.MoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.AddGameplayTag
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TagToAdd                                               (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::AddGameplayTag(const struct FGameplayTag& TagToAdd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "AddGameplayTag");

	Params::MoverComponent_AddGameplayTag Parms{};

	Parms.TagToAdd = std::move(TagToAdd);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.AddGameplayTags
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     TagsToAdd                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UMoverComponent::AddGameplayTags(const struct FGameplayTagContainer& TagsToAdd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "AddGameplayTags");

	Params::MoverComponent_AddGameplayTags Parms{};

	Parms.TagsToAdd = std::move(TagsToAdd);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.AddMovementModeFromClass
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ModeName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UBaseMovementMode>    MovementMode                                           (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBaseMovementMode*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBaseMovementMode* UMoverComponent::AddMovementModeFromClass(class FName ModeName, TSubclassOf<class UBaseMovementMode> MovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "AddMovementModeFromClass");

	Params::MoverComponent_AddMovementModeFromClass Parms{};

	Parms.ModeName = ModeName;
	Parms.MovementMode = MovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.AddMovementModeFromObject
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ModeName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBaseMovementMode*                MovementMode                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::AddMovementModeFromObject(class FName ModeName, class UBaseMovementMode* MovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "AddMovementModeFromObject");

	Params::MoverComponent_AddMovementModeFromObject Parms{};

	Parms.ModeName = ModeName;
	Parms.MovementMode = MovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.BindProcessGeneratedMovement
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// TDelegate<void(const struct FMoverTickStartData& StartState, const struct FMoverTimeStep& TimeStep, struct FProposedMove* OutProposedMove)>ProcessGeneratedMovementEvent                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::BindProcessGeneratedMovement(TDelegate<void(const struct FMoverTickStartData& StartState, const struct FMoverTimeStep& TimeStep, struct FProposedMove* OutProposedMove)> ProcessGeneratedMovementEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "BindProcessGeneratedMovement");

	Params::MoverComponent_BindProcessGeneratedMovement Parms{};

	Parms.ProcessGeneratedMovementEvent = ProcessGeneratedMovementEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.CancelModifierFromHandle
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const struct FMovementModifierHandle&   ModifierHandle                                         (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UMoverComponent::CancelModifierFromHandle(const struct FMovementModifierHandle& ModifierHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "CancelModifierFromHandle");

	Params::MoverComponent_CancelModifierFromHandle Parms{};

	Parms.ModifierHandle = std::move(ModifierHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.GetFutureTrajectory
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   FutureSeconds                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SamplesPerSecond                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FTrajectorySampleInfo>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FTrajectorySampleInfo> UMoverComponent::GetFutureTrajectory(float FutureSeconds, float SamplesPerSecond)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetFutureTrajectory");

	Params::MoverComponent_GetFutureTrajectory Parms{};

	Parms.FutureSeconds = FutureSeconds;
	Parms.SamplesPerSecond = SamplesPerSecond;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetPredictedTrajectory
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const struct FMoverPredictTrajectoryParams&PredictionParams                                       (Parm, NativeAccessSpecifierPublic)
// TArray<struct FTrajectorySampleInfo>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FTrajectorySampleInfo> UMoverComponent::GetPredictedTrajectory(const struct FMoverPredictTrajectoryParams& PredictionParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetPredictedTrajectory");

	Params::MoverComponent_GetPredictedTrajectory Parms{};

	Parms.PredictionParams = std::move(PredictionParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.HandleImpact
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FMoverOnImpactParams*            ImpactParams                                           (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UMoverComponent::HandleImpact(struct FMoverOnImpactParams* ImpactParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "HandleImpact");

	Params::MoverComponent_HandleImpact Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ImpactParams != nullptr)
		*ImpactParams = std::move(Parms.ImpactParams);
}


// Function Mover.MoverComponent.K2_QueueInstantMovementEffect
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            EffectAsRawData                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::K2_QueueInstantMovementEffect(const int32& EffectAsRawData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "K2_QueueInstantMovementEffect");

	Params::MoverComponent_K2_QueueInstantMovementEffect Parms{};

	Parms.EffectAsRawData = EffectAsRawData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.K2_QueueLayeredMove
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            MoveAsRawData                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::K2_QueueLayeredMove(const int32& MoveAsRawData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "K2_QueueLayeredMove");

	Params::MoverComponent_K2_QueueLayeredMove Parms{};

	Parms.MoveAsRawData = MoveAsRawData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.K2_QueueMovementModifier
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            MoveAsRawData                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMovementModifierHandle          ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FMovementModifierHandle UMoverComponent::K2_QueueMovementModifier(const int32& MoveAsRawData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "K2_QueueMovementModifier");

	Params::MoverComponent_K2_QueueMovementModifier Parms{};

	Parms.MoveAsRawData = MoveAsRawData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.OnBeginOverlap
// (Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Other                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UMoverComponent::OnBeginOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "OnBeginOverlap");

	Params::MoverComponent_OnBeginOverlap Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.Other = Other;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.PhysicsVolumeChanged
// (RequiredAPI, Native, Protected)
// Parameters:
// class APhysicsVolume*                   NewVolume                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::PhysicsVolumeChanged(class APhysicsVolume* NewVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "PhysicsVolumeChanged");

	Params::MoverComponent_PhysicsVolumeChanged Parms{};

	Parms.NewVolume = NewVolume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.QueueNextMode
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             DesiredModeName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldReenter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::QueueNextMode(class FName DesiredModeName, bool bShouldReenter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "QueueNextMode");

	Params::MoverComponent_QueueNextMode Parms{};

	Parms.DesiredModeName = DesiredModeName;
	Parms.bShouldReenter = bShouldReenter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.RemoveGameplayTag
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TagToRemove                                            (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::RemoveGameplayTag(const struct FGameplayTag& TagToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "RemoveGameplayTag");

	Params::MoverComponent_RemoveGameplayTag Parms{};

	Parms.TagToRemove = std::move(TagToRemove);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.RemoveGameplayTags
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     TagsToRemove                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UMoverComponent::RemoveGameplayTags(const struct FGameplayTagContainer& TagsToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "RemoveGameplayTags");

	Params::MoverComponent_RemoveGameplayTags Parms{};

	Parms.TagsToRemove = std::move(TagsToRemove);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.RemoveMovementMode
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ModeName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::RemoveMovementMode(class FName ModeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "RemoveMovementMode");

	Params::MoverComponent_RemoveMovementMode Parms{};

	Parms.ModeName = ModeName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.SetBaseVisualComponentTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                ComponentTransform                                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::SetBaseVisualComponentTransform(const struct FTransform& ComponentTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "SetBaseVisualComponentTransform");

	Params::MoverComponent_SetBaseVisualComponentTransform Parms{};

	Parms.ComponentTransform = std::move(ComponentTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.SetGravityOverride
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// bool                                    bOverrideGravity                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   GravityAcceleration                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::SetGravityOverride(bool bOverrideGravity, const struct FVector& GravityAcceleration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "SetGravityOverride");

	Params::MoverComponent_SetGravityOverride Parms{};

	Parms.bOverrideGravity = bOverrideGravity;
	Parms.GravityAcceleration = std::move(GravityAcceleration);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.SetPlanarConstraint
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPlanarConstraint&         InConstraint                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UMoverComponent::SetPlanarConstraint(const struct FPlanarConstraint& InConstraint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "SetPlanarConstraint");

	Params::MoverComponent_SetPlanarConstraint Parms{};

	Parms.InConstraint = std::move(InConstraint);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.SetPrimaryVisualComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  SceneComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::SetPrimaryVisualComponent(class USceneComponent* SceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "SetPrimaryVisualComponent");

	Params::MoverComponent_SetPrimaryVisualComponent Parms{};

	Parms.SceneComponent = SceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.SetUpdatedComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  NewUpdatedComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::SetUpdatedComponent(class USceneComponent* NewUpdatedComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "SetUpdatedComponent");

	Params::MoverComponent_SetUpdatedComponent Parms{};

	Parms.NewUpdatedComponent = NewUpdatedComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.SetUseDeferredGroupMovement
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::SetUseDeferredGroupMovement(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "SetUseDeferredGroupMovement");

	Params::MoverComponent_SetUseDeferredGroupMovement Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.UnbindProcessGeneratedMovement
// (Final, RequiredAPI, Native, Public, BlueprintCallable)

void UMoverComponent::UnbindProcessGeneratedMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "UnbindProcessGeneratedMovement");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverComponent.FindMovementMode
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UBaseMovementMode>    MovementMode                                           (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBaseMovementMode*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBaseMovementMode* UMoverComponent::FindMovementMode(TSubclassOf<class UBaseMovementMode> MovementMode) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "FindMovementMode");

	Params::MoverComponent_FindMovementMode Parms{};

	Parms.MovementMode = MovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.FindMovementModeByName
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             MovementModeName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBaseMovementMode*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBaseMovementMode* UMoverComponent::FindMovementModeByName(class FName MovementModeName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "FindMovementModeByName");

	Params::MoverComponent_FindMovementModeByName Parms{};

	Parms.MovementModeName = MovementModeName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.FindSharedSettings_BP
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UObject>              SharedSetting                                          (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UObject* UMoverComponent::FindSharedSettings_BP(TSubclassOf<class UObject> SharedSetting) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "FindSharedSettings_BP");

	Params::MoverComponent_FindSharedSettings_BP Parms{};

	Parms.SharedSetting = SharedSetting;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.FindSharedSettings_Mutable_BP
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UObject>              SharedSetting                                          (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UMoverComponent::FindSharedSettings_Mutable_BP(TSubclassOf<class UObject> SharedSetting) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "FindSharedSettings_Mutable_BP");

	Params::MoverComponent_FindSharedSettings_Mutable_BP Parms{};

	Parms.SharedSetting = SharedSetting;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetBaseVisualComponentTransform
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform UMoverComponent::GetBaseVisualComponentTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetBaseVisualComponentTransform");

	Params::MoverComponent_GetBaseVisualComponentTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetGravityAcceleration
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverComponent::GetGravityAcceleration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetGravityAcceleration");

	Params::MoverComponent_GetGravityAcceleration Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetLastInputCmd
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMoverInputCmdContext      ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FMoverInputCmdContext UMoverComponent::GetLastInputCmd() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetLastInputCmd");

	Params::MoverComponent_GetLastInputCmd Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetLastTimeStep
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMoverTimeStep             ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FMoverTimeStep UMoverComponent::GetLastTimeStep() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetLastTimeStep");

	Params::MoverComponent_GetLastTimeStep Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetMovementBase
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPrimitiveComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPrimitiveComponent* UMoverComponent::GetMovementBase() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetMovementBase");

	Params::MoverComponent_GetMovementBase Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetMovementBaseBoneName
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UMoverComponent::GetMovementBaseBoneName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetMovementBaseBoneName");

	Params::MoverComponent_GetMovementBaseBoneName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetMovementIntent
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverComponent::GetMovementIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetMovementIntent");

	Params::MoverComponent_GetMovementIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetMovementMode
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UBaseMovementMode*          ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UBaseMovementMode* UMoverComponent::GetMovementMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetMovementMode");

	Params::MoverComponent_GetMovementMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetMovementModeName
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UMoverComponent::GetMovementModeName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetMovementModeName");

	Params::MoverComponent_GetMovementModeName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetPlanarConstraint
// (Final, RequiredAPI, Native, Public, BlueprintCallable, Const)
// Parameters:
// const struct FPlanarConstraint          ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FPlanarConstraint UMoverComponent::GetPlanarConstraint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetPlanarConstraint");

	Params::MoverComponent_GetPlanarConstraint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetPrimaryVisualComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* UMoverComponent::GetPrimaryVisualComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetPrimaryVisualComponent");

	Params::MoverComponent_GetPrimaryVisualComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetSimBlackboard
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UMoverBlackboard*           ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UMoverBlackboard* UMoverComponent::GetSimBlackboard() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetSimBlackboard");

	Params::MoverComponent_GetSimBlackboard Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetSyncState
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMoverSyncState            ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FMoverSyncState UMoverComponent::GetSyncState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetSyncState");

	Params::MoverComponent_GetSyncState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetTargetOrientation
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UMoverComponent::GetTargetOrientation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetTargetOrientation");

	Params::MoverComponent_GetTargetOrientation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetUpdatedComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* UMoverComponent::GetUpdatedComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetUpdatedComponent");

	Params::MoverComponent_GetUpdatedComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetUpDirection
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverComponent::GetUpDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetUpDirection");

	Params::MoverComponent_GetUpDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.GetVelocity
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverComponent::GetVelocity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "GetVelocity");

	Params::MoverComponent_GetVelocity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.HasGameplayTag
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              TagToFind                                              (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bExactMatch                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::HasGameplayTag(const struct FGameplayTag& TagToFind, bool bExactMatch) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "HasGameplayTag");

	Params::MoverComponent_HasGameplayTag Parms{};

	Parms.TagToFind = std::move(TagToFind);
	Parms.bExactMatch = bExactMatch;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.HasGameplayTagInState
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMoverSyncState&           SyncState                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              TagToFind                                              (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bExactMatch                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::HasGameplayTagInState(const struct FMoverSyncState& SyncState, const struct FGameplayTag& TagToFind, bool bExactMatch) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "HasGameplayTagInState");

	Params::MoverComponent_HasGameplayTagInState Parms{};

	Parms.SyncState = std::move(SyncState);
	Parms.TagToFind = std::move(TagToFind);
	Parms.bExactMatch = bExactMatch;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.HasValidCachedInputCmd
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::HasValidCachedInputCmd() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "HasValidCachedInputCmd");

	Params::MoverComponent_HasValidCachedInputCmd Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.HasValidCachedState
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::HasValidCachedState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "HasValidCachedState");

	Params::MoverComponent_HasValidCachedState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.IsModifierActiveOrQueued
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMovementModifierHandle&   ModifierHandle                                         (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::IsModifierActiveOrQueued(const struct FMovementModifierHandle& ModifierHandle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "IsModifierActiveOrQueued");

	Params::MoverComponent_IsModifierActiveOrQueued Parms{};

	Parms.ModifierHandle = std::move(ModifierHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.IsUsingDeferredGroupMovement
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::IsUsingDeferredGroupMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "IsUsingDeferredGroupMovement");

	Params::MoverComponent_IsUsingDeferredGroupMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverComponent.K2_FindActiveLayeredMove
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   DidSucceed                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  TargetAsRawBytes                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::K2_FindActiveLayeredMove(bool* DidSucceed, int32* TargetAsRawBytes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "K2_FindActiveLayeredMove");

	Params::MoverComponent_K2_FindActiveLayeredMove Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (DidSucceed != nullptr)
		*DidSucceed = Parms.DidSucceed;

	if (TargetAsRawBytes != nullptr)
		*TargetAsRawBytes = Parms.TargetAsRawBytes;
}


// Function Mover.MoverComponent.K2_FindMovementModifier
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FMovementModifierHandle&   ModifierHandle                                         (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   bFoundModifier                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  TargetAsRawBytes                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverComponent::K2_FindMovementModifier(const struct FMovementModifierHandle& ModifierHandle, bool* bFoundModifier, int32* TargetAsRawBytes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "K2_FindMovementModifier");

	Params::MoverComponent_K2_FindMovementModifier Parms{};

	Parms.ModifierHandle = std::move(ModifierHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bFoundModifier != nullptr)
		*bFoundModifier = Parms.bFoundModifier;

	if (TargetAsRawBytes != nullptr)
		*TargetAsRawBytes = Parms.TargetAsRawBytes;
}


// Function Mover.MoverComponent.TryGetFloorCheckHitResult
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FHitResult*                      OutHitResult                                           (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverComponent::TryGetFloorCheckHitResult(struct FHitResult* OutHitResult) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverComponent", "TryGetFloorCheckHitResult");

	Params::MoverComponent_TryGetFloorCheckHitResult Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutHitResult != nullptr)
		*OutHitResult = std::move(Parms.OutHitResult);

	return Parms.ReturnValue;
}


// Function Mover.PathedPhysicsMoverComponent.SetDefaultPlaybackBehavior
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// EPathedPhysicsPlaybackBehavior          PlaybackBehavior                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPathedPhysicsMoverComponent::SetDefaultPlaybackBehavior(EPathedPhysicsPlaybackBehavior PlaybackBehavior)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "SetDefaultPlaybackBehavior");

	Params::PathedPhysicsMoverComponent_SetDefaultPlaybackBehavior Parms{};

	Parms.PlaybackBehavior = PlaybackBehavior;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PathedPhysicsMoverComponent.SetIsMoving
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldMove                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPathedPhysicsMoverComponent::SetIsMoving(bool bShouldMove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "SetIsMoving");

	Params::PathedPhysicsMoverComponent_SetIsMoving Parms{};

	Parms.bShouldMove = bShouldMove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PathedPhysicsMoverComponent.SetPathOriginTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                NewPathOrigin                                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPathedPhysicsMoverComponent::SetPathOriginTransform(const struct FTransform& NewPathOrigin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "SetPathOriginTransform");

	Params::PathedPhysicsMoverComponent_SetPathOriginTransform Parms{};

	Parms.NewPathOrigin = std::move(NewPathOrigin);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PathedPhysicsMoverComponent.SetPlaybackDirection
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bPlayForward                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPathedPhysicsMoverComponent::SetPlaybackDirection(bool bPlayForward)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "SetPlaybackDirection");

	Params::PathedPhysicsMoverComponent_SetPlaybackDirection Parms{};

	Parms.bPlayForward = bPlayForward;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PathedPhysicsMoverComponent.GetDefaultPlaybackBehavior
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPathedPhysicsPlaybackBehavior          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPathedPhysicsPlaybackBehavior UPathedPhysicsMoverComponent::GetDefaultPlaybackBehavior() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "GetDefaultPlaybackBehavior");

	Params::PathedPhysicsMoverComponent_GetDefaultPlaybackBehavior Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PathedPhysicsMoverComponent.GetPathOriginTransform
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FTransform                 ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FTransform UPathedPhysicsMoverComponent::GetPathOriginTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "GetPathOriginTransform");

	Params::PathedPhysicsMoverComponent_GetPathOriginTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PathedPhysicsMoverComponent.IsInReverse
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPathedPhysicsMoverComponent::IsInReverse() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "IsInReverse");

	Params::PathedPhysicsMoverComponent_IsInReverse Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PathedPhysicsMoverComponent.IsJointEnabled
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPathedPhysicsMoverComponent::IsJointEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "IsJointEnabled");

	Params::PathedPhysicsMoverComponent_IsJointEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PathedPhysicsMoverComponent.IsMoving
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPathedPhysicsMoverComponent::IsMoving() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMoverComponent", "IsMoving");

	Params::PathedPhysicsMoverComponent_IsMoving Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.BaseMovementMode.K2_OnActivated
// (RequiredAPI, Event, Protected, BlueprintEvent)

void UBaseMovementMode::K2_OnActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementMode", "K2_OnActivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Mover.BaseMovementMode.K2_OnDeactivated
// (RequiredAPI, Event, Protected, BlueprintEvent)

void UBaseMovementMode::K2_OnDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementMode", "K2_OnDeactivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Mover.BaseMovementMode.K2_OnRegistered
// (RequiredAPI, Event, Protected, BlueprintEvent)
// Parameters:
// const class FName                       ModeName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBaseMovementMode::K2_OnRegistered(const class FName ModeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementMode", "K2_OnRegistered");

	Params::BaseMovementMode_K2_OnRegistered Parms{};

	Parms.ModeName = ModeName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Mover.BaseMovementMode.K2_OnUnregistered
// (RequiredAPI, Event, Protected, BlueprintEvent)

void UBaseMovementMode::K2_OnUnregistered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementMode", "K2_OnUnregistered");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Mover.BaseMovementMode.SimulationTick
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FSimulationTickParams&     Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMoverTickEndData*               OutputState                                            (Parm, OutParm, NativeAccessSpecifierPublic)

void UBaseMovementMode::SimulationTick(const struct FSimulationTickParams& Params_0, struct FMoverTickEndData* OutputState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementMode", "SimulationTick");

	Params::BaseMovementMode_SimulationTick Parms{};

	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutputState != nullptr)
		*OutputState = std::move(Parms.OutputState);
}


// Function Mover.BaseMovementMode.GenerateMove
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const struct FMoverTickStartData&       StartState                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FProposedMove*                   OutProposedMove                                        (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)

void UBaseMovementMode::GenerateMove(const struct FMoverTickStartData& StartState, const struct FMoverTimeStep& TimeStep, struct FProposedMove* OutProposedMove) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementMode", "GenerateMove");

	Params::BaseMovementMode_GenerateMove Parms{};

	Parms.StartState = std::move(StartState);
	Parms.TimeStep = std::move(TimeStep);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutProposedMove != nullptr)
		*OutProposedMove = std::move(Parms.OutProposedMove);
}


// Function Mover.BaseMovementMode.K2_GetMoverComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMoverComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMoverComponent* UBaseMovementMode::K2_GetMoverComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementMode", "K2_GetMoverComponent");

	Params::BaseMovementMode_K2_GetMoverComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PathedPhysicsMovementMode.SetPathDuration_BeginPlayOnly
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewDuration                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPathedPhysicsMovementMode::SetPathDuration_BeginPlayOnly(float NewDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMovementMode", "SetPathDuration_BeginPlayOnly");

	Params::PathedPhysicsMovementMode_SetPathDuration_BeginPlayOnly Parms{};

	Parms.NewDuration = NewDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PathedPhysicsMovementMode.SetUseJointConstraint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUseJoint                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPathedPhysicsMovementMode::SetUseJointConstraint(bool bUseJoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMovementMode", "SetUseJointConstraint");

	Params::PathedPhysicsMovementMode_SetUseJointConstraint Parms{};

	Parms.bUseJoint = bUseJoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PathedPhysicsMovementMode.BP_FindPattern
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UPathedMovementPatternBase>PatternType                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPathedMovementPatternBase*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPathedMovementPatternBase* UPathedPhysicsMovementMode::BP_FindPattern(TSubclassOf<class UPathedMovementPatternBase> PatternType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PathedPhysicsMovementMode", "BP_FindPattern");

	Params::PathedPhysicsMovementMode_BP_FindPattern Parms{};

	Parms.PatternType = PatternType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.CanCrouch
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::CanCrouch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "CanCrouch");

	Params::CharacterMoverComponent_CanCrouch Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.Crouch
// (RequiredAPI, Native, Public, BlueprintCallable)

void UCharacterMoverComponent::Crouch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "Crouch");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Mover.CharacterMoverComponent.Jump
// (RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::Jump()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "Jump");

	Params::CharacterMoverComponent_Jump Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.OnMoverPreSimulationTick
// (RequiredAPI, Native, Protected, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FMoverInputCmdContext&     InputCmd                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UCharacterMoverComponent::OnMoverPreSimulationTick(const struct FMoverTimeStep& TimeStep, const struct FMoverInputCmdContext& InputCmd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "OnMoverPreSimulationTick");

	Params::CharacterMoverComponent_OnMoverPreSimulationTick Parms{};

	Parms.TimeStep = std::move(TimeStep);
	Parms.InputCmd = std::move(InputCmd);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.CharacterMoverComponent.SetHandleJump
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInHandleJump                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterMoverComponent::SetHandleJump(bool bInHandleJump)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "SetHandleJump");

	Params::CharacterMoverComponent_SetHandleJump Parms{};

	Parms.bInHandleJump = bInHandleJump;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.CharacterMoverComponent.SetHandleStanceChanges
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInHandleStanceChanges                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterMoverComponent::SetHandleStanceChanges(bool bInHandleStanceChanges)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "SetHandleStanceChanges");

	Params::CharacterMoverComponent_SetHandleStanceChanges Parms{};

	Parms.bInHandleStanceChanges = bInHandleStanceChanges;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.CharacterMoverComponent.UnCrouch
// (RequiredAPI, Native, Public, BlueprintCallable)

void UCharacterMoverComponent::UnCrouch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "UnCrouch");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Mover.CharacterMoverComponent.CanActorJump
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::CanActorJump() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "CanActorJump");

	Params::CharacterMoverComponent_CanActorJump Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.GetHandleJump
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::GetHandleJump() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "GetHandleJump");

	Params::CharacterMoverComponent_GetHandleJump Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.GetHandleStanceChanges
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::GetHandleStanceChanges() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "GetHandleStanceChanges");

	Params::CharacterMoverComponent_GetHandleStanceChanges Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.IsAirborne
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::IsAirborne() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "IsAirborne");

	Params::CharacterMoverComponent_IsAirborne Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.IsCrouching
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::IsCrouching() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "IsCrouching");

	Params::CharacterMoverComponent_IsCrouching Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.IsFalling
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::IsFalling() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "IsFalling");

	Params::CharacterMoverComponent_IsFalling Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.IsFlying
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::IsFlying() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "IsFlying");

	Params::CharacterMoverComponent_IsFlying Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.IsOnGround
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::IsOnGround() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "IsOnGround");

	Params::CharacterMoverComponent_IsOnGround Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.IsSlopeSliding
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::IsSlopeSliding() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "IsSlopeSliding");

	Params::CharacterMoverComponent_IsSlopeSliding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.CharacterMoverComponent.IsSwimming
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterMoverComponent::IsSwimming() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterMoverComponent", "IsSwimming");

	Params::CharacterMoverComponent_IsSwimming Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PlanarConstraintUtils.ConstrainDirectionToPlane
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FPlanarConstraint&         Constraint                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bMaintainMagnitude                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPlanarConstraintUtils::ConstrainDirectionToPlane(const struct FPlanarConstraint& Constraint, const struct FVector& Direction, bool bMaintainMagnitude)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PlanarConstraintUtils", "ConstrainDirectionToPlane");

	Params::PlanarConstraintUtils_ConstrainDirectionToPlane Parms{};

	Parms.Constraint = std::move(Constraint);
	Parms.Direction = std::move(Direction);
	Parms.bMaintainMagnitude = bMaintainMagnitude;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PlanarConstraintUtils.ConstrainLocationToPlane
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FPlanarConstraint&         Constraint                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPlanarConstraintUtils::ConstrainLocationToPlane(const struct FPlanarConstraint& Constraint, const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PlanarConstraintUtils", "ConstrainLocationToPlane");

	Params::PlanarConstraintUtils_ConstrainLocationToPlane Parms{};

	Parms.Constraint = std::move(Constraint);
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PlanarConstraintUtils.ConstrainNormalToPlane
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FPlanarConstraint&         Constraint                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   Normal                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UPlanarConstraintUtils::ConstrainNormalToPlane(const struct FPlanarConstraint& Constraint, const struct FVector& Normal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PlanarConstraintUtils", "ConstrainNormalToPlane");

	Params::PlanarConstraintUtils_ConstrainNormalToPlane Parms{};

	Parms.Constraint = std::move(Constraint);
	Parms.Normal = std::move(Normal);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PlanarConstraintUtils.SetPlanarConstraintEnabled
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FPlanarConstraint&               Constraint                                             (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlanarConstraintUtils::SetPlanarConstraintEnabled(struct FPlanarConstraint& Constraint, bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PlanarConstraintUtils", "SetPlanarConstraintEnabled");

	Params::PlanarConstraintUtils_SetPlanarConstraintEnabled Parms{};

	Parms.Constraint = std::move(Constraint);
	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Constraint = std::move(Parms.Constraint);
}


// Function Mover.PlanarConstraintUtils.SetPlanarConstraintNormal
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPlanarConstraint&               Constraint                                             (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   PlaneNormal                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlanarConstraintUtils::SetPlanarConstraintNormal(struct FPlanarConstraint& Constraint, const struct FVector& PlaneNormal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PlanarConstraintUtils", "SetPlanarConstraintNormal");

	Params::PlanarConstraintUtils_SetPlanarConstraintNormal Parms{};

	Parms.Constraint = std::move(Constraint);
	Parms.PlaneNormal = std::move(PlaneNormal);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Constraint = std::move(Parms.Constraint);
}


// Function Mover.PlanarConstraintUtils.SetPlaneConstraintOrigin
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPlanarConstraint&               Constraint                                             (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   PlaneOrigin                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlanarConstraintUtils::SetPlaneConstraintOrigin(struct FPlanarConstraint& Constraint, const struct FVector& PlaneOrigin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PlanarConstraintUtils", "SetPlaneConstraintOrigin");

	Params::PlanarConstraintUtils_SetPlaneConstraintOrigin Parms{};

	Parms.Constraint = std::move(Constraint);
	Parms.PlaneOrigin = std::move(PlaneOrigin);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Constraint = std::move(Parms.Constraint);
}


// Function Mover.FloorQueryUtils.IsHitSurfaceWalkable
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   UpDirection                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UFloorQueryUtils::IsHitSurfaceWalkable(const struct FHitResult& Hit, const struct FVector& UpDirection, float MaxWalkSlopeCosine)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FloorQueryUtils", "IsHitSurfaceWalkable");

	Params::FloorQueryUtils_IsHitSurfaceWalkable Parms{};

	Parms.Hit = std::move(Hit);
	Parms.UpDirection = std::move(UpDirection);
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.GroundMovementUtils.CanStepUpOnHitSurface
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGroundMovementUtils::CanStepUpOnHitSurface(const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GroundMovementUtils", "CanStepUpOnHitSurface");

	Params::GroundMovementUtils_CanStepUpOnHitSurface Parms{};

	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.GroundMovementUtils.ComputeControlledGroundMove
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGroundMoveParams&         InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FProposedMove                    ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FProposedMove UGroundMovementUtils::ComputeControlledGroundMove(const struct FGroundMoveParams& InParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GroundMovementUtils", "ComputeControlledGroundMove");

	Params::GroundMovementUtils_ComputeControlledGroundMove Parms{};

	Parms.InParams = std::move(InParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.GroundMovementUtils.ComputeDeflectedMoveOntoRamp
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   OrigMoveDelta                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   UpDirection                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                RampHitResult                                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bHitFromLineTrace                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UGroundMovementUtils::ComputeDeflectedMoveOntoRamp(const struct FVector& OrigMoveDelta, const struct FVector& UpDirection, const struct FHitResult& RampHitResult, float MaxWalkSlopeCosine, const bool bHitFromLineTrace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GroundMovementUtils", "ComputeDeflectedMoveOntoRamp");

	Params::GroundMovementUtils_ComputeDeflectedMoveOntoRamp Parms{};

	Parms.OrigMoveDelta = std::move(OrigMoveDelta);
	Parms.UpDirection = std::move(UpDirection);
	Parms.RampHitResult = std::move(RampHitResult);
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;
	Parms.bHitFromLineTrace = bHitFromLineTrace;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.GroundMovementUtils.TestGroundedMoveAlongHitSurface
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   OriginalMoveDelta                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationAtHit                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     TargetRotation                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bHandleImpact                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxStepHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      InOutHit                                               (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 InOutMoveRecord                                        (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UGroundMovementUtils::TestGroundedMoveAlongHitSurface(const struct FMovingComponentSet& MovingComps, const struct FVector& OriginalMoveDelta, const struct FVector& LocationAtHit, const struct FQuat& TargetRotation, bool bHandleImpact, float MaxStepHeight, float MaxWalkSlopeCosine, struct FHitResult& InOutHit, struct FMovementRecord& InOutMoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GroundMovementUtils", "TestGroundedMoveAlongHitSurface");

	Params::GroundMovementUtils_TestGroundedMoveAlongHitSurface Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.OriginalMoveDelta = std::move(OriginalMoveDelta);
	Parms.LocationAtHit = std::move(LocationAtHit);
	Parms.TargetRotation = std::move(TargetRotation);
	Parms.bHandleImpact = bHandleImpact;
	Parms.MaxStepHeight = MaxStepHeight;
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;
	Parms.InOutHit = std::move(InOutHit);
	Parms.InOutMoveRecord = std::move(InOutMoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	InOutHit = std::move(Parms.InOutHit);
	InOutMoveRecord = std::move(Parms.InOutMoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.GroundMovementUtils.TestMoveToAdjustToFloor
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFloorCheckResult&               InOutCurrentFloor                                      (Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 InOutMoveRecord                                        (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UGroundMovementUtils::TestMoveToAdjustToFloor(const struct FMovingComponentSet& MovingComps, const struct FVector& Location, const struct FQuat& Rotation, float MaxWalkSlopeCosine, struct FFloorCheckResult& InOutCurrentFloor, struct FMovementRecord& InOutMoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GroundMovementUtils", "TestMoveToAdjustToFloor");

	Params::GroundMovementUtils_TestMoveToAdjustToFloor Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;
	Parms.InOutCurrentFloor = std::move(InOutCurrentFloor);
	Parms.InOutMoveRecord = std::move(InOutMoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	InOutCurrentFloor = std::move(Parms.InOutCurrentFloor);
	InOutMoveRecord = std::move(Parms.InOutMoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.GroundMovementUtils.TryWalkToSlideAlongSurface
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PctOfDeltaToMove                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Normal                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      Hit                                                    (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bHandleImpact                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 MoveRecord                                             (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   MaxWalkSlopeCosine                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxStepHeight                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UGroundMovementUtils::TryWalkToSlideAlongSurface(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, float PctOfDeltaToMove, const struct FQuat& Rotation, const struct FVector& Normal, struct FHitResult& Hit, bool bHandleImpact, struct FMovementRecord& MoveRecord, float MaxWalkSlopeCosine, float MaxStepHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GroundMovementUtils", "TryWalkToSlideAlongSurface");

	Params::GroundMovementUtils_TryWalkToSlideAlongSurface Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.PctOfDeltaToMove = PctOfDeltaToMove;
	Parms.Rotation = std::move(Rotation);
	Parms.Normal = std::move(Normal);
	Parms.Hit = std::move(Hit);
	Parms.bHandleImpact = bHandleImpact;
	Parms.MoveRecord = std::move(MoveRecord);
	Parms.MaxWalkSlopeCosine = MaxWalkSlopeCosine;
	Parms.MaxStepHeight = MaxStepHeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Hit = std::move(Parms.Hit);
	MoveRecord = std::move(Parms.MoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.LookAtRotationPattern.SetLookAtLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   LookAt                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULookAtRotationPattern::SetLookAtLocation(const struct FVector& LookAt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LookAtRotationPattern", "SetLookAtLocation");

	Params::LookAtRotationPattern_SetLookAtLocation Parms{};

	Parms.LookAt = std::move(LookAt);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.LookAtRotationPattern.SetRelativeLookAtLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   RelativeLookAt                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULookAtRotationPattern::SetRelativeLookAtLocation(const struct FVector& RelativeLookAt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LookAtRotationPattern", "SetRelativeLookAtLocation");

	Params::LookAtRotationPattern_SetRelativeLookAtLocation Parms{};

	Parms.RelativeLookAt = std::move(RelativeLookAt);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.TurnGeneratorInterface.GetTurn
// (RequiredAPI, Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FRotator&                  TargetOrientation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FMoverTickStartData&       FullStartState                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FMoverDefaultSyncState&    MoverState                                             (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FProposedMove&             ProposedMove                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class UMoverBlackboard*                 SimBlackboard                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator ITurnGeneratorInterface::GetTurn(const struct FRotator& TargetOrientation, const struct FMoverTickStartData& FullStartState, const struct FMoverDefaultSyncState& MoverState, const struct FMoverTimeStep& TimeStep, const struct FProposedMove& ProposedMove, class UMoverBlackboard* SimBlackboard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("TurnGeneratorInterface", "GetTurn");

	Params::TurnGeneratorInterface_GetTurn Parms{};

	Parms.TargetOrientation = std::move(TargetOrientation);
	Parms.FullStartState = std::move(FullStartState);
	Parms.MoverState = std::move(MoverState);
	Parms.TimeStep = std::move(TimeStep);
	Parms.ProposedMove = std::move(ProposedMove);
	Parms.SimBlackboard = SimBlackboard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementRecordUtils.K2_GetRelevantMoveDelta
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FMovementRecord&           MovementRecord                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector UMovementRecordUtils::K2_GetRelevantMoveDelta(const struct FMovementRecord& MovementRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementRecordUtils", "K2_GetRelevantMoveDelta");

	Params::MovementRecordUtils_K2_GetRelevantMoveDelta Parms{};

	Parms.MovementRecord = std::move(MovementRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementRecordUtils.K2_GetRelevantVelocity
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FMovementRecord&           MovementRecord                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementRecordUtils::K2_GetRelevantVelocity(const struct FMovementRecord& MovementRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementRecordUtils", "K2_GetRelevantVelocity");

	Params::MovementRecordUtils_K2_GetRelevantVelocity Parms{};

	Parms.MovementRecord = std::move(MovementRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementRecordUtils.K2_GetTotalMoveDelta
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FMovementRecord&           MovementRecord                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector UMovementRecordUtils::K2_GetTotalMoveDelta(const struct FMovementRecord& MovementRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementRecordUtils", "K2_GetTotalMoveDelta");

	Params::MovementRecordUtils_K2_GetTotalMoveDelta Parms{};

	Parms.MovementRecord = std::move(MovementRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementRecordUtils.K2_SetDeltaSeconds
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FMovementRecord&                 OutMovementRecord                                      (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMovementRecordUtils::K2_SetDeltaSeconds(struct FMovementRecord& OutMovementRecord, float DeltaSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementRecordUtils", "K2_SetDeltaSeconds");

	Params::MovementRecordUtils_K2_SetDeltaSeconds Parms{};

	Parms.OutMovementRecord = std::move(OutMovementRecord);
	Parms.DeltaSeconds = DeltaSeconds;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	OutMovementRecord = std::move(Parms.OutMovementRecord);
}


// Function Mover.MoverDataModelBlueprintLibrary.GetLocationFromSyncState
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMoverDefaultSyncState&    SyncState                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverDataModelBlueprintLibrary::GetLocationFromSyncState(const struct FMoverDefaultSyncState& SyncState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataModelBlueprintLibrary", "GetLocationFromSyncState");

	Params::MoverDataModelBlueprintLibrary_GetLocationFromSyncState Parms{};

	Parms.SyncState = std::move(SyncState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverDataModelBlueprintLibrary.GetMoveDirectionIntentFromInputs
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FCharacterDefaultInputs&   Inputs                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverDataModelBlueprintLibrary::GetMoveDirectionIntentFromInputs(const struct FCharacterDefaultInputs& Inputs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataModelBlueprintLibrary", "GetMoveDirectionIntentFromInputs");

	Params::MoverDataModelBlueprintLibrary_GetMoveDirectionIntentFromInputs Parms{};

	Parms.Inputs = std::move(Inputs);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverDataModelBlueprintLibrary.GetMoveDirectionIntentFromSyncState
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMoverDefaultSyncState&    SyncState                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverDataModelBlueprintLibrary::GetMoveDirectionIntentFromSyncState(const struct FMoverDefaultSyncState& SyncState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataModelBlueprintLibrary", "GetMoveDirectionIntentFromSyncState");

	Params::MoverDataModelBlueprintLibrary_GetMoveDirectionIntentFromSyncState Parms{};

	Parms.SyncState = std::move(SyncState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverDataModelBlueprintLibrary.GetOrientationFromSyncState
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMoverDefaultSyncState&    SyncState                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UMoverDataModelBlueprintLibrary::GetOrientationFromSyncState(const struct FMoverDefaultSyncState& SyncState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataModelBlueprintLibrary", "GetOrientationFromSyncState");

	Params::MoverDataModelBlueprintLibrary_GetOrientationFromSyncState Parms{};

	Parms.SyncState = std::move(SyncState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverDataModelBlueprintLibrary.GetVelocityFromSyncState
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMoverDefaultSyncState&    SyncState                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMoverDataModelBlueprintLibrary::GetVelocityFromSyncState(const struct FMoverDefaultSyncState& SyncState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataModelBlueprintLibrary", "GetVelocityFromSyncState");

	Params::MoverDataModelBlueprintLibrary_GetVelocityFromSyncState Parms{};

	Parms.SyncState = std::move(SyncState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverDataModelBlueprintLibrary.SetMoveIntent
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FCharacterDefaultInputs&         Inputs                                                 (Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldDirectionIntent                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverDataModelBlueprintLibrary::SetMoveIntent(struct FCharacterDefaultInputs& Inputs, const struct FVector& WorldDirectionIntent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataModelBlueprintLibrary", "SetMoveIntent");

	Params::MoverDataModelBlueprintLibrary_SetMoveIntent Parms{};

	Parms.Inputs = std::move(Inputs);
	Parms.WorldDirectionIntent = std::move(WorldDirectionIntent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Inputs = std::move(Parms.Inputs);
}


// Function Mover.MoverDebugComponent.OnHistoryTrackingRollback
// (Final, RequiredAPI, Native, Protected, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            NewTimeStep                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FMoverTimeStep&            InvalidatedTimeStep                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UMoverDebugComponent::OnHistoryTrackingRollback(const struct FMoverTimeStep& NewTimeStep, const struct FMoverTimeStep& InvalidatedTimeStep)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverDebugComponent", "OnHistoryTrackingRollback");

	Params::MoverDebugComponent_OnHistoryTrackingRollback Parms{};

	Parms.NewTimeStep = std::move(NewTimeStep);
	Parms.InvalidatedTimeStep = std::move(InvalidatedTimeStep);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverDebugComponent.OnMovementSimRollback
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            NewTimeStep                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FMoverTimeStep&            InvalidatedTimeStep                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UMoverDebugComponent::OnMovementSimRollback(const struct FMoverTimeStep& NewTimeStep, const struct FMoverTimeStep& InvalidatedTimeStep)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverDebugComponent", "OnMovementSimRollback");

	Params::MoverDebugComponent_OnMovementSimRollback Parms{};

	Parms.NewTimeStep = std::move(NewTimeStep);
	Parms.InvalidatedTimeStep = std::move(InvalidatedTimeStep);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverDebugComponent.OnMovementSimTick
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UMoverDebugComponent::OnMovementSimTick(const struct FMoverTimeStep& TimeStep)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverDebugComponent", "OnMovementSimTick");

	Params::MoverDebugComponent_OnMovementSimTick Parms{};

	Parms.TimeStep = std::move(TimeStep);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverDebugComponent.SetHistoryTracking
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   SecondsToTrack                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SamplesPerSecond                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverDebugComponent::SetHistoryTracking(float SecondsToTrack, float SamplesPerSecond)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverDebugComponent", "SetHistoryTracking");

	Params::MoverDebugComponent_SetHistoryTracking Parms{};

	Parms.SecondsToTrack = SecondsToTrack;
	Parms.SamplesPerSecond = SamplesPerSecond;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverDebugComponent.GetPastTrajectory
// (Final, RequiredAPI, Native, Public, BlueprintCallable, Const)
// Parameters:
// TArray<struct FTrajectorySampleInfo>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FTrajectorySampleInfo> UMoverDebugComponent::GetPastTrajectory() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverDebugComponent", "GetPastTrajectory");

	Params::MoverDebugComponent_GetPastTrajectory Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverNetworkPhysicsLiaisonComponentBase.HandleComponentPhysicsStateChanged
// (RequiredAPI, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              ChangedComponent                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EComponentPhysicsStateChange            StateChange                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverNetworkPhysicsLiaisonComponentBase::HandleComponentPhysicsStateChanged(class UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverNetworkPhysicsLiaisonComponentBase", "HandleComponentPhysicsStateChanged");

	Params::MoverNetworkPhysicsLiaisonComponentBase_HandleComponentPhysicsStateChanged Parms{};

	Parms.ChangedComponent = ChangedComponent;
	Parms.StateChange = StateChange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverNetworkPhysicsLiaisonComponentBase.HandleOwningPawnControllerChanged_Server
// (Final, RequiredAPI, Native, Protected)
// Parameters:
// class APawn*                            OwnerPawn                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      OldController                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      NewController                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverNetworkPhysicsLiaisonComponentBase::HandleOwningPawnControllerChanged_Server(class APawn* OwnerPawn, class AController* OldController, class AController* NewController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverNetworkPhysicsLiaisonComponentBase", "HandleOwningPawnControllerChanged_Server");

	Params::MoverNetworkPhysicsLiaisonComponentBase_HandleOwningPawnControllerChanged_Server Parms{};

	Parms.OwnerPawn = OwnerPawn;
	Parms.OldController = OldController;
	Parms.NewController = NewController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverTrajectoryPredictor.Setup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMoverComponent*                  InMoverComponent                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverTrajectoryPredictor::Setup(class UMoverComponent* InMoverComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverTrajectoryPredictor", "Setup");

	Params::MoverTrajectoryPredictor_Setup Parms{};

	Parms.InMoverComponent = InMoverComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverInputProducerInterface.ProduceInput
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// int32                                   SimTimeMs                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMoverInputCmdContext*           InputCmdResult                                         (Parm, OutParm, NativeAccessSpecifierPublic)

void IMoverInputProducerInterface::ProduceInput(int32 SimTimeMs, struct FMoverInputCmdContext* InputCmdResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("MoverInputProducerInterface", "ProduceInput");

	Params::MoverInputProducerInterface_ProduceInput Parms{};

	Parms.SimTimeMs = SimTimeMs;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (InputCmdResult != nullptr)
		*InputCmdResult = std::move(Parms.InputCmdResult);
}


// Function Mover.MoverStandaloneLiaisonComponent.AddTickDependency
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class UActorComponent*                  OtherComponent                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMoverTickDependencyOrder               TickOrder                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMoverTickPhase                         TickPhase                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverStandaloneLiaisonComponent::AddTickDependency(class UActorComponent* OtherComponent, EMoverTickDependencyOrder TickOrder, EMoverTickPhase TickPhase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "AddTickDependency");

	Params::MoverStandaloneLiaisonComponent_AddTickDependency Parms{};

	Parms.OtherComponent = OtherComponent;
	Parms.TickOrder = TickOrder;
	Parms.TickPhase = TickPhase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverStandaloneLiaisonComponent.OnControllerChanged
// (RequiredAPI, Native, Protected)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      OldController                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      NewController                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverStandaloneLiaisonComponent::OnControllerChanged(class APawn* Pawn, class AController* OldController, class AController* NewController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "OnControllerChanged");

	Params::MoverStandaloneLiaisonComponent_OnControllerChanged Parms{};

	Parms.Pawn = Pawn;
	Parms.OldController = OldController;
	Parms.NewController = NewController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverStandaloneLiaisonComponent.SetEnableProduceInput
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnableInputProduction                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverStandaloneLiaisonComponent::SetEnableProduceInput(bool bEnableInputProduction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "SetEnableProduceInput");

	Params::MoverStandaloneLiaisonComponent_SetEnableProduceInput Parms{};

	Parms.bEnableInputProduction = bEnableInputProduction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverStandaloneLiaisonComponent.SetUseAsyncMovementSimulationTick
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUseAsyncMovementSim                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverStandaloneLiaisonComponent::SetUseAsyncMovementSimulationTick(bool bUseAsyncMovementSim)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "SetUseAsyncMovementSimulationTick");

	Params::MoverStandaloneLiaisonComponent_SetUseAsyncMovementSimulationTick Parms{};

	Parms.bUseAsyncMovementSim = bUseAsyncMovementSim;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverStandaloneLiaisonComponent.SetUseAsyncProduceInput
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUseAsyncInputProduction                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverStandaloneLiaisonComponent::SetUseAsyncProduceInput(bool bUseAsyncInputProduction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "SetUseAsyncProduceInput");

	Params::MoverStandaloneLiaisonComponent_SetUseAsyncProduceInput Parms{};

	Parms.bUseAsyncInputProduction = bUseAsyncInputProduction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverStandaloneLiaisonComponent.GetEnableProduceInput
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverStandaloneLiaisonComponent::GetEnableProduceInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "GetEnableProduceInput");

	Params::MoverStandaloneLiaisonComponent_GetEnableProduceInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverStandaloneLiaisonComponent.GetUseAsyncMovementSimulationTick
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverStandaloneLiaisonComponent::GetUseAsyncMovementSimulationTick() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "GetUseAsyncMovementSimulationTick");

	Params::MoverStandaloneLiaisonComponent_GetUseAsyncMovementSimulationTick Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverStandaloneLiaisonComponent.GetUseAsyncProduceInput
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMoverStandaloneLiaisonComponent::GetUseAsyncProduceInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverStandaloneLiaisonComponent", "GetUseAsyncProduceInput");

	Params::MoverStandaloneLiaisonComponent_GetUseAsyncProduceInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverDataCollectionLibrary.ClearDataFromCollection
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FMoverDataCollection&            Collection                                             (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UMoverDataCollectionLibrary::ClearDataFromCollection(struct FMoverDataCollection& Collection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataCollectionLibrary", "ClearDataFromCollection");

	Params::MoverDataCollectionLibrary_ClearDataFromCollection Parms{};

	Parms.Collection = std::move(Collection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Collection = std::move(Parms.Collection);
}


// Function Mover.MoverDataCollectionLibrary.K2_AddDataToCollection
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FMoverDataCollection&            Collection                                             (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const int32&                            SourceAsRawBytes                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverDataCollectionLibrary::K2_AddDataToCollection(struct FMoverDataCollection& Collection, const int32& SourceAsRawBytes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataCollectionLibrary", "K2_AddDataToCollection");

	Params::MoverDataCollectionLibrary_K2_AddDataToCollection Parms{};

	Parms.Collection = std::move(Collection);
	Parms.SourceAsRawBytes = SourceAsRawBytes;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Collection = std::move(Parms.Collection);
}


// Function Mover.MoverDataCollectionLibrary.K2_GetDataFromCollection
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// bool*                                   DidSucceed                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMoverDataCollection&      Collection                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32*                                  TargetAsRawBytes                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverDataCollectionLibrary::K2_GetDataFromCollection(bool* DidSucceed, const struct FMoverDataCollection& Collection, int32* TargetAsRawBytes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MoverDataCollectionLibrary", "K2_GetDataFromCollection");

	Params::MoverDataCollectionLibrary_K2_GetDataFromCollection Parms{};

	Parms.Collection = std::move(Collection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (DidSucceed != nullptr)
		*DidSucceed = Parms.DidSucceed;

	if (TargetAsRawBytes != nullptr)
		*TargetAsRawBytes = Parms.TargetAsRawBytes;
}


// Function Mover.NavMoverComponent.ConsumeNavMovementData
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector*                         OutMoveInputIntent                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutMoveInputVelocity                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UNavMoverComponent::ConsumeNavMovementData(struct FVector* OutMoveInputIntent, struct FVector* OutMoveInputVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NavMoverComponent", "ConsumeNavMovementData");

	Params::NavMoverComponent_ConsumeNavMovementData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMoveInputIntent != nullptr)
		*OutMoveInputIntent = std::move(Parms.OutMoveInputIntent);

	if (OutMoveInputVelocity != nullptr)
		*OutMoveInputVelocity = std::move(Parms.OutMoveInputVelocity);

	return Parms.ReturnValue;
}


// Function Mover.NavMoverComponent.GetMaxSpeedForNavMovement
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UNavMoverComponent::GetMaxSpeedForNavMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NavMoverComponent", "GetMaxSpeedForNavMovement");

	Params::NavMoverComponent_GetMaxSpeedForNavMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.NavMoverComponent.GetVelocityForNavMovement
// (RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UNavMoverComponent::GetVelocityForNavMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NavMoverComponent", "GetVelocityForNavMovement");

	Params::NavMoverComponent_GetVelocityForNavMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.NavMoverComponent.IsSwimming
// (RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UNavMoverComponent::IsSwimming() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NavMoverComponent", "IsSwimming");

	Params::NavMoverComponent_IsSwimming Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.NavWalkingMode.GetTurnGenerator
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UNavWalkingMode::GetTurnGenerator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NavWalkingMode", "GetTurnGenerator");

	Params::NavWalkingMode_GetTurnGenerator Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.NavWalkingMode.SetTurnGeneratorClass
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UObject>              TurnGeneratorClass                                     (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UNavWalkingMode::SetTurnGeneratorClass(TSubclassOf<class UObject> TurnGeneratorClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NavWalkingMode", "SetTurnGeneratorClass");

	Params::NavWalkingMode_SetTurnGeneratorClass Parms{};

	Parms.TurnGeneratorClass = TurnGeneratorClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PhysicsCharacterMoverComponent.OnMoverPostSimulationTick
// (RequiredAPI, Native, Protected, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPhysicsCharacterMoverComponent::OnMoverPostSimulationTick(const struct FMoverTimeStep& TimeStep)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicsCharacterMoverComponent", "OnMoverPostSimulationTick");

	Params::PhysicsCharacterMoverComponent_OnMoverPostSimulationTick Parms{};

	Parms.TimeStep = std::move(TimeStep);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.PhysicsCharacterMoverComponent.OnMoverPreMovement
// (RequiredAPI, Native, Protected, HasOutParams)
// Parameters:
// const struct FMoverTimeStep&            TimeStep                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FMoverInputCmdContext&     InputCmd                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FMoverSyncState&           SyncState                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FMoverAuxStateContext&     AuxState                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UPhysicsCharacterMoverComponent::OnMoverPreMovement(const struct FMoverTimeStep& TimeStep, const struct FMoverInputCmdContext& InputCmd, const struct FMoverSyncState& SyncState, const struct FMoverAuxStateContext& AuxState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicsCharacterMoverComponent", "OnMoverPreMovement");

	Params::PhysicsCharacterMoverComponent_OnMoverPreMovement Parms{};

	Parms.TimeStep = std::move(TimeStep);
	Parms.InputCmd = std::move(InputCmd);
	Parms.SyncState = std::move(SyncState);
	Parms.AuxState = std::move(AuxState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.BaseMovementModeTransition.K2_OnRegistered
// (RequiredAPI, Event, Protected, BlueprintEvent)

void UBaseMovementModeTransition::K2_OnRegistered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementModeTransition", "K2_OnRegistered");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Mover.BaseMovementModeTransition.K2_OnUnregistered
// (RequiredAPI, Event, Protected, BlueprintEvent)

void UBaseMovementModeTransition::K2_OnUnregistered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementModeTransition", "K2_OnUnregistered");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Mover.BaseMovementModeTransition.Trigger
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FSimulationTickParams&     Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UBaseMovementModeTransition::Trigger(const struct FSimulationTickParams& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementModeTransition", "Trigger");

	Params::BaseMovementModeTransition_Trigger Parms{};

	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.BaseMovementModeTransition.Evaluate
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const struct FSimulationTickParams&     Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FTransitionEvalResult            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FTransitionEvalResult UBaseMovementModeTransition::Evaluate(const struct FSimulationTickParams& Params_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementModeTransition", "Evaluate");

	Params::BaseMovementModeTransition_Evaluate Parms{};

	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.BaseMovementModeTransition.K2_GetMoverComponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMoverComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMoverComponent* UBaseMovementModeTransition::K2_GetMoverComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BaseMovementModeTransition", "K2_GetMoverComponent");

	Params::BaseMovementModeTransition_K2_GetMoverComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.WaterMovementUtils.ComputeControlledWaterMove
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FWaterMoveParams&          InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FProposedMove                    ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FProposedMove UWaterMovementUtils::ComputeControlledWaterMove(const struct FWaterMoveParams& InParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("WaterMovementUtils", "ComputeControlledWaterMove");

	Params::WaterMovementUtils_ComputeControlledWaterMove Parms{};

	Parms.InParams = std::move(InParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.WaterMovementUtils.UpdateWaterSplineData
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUpdateWaterSplineDataParams&UpdateWaterSplineDataParams                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FWaterCheckResult&               WaterCheckResult                                       (Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UWaterMovementUtils::UpdateWaterSplineData(const struct FUpdateWaterSplineDataParams& UpdateWaterSplineDataParams, struct FWaterCheckResult& WaterCheckResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("WaterMovementUtils", "UpdateWaterSplineData");

	Params::WaterMovementUtils_UpdateWaterSplineData Parms{};

	Parms.UpdateWaterSplineDataParams = std::move(UpdateWaterSplineDataParams);
	Parms.WaterCheckResult = std::move(WaterCheckResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	WaterCheckResult = std::move(Parms.WaterCheckResult);
}


// Function Mover.MoverPathedPhysicsLiaisonComponent.HandleMovementModeChanged
// (Final, RequiredAPI, Native, Private, HasOutParams)
// Parameters:
// const class FName&                      OldModeName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NewModeName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMoverPathedPhysicsLiaisonComponent::HandleMovementModeChanged(const class FName& OldModeName, const class FName& NewModeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverPathedPhysicsLiaisonComponent", "HandleMovementModeChanged");

	Params::MoverPathedPhysicsLiaisonComponent_HandleMovementModeChanged Parms{};

	Parms.OldModeName = OldModeName;
	Parms.NewModeName = NewModeName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.AsyncFallingMode.ProcessLanded
// (RequiredAPI, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFloorCheckResult&         FloorResult                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector*                         Velocity                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRelativeBaseInfo*               BaseInfo                                               (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMoverTickEndData*               TickEndData                                            (Parm, OutParm, NativeAccessSpecifierPublic)

void UAsyncFallingMode::ProcessLanded(const struct FFloorCheckResult& FloorResult, struct FVector* Velocity, struct FRelativeBaseInfo* BaseInfo, struct FMoverTickEndData* TickEndData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AsyncFallingMode", "ProcessLanded");

	Params::AsyncFallingMode_ProcessLanded Parms{};

	Parms.FloorResult = std::move(FloorResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Velocity != nullptr)
		*Velocity = std::move(Parms.Velocity);

	if (BaseInfo != nullptr)
		*BaseInfo = std::move(Parms.BaseInfo);

	if (TickEndData != nullptr)
		*TickEndData = std::move(Parms.TickEndData);
}


// Function Mover.AsyncNavWalkingMode.GetTurnGenerator
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UAsyncNavWalkingMode::GetTurnGenerator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AsyncNavWalkingMode", "GetTurnGenerator");

	Params::AsyncNavWalkingMode_GetTurnGenerator Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.AsyncNavWalkingMode.SetTurnGeneratorClass
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UObject>              TurnGeneratorClass                                     (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAsyncNavWalkingMode::SetTurnGeneratorClass(TSubclassOf<class UObject> TurnGeneratorClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AsyncNavWalkingMode", "SetTurnGeneratorClass");

	Params::AsyncNavWalkingMode_SetTurnGeneratorClass Parms{};

	Parms.TurnGeneratorClass = TurnGeneratorClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.AsyncWalkingMode.GetTurnGenerator
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UAsyncWalkingMode::GetTurnGenerator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AsyncWalkingMode", "GetTurnGenerator");

	Params::AsyncWalkingMode_GetTurnGenerator Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.AsyncWalkingMode.SetTurnGeneratorClass
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UObject>              TurnGeneratorClass                                     (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAsyncWalkingMode::SetTurnGeneratorClass(TSubclassOf<class UObject> TurnGeneratorClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AsyncWalkingMode", "SetTurnGeneratorClass");

	Params::AsyncWalkingMode_SetTurnGeneratorClass Parms{};

	Parms.TurnGeneratorClass = TurnGeneratorClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.FallingMode.ProcessLanded
// (RequiredAPI, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFloorCheckResult&         FloorResult                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector*                         Velocity                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRelativeBaseInfo*               BaseInfo                                               (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMoverTickEndData*               TickEndData                                            (Parm, OutParm, NativeAccessSpecifierPublic)

void UFallingMode::ProcessLanded(const struct FFloorCheckResult& FloorResult, struct FVector* Velocity, struct FRelativeBaseInfo* BaseInfo, struct FMoverTickEndData* TickEndData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FallingMode", "ProcessLanded");

	Params::FallingMode_ProcessLanded Parms{};

	Parms.FloorResult = std::move(FloorResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Velocity != nullptr)
		*Velocity = std::move(Parms.Velocity);

	if (BaseInfo != nullptr)
		*BaseInfo = std::move(Parms.BaseInfo);

	if (TickEndData != nullptr)
		*TickEndData = std::move(Parms.TickEndData);
}


// Function Mover.WalkingMode.GetTurnGenerator
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UWalkingMode::GetTurnGenerator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WalkingMode", "GetTurnGenerator");

	Params::WalkingMode_GetTurnGenerator Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.WalkingMode.SetTurnGeneratorClass
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UObject>              TurnGeneratorClass                                     (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWalkingMode::SetTurnGeneratorClass(TSubclassOf<class UObject> TurnGeneratorClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WalkingMode", "SetTurnGeneratorClass");

	Params::WalkingMode_SetTurnGeneratorClass Parms{};

	Parms.TurnGeneratorClass = TurnGeneratorClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.AsyncMovementUtils.TestDepenetratingMove
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   StartLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     StartRotation                                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     TargetRotation                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldSweep                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 InOutMoveRecord                                        (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAsyncMovementUtils::TestDepenetratingMove(const struct FMovingComponentSet& MovingComps, const struct FVector& StartLocation, const struct FVector& TargetLocation, const struct FQuat& StartRotation, const struct FQuat& TargetRotation, bool bShouldSweep, struct FHitResult* OutHit, struct FMovementRecord& InOutMoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AsyncMovementUtils", "TestDepenetratingMove");

	Params::AsyncMovementUtils_TestDepenetratingMove Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.StartLocation = std::move(StartLocation);
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.StartRotation = std::move(StartRotation);
	Parms.TargetRotation = std::move(TargetRotation);
	Parms.bShouldSweep = bShouldSweep;
	Parms.InOutMoveRecord = std::move(InOutMoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	InOutMoveRecord = std::move(Parms.InOutMoveRecord);

	if (OutHit != nullptr)
		*OutHit = std::move(Parms.OutHit);

	return Parms.ReturnValue;
}


// Function Mover.AsyncMovementUtils.TestSlidingMoveAlongHitSurface
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   OriginalMoveDelta                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationAtHit                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     TargetRotation                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      InOutHit                                               (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 InOutMoveRecord                                        (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAsyncMovementUtils::TestSlidingMoveAlongHitSurface(const struct FMovingComponentSet& MovingComps, const struct FVector& OriginalMoveDelta, const struct FVector& LocationAtHit, const struct FQuat& TargetRotation, struct FHitResult& InOutHit, struct FMovementRecord& InOutMoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AsyncMovementUtils", "TestSlidingMoveAlongHitSurface");

	Params::AsyncMovementUtils_TestSlidingMoveAlongHitSurface Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.OriginalMoveDelta = std::move(OriginalMoveDelta);
	Parms.LocationAtHit = std::move(LocationAtHit);
	Parms.TargetRotation = std::move(TargetRotation);
	Parms.InOutHit = std::move(InOutHit);
	Parms.InOutMoveRecord = std::move(InOutMoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	InOutHit = std::move(Parms.InOutHit);
	InOutMoveRecord = std::move(Parms.InOutMoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.GetMovementBaseTransform
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       BoneName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FQuat*                           OutQuat                                                (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::GetMovementBaseTransform(const class UPrimitiveComponent* MovementBase, const class FName BoneName, struct FVector* OutLocation, struct FQuat* OutQuat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "GetMovementBaseTransform");

	Params::BasedMovementUtils_GetMovementBaseTransform Parms{};

	Parms.MovementBase = MovementBase;
	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocation != nullptr)
		*OutLocation = std::move(Parms.OutLocation);

	if (OutQuat != nullptr)
		*OutQuat = std::move(Parms.OutQuat);

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.IsADynamicBase
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::IsADynamicBase(const class UPrimitiveComponent* MovementBase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "IsADynamicBase");

	Params::BasedMovementUtils_IsADynamicBase Parms{};

	Parms.MovementBase = MovementBase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.IsBaseSimulatingPhysics
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::IsBaseSimulatingPhysics(const class UPrimitiveComponent* MovementBase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "IsBaseSimulatingPhysics");

	Params::BasedMovementUtils_IsBaseSimulatingPhysics Parms{};

	Parms.MovementBase = MovementBase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.TransformBasedDirectionToWorld
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       BoneName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocalDirection                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutDirectionWorldSpace                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::TransformBasedDirectionToWorld(const class UPrimitiveComponent* MovementBase, const class FName BoneName, const struct FVector& LocalDirection, struct FVector* OutDirectionWorldSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformBasedDirectionToWorld");

	Params::BasedMovementUtils_TransformBasedDirectionToWorld Parms{};

	Parms.MovementBase = MovementBase;
	Parms.BoneName = BoneName;
	Parms.LocalDirection = std::move(LocalDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDirectionWorldSpace != nullptr)
		*OutDirectionWorldSpace = std::move(Parms.OutDirectionWorldSpace);

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.TransformBasedLocationToWorld
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       BoneName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocalLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocationWorldSpace                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::TransformBasedLocationToWorld(const class UPrimitiveComponent* MovementBase, const class FName BoneName, const struct FVector& LocalLocation, struct FVector* OutLocationWorldSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformBasedLocationToWorld");

	Params::BasedMovementUtils_TransformBasedLocationToWorld Parms{};

	Parms.MovementBase = MovementBase;
	Parms.BoneName = BoneName;
	Parms.LocalLocation = std::move(LocalLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocationWorldSpace != nullptr)
		*OutLocationWorldSpace = std::move(Parms.OutLocationWorldSpace);

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.TransformBasedRotatorToWorld
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       BoneName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  LocalRotator                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator*                        OutWorldSpaceRotator                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::TransformBasedRotatorToWorld(const class UPrimitiveComponent* MovementBase, const class FName BoneName, const struct FRotator& LocalRotator, struct FRotator* OutWorldSpaceRotator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformBasedRotatorToWorld");

	Params::BasedMovementUtils_TransformBasedRotatorToWorld Parms{};

	Parms.MovementBase = MovementBase;
	Parms.BoneName = BoneName;
	Parms.LocalRotator = std::move(LocalRotator);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWorldSpaceRotator != nullptr)
		*OutWorldSpaceRotator = std::move(Parms.OutWorldSpaceRotator);

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.TransformDirectionToLocal
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FQuat&                     BaseQuat                                               (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldSpaceDirection                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocalDirection                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBasedMovementUtils::TransformDirectionToLocal(const struct FQuat& BaseQuat, const struct FVector& WorldSpaceDirection, struct FVector* OutLocalDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformDirectionToLocal");

	Params::BasedMovementUtils_TransformDirectionToLocal Parms{};

	Parms.BaseQuat = std::move(BaseQuat);
	Parms.WorldSpaceDirection = std::move(WorldSpaceDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocalDirection != nullptr)
		*OutLocalDirection = std::move(Parms.OutLocalDirection);
}


// Function Mover.BasedMovementUtils.TransformDirectionToWorld
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FQuat&                     BaseQuat                                               (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocalDirection                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutDirectionWorldSpace                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBasedMovementUtils::TransformDirectionToWorld(const struct FQuat& BaseQuat, const struct FVector& LocalDirection, struct FVector* OutDirectionWorldSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformDirectionToWorld");

	Params::BasedMovementUtils_TransformDirectionToWorld Parms{};

	Parms.BaseQuat = std::move(BaseQuat);
	Parms.LocalDirection = std::move(LocalDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDirectionWorldSpace != nullptr)
		*OutDirectionWorldSpace = std::move(Parms.OutDirectionWorldSpace);
}


// Function Mover.BasedMovementUtils.TransformLocationToLocal
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   BasePos                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     BaseQuat                                               (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldSpaceLocation                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocalLocation                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBasedMovementUtils::TransformLocationToLocal(const struct FVector& BasePos, const struct FQuat& BaseQuat, const struct FVector& WorldSpaceLocation, struct FVector* OutLocalLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformLocationToLocal");

	Params::BasedMovementUtils_TransformLocationToLocal Parms{};

	Parms.BasePos = std::move(BasePos);
	Parms.BaseQuat = std::move(BaseQuat);
	Parms.WorldSpaceLocation = std::move(WorldSpaceLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocalLocation != nullptr)
		*OutLocalLocation = std::move(Parms.OutLocalLocation);
}


// Function Mover.BasedMovementUtils.TransformLocationToWorld
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   BasePos                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     BaseQuat                                               (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocalLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocationWorldSpace                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBasedMovementUtils::TransformLocationToWorld(const struct FVector& BasePos, const struct FQuat& BaseQuat, const struct FVector& LocalLocation, struct FVector* OutLocationWorldSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformLocationToWorld");

	Params::BasedMovementUtils_TransformLocationToWorld Parms{};

	Parms.BasePos = std::move(BasePos);
	Parms.BaseQuat = std::move(BaseQuat);
	Parms.LocalLocation = std::move(LocalLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocationWorldSpace != nullptr)
		*OutLocationWorldSpace = std::move(Parms.OutLocationWorldSpace);
}


// Function Mover.BasedMovementUtils.TransformRotatorToLocal
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FQuat&                     BaseQuat                                               (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  WorldSpaceRotator                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator*                        OutLocalRotator                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBasedMovementUtils::TransformRotatorToLocal(const struct FQuat& BaseQuat, const struct FRotator& WorldSpaceRotator, struct FRotator* OutLocalRotator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformRotatorToLocal");

	Params::BasedMovementUtils_TransformRotatorToLocal Parms{};

	Parms.BaseQuat = std::move(BaseQuat);
	Parms.WorldSpaceRotator = std::move(WorldSpaceRotator);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocalRotator != nullptr)
		*OutLocalRotator = std::move(Parms.OutLocalRotator);
}


// Function Mover.BasedMovementUtils.TransformRotatorToWorld
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FQuat&                     BaseQuat                                               (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  LocalRotator                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator*                        OutWorldSpaceRotator                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBasedMovementUtils::TransformRotatorToWorld(const struct FQuat& BaseQuat, const struct FRotator& LocalRotator, struct FRotator* OutWorldSpaceRotator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformRotatorToWorld");

	Params::BasedMovementUtils_TransformRotatorToWorld Parms{};

	Parms.BaseQuat = std::move(BaseQuat);
	Parms.LocalRotator = std::move(LocalRotator);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWorldSpaceRotator != nullptr)
		*OutWorldSpaceRotator = std::move(Parms.OutWorldSpaceRotator);
}


// Function Mover.BasedMovementUtils.TransformWorldDirectionToBased
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       BoneName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldSpaceDirection                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocalDirection                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::TransformWorldDirectionToBased(const class UPrimitiveComponent* MovementBase, const class FName BoneName, const struct FVector& WorldSpaceDirection, struct FVector* OutLocalDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformWorldDirectionToBased");

	Params::BasedMovementUtils_TransformWorldDirectionToBased Parms{};

	Parms.MovementBase = MovementBase;
	Parms.BoneName = BoneName;
	Parms.WorldSpaceDirection = std::move(WorldSpaceDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocalDirection != nullptr)
		*OutLocalDirection = std::move(Parms.OutLocalDirection);

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.TransformWorldLocationToBased
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       BoneName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldSpaceLocation                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocalLocation                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::TransformWorldLocationToBased(const class UPrimitiveComponent* MovementBase, const class FName BoneName, const struct FVector& WorldSpaceLocation, struct FVector* OutLocalLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformWorldLocationToBased");

	Params::BasedMovementUtils_TransformWorldLocationToBased Parms{};

	Parms.MovementBase = MovementBase;
	Parms.BoneName = BoneName;
	Parms.WorldSpaceLocation = std::move(WorldSpaceLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocalLocation != nullptr)
		*OutLocalLocation = std::move(Parms.OutLocalLocation);

	return Parms.ReturnValue;
}


// Function Mover.BasedMovementUtils.TransformWorldRotatorToBased
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UPrimitiveComponent*        MovementBase                                           (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       BoneName                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  WorldSpaceRotator                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator*                        OutLocalRotator                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBasedMovementUtils::TransformWorldRotatorToBased(const class UPrimitiveComponent* MovementBase, const class FName BoneName, const struct FRotator& WorldSpaceRotator, struct FRotator* OutLocalRotator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BasedMovementUtils", "TransformWorldRotatorToBased");

	Params::BasedMovementUtils_TransformWorldRotatorToBased Parms{};

	Parms.MovementBase = MovementBase;
	Parms.BoneName = BoneName;
	Parms.WorldSpaceRotator = std::move(WorldSpaceRotator);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocalRotator != nullptr)
		*OutLocalRotator = std::move(Parms.OutLocalRotator);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ApplyGravityToOrientationIntent
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  IntendedOrientation                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FQuat&                     WorldToGravity                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStayVertical                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UMovementUtils::ApplyGravityToOrientationIntent(const struct FRotator& IntendedOrientation, const struct FQuat& WorldToGravity, bool bStayVertical)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ApplyGravityToOrientationIntent");

	Params::MovementUtils_ApplyGravityToOrientationIntent Parms{};

	Parms.IntendedOrientation = std::move(IntendedOrientation);
	Parms.WorldToGravity = std::move(WorldToGravity);
	Parms.bStayVertical = bStayVertical;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.CanEscapeGravity
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   PriorVelocity                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NewVelocity                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   GravityAccel                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::CanEscapeGravity(const struct FVector& PriorVelocity, const struct FVector& NewVelocity, const struct FVector& GravityAccel, float DeltaSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "CanEscapeGravity");

	Params::MovementUtils_CanEscapeGravity Parms{};

	Parms.PriorVelocity = std::move(PriorVelocity);
	Parms.NewVelocity = std::move(NewVelocity);
	Parms.GravityAccel = std::move(GravityAccel);
	Parms.DeltaSeconds = DeltaSeconds;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ComputeAngularVelocity
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  From                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  To                                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FQuat&                     WorldToGravity                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TurningRateLimit                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UMovementUtils::ComputeAngularVelocity(const struct FRotator& From, const struct FRotator& To, const struct FQuat& WorldToGravity, float DeltaSeconds, float TurningRateLimit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ComputeAngularVelocity");

	Params::MovementUtils_ComputeAngularVelocity Parms{};

	Parms.From = std::move(From);
	Parms.To = std::move(To);
	Parms.WorldToGravity = std::move(WorldToGravity);
	Parms.DeltaSeconds = DeltaSeconds;
	Parms.TurningRateLimit = TurningRateLimit;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ComputeCombinedVelocity
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FComputeCombinedVelocityParams&InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ComputeCombinedVelocity(const struct FComputeCombinedVelocityParams& InParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ComputeCombinedVelocity");

	Params::MovementUtils_ComputeCombinedVelocity Parms{};

	Parms.InParams = std::move(InParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ComputeDirectionIntent
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   MoveInput                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMoveInputType                          MoveInputType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxSpeed                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ComputeDirectionIntent(const struct FVector& MoveInput, EMoveInputType MoveInputType, float MaxSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ComputeDirectionIntent");

	Params::MovementUtils_ComputeDirectionIntent Parms{};

	Parms.MoveInput = std::move(MoveInput);
	Parms.MoveInputType = MoveInputType;
	Parms.MaxSpeed = MaxSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ComputeSlideDelta
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             PctOfDeltaToMove                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Normal                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ComputeSlideDelta(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, const float PctOfDeltaToMove, const struct FVector& Normal, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ComputeSlideDelta");

	Params::MovementUtils_ComputeSlideDelta Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.PctOfDeltaToMove = PctOfDeltaToMove;
	Parms.Normal = std::move(Normal);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ComputeVelocity
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FComputeVelocityParams&    InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ComputeVelocity(const struct FComputeVelocityParams& InParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ComputeVelocity");

	Params::MovementUtils_ComputeVelocity Parms{};

	Parms.InParams = std::move(InParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ComputeVelocityFromGravity
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   GravityAccel                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ComputeVelocityFromGravity(const struct FVector& GravityAccel, float DeltaSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ComputeVelocityFromGravity");

	Params::MovementUtils_ComputeVelocityFromGravity Parms{};

	Parms.GravityAccel = std::move(GravityAccel);
	Parms.DeltaSeconds = DeltaSeconds;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ComputeVelocityFromPositions
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   FromPos                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ToPos                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ComputeVelocityFromPositions(const struct FVector& FromPos, const struct FVector& ToPos, float DeltaSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ComputeVelocityFromPositions");

	Params::MovementUtils_ComputeVelocityFromPositions Parms{};

	Parms.FromPos = std::move(FromPos);
	Parms.ToPos = std::move(ToPos);
	Parms.DeltaSeconds = DeltaSeconds;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ConstrainToPlane
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Vector                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FPlane&                    MovementPlane                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bMaintainMagnitude                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ConstrainToPlane(const struct FVector& Vector, const struct FPlane& MovementPlane, bool bMaintainMagnitude)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ConstrainToPlane");

	Params::MovementUtils_ConstrainToPlane Parms{};

	Parms.Vector = std::move(Vector);
	Parms.MovementPlane = std::move(MovementPlane);
	Parms.bMaintainMagnitude = bMaintainMagnitude;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.DeduceUpDirectionFromGravity
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   GravityAcceleration                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::DeduceUpDirectionFromGravity(const struct FVector& GravityAcceleration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "DeduceUpDirectionFromGravity");

	Params::MovementUtils_DeduceUpDirectionFromGravity Parms{};

	Parms.GravityAcceleration = std::move(GravityAcceleration);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.FindTeleportSpot
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UMoverComponent*            MoverComp                                              (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector&                         TestLocation                                           (Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  TestRotation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::FindTeleportSpot(const class UMoverComponent* MoverComp, struct FVector& TestLocation, const struct FRotator& TestRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "FindTeleportSpot");

	Params::MovementUtils_FindTeleportSpot Parms{};

	Parms.MoverComp = MoverComp;
	Parms.TestLocation = std::move(TestLocation);
	Parms.TestRotation = std::move(TestRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	TestLocation = std::move(Parms.TestLocation);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.GetGravityVerticalComponent
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Vector                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   UpDirection                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::GetGravityVerticalComponent(const struct FVector& Vector, const struct FVector& UpDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "GetGravityVerticalComponent");

	Params::MovementUtils_GetGravityVerticalComponent Parms{};

	Parms.Vector = std::move(Vector);
	Parms.UpDirection = std::move(UpDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.IsAngularVelocityZero
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  AngularVelocity                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::IsAngularVelocityZero(const struct FRotator& AngularVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "IsAngularVelocityZero");

	Params::MovementUtils_IsAngularVelocityZero Parms{};

	Parms.AngularVelocity = std::move(AngularVelocity);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.IsExceedingMaxSpeed
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Velocity                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InMaxSpeed                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::IsExceedingMaxSpeed(const struct FVector& Velocity, float InMaxSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "IsExceedingMaxSpeed");

	Params::MovementUtils_IsExceedingMaxSpeed Parms{};

	Parms.Velocity = std::move(Velocity);
	Parms.InMaxSpeed = InMaxSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.ProjectToGravityFloor
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Vector                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   UpDirection                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UMovementUtils::ProjectToGravityFloor(const struct FVector& Vector, const struct FVector& UpDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "ProjectToGravityFloor");

	Params::MovementUtils_ProjectToGravityFloor Parms{};

	Parms.Vector = std::move(Vector);
	Parms.UpDirection = std::move(UpDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TestEncroachment
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class UMoverComponent*            MoverComp                                              (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TestLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  TestRotation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::TestEncroachment(const class UMoverComponent* MoverComp, const struct FVector& TestLocation, const struct FRotator& TestRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TestEncroachment");

	Params::MovementUtils_TestEncroachment Parms{};

	Parms.MoverComp = MoverComp;
	Parms.TestLocation = std::move(TestLocation);
	Parms.TestRotation = std::move(TestRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TestEncroachmentAndAdjust
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UMoverComponent*            MoverComp                                              (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TestLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  TestRotation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         OutProposedAdjustment                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::TestEncroachmentAndAdjust(const class UMoverComponent* MoverComp, const struct FVector& TestLocation, const struct FRotator& TestRotation, struct FVector* OutProposedAdjustment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TestEncroachmentAndAdjust");

	Params::MovementUtils_TestEncroachmentAndAdjust Parms{};

	Parms.MoverComp = MoverComp;
	Parms.TestLocation = std::move(TestLocation);
	Parms.TestRotation = std::move(TestRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutProposedAdjustment != nullptr)
		*OutProposedAdjustment = std::move(Parms.OutProposedAdjustment);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TryMoveToSlideAlongSurface
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PctOfDeltaToMove                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Normal                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      Hit                                                    (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bHandleImpact                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 MoveRecord                                             (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UMovementUtils::TryMoveToSlideAlongSurface(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, float PctOfDeltaToMove, const struct FQuat& Rotation, const struct FVector& Normal, struct FHitResult& Hit, bool bHandleImpact, struct FMovementRecord& MoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TryMoveToSlideAlongSurface");

	Params::MovementUtils_TryMoveToSlideAlongSurface Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.PctOfDeltaToMove = PctOfDeltaToMove;
	Parms.Rotation = std::move(Rotation);
	Parms.Normal = std::move(Normal);
	Parms.Hit = std::move(Hit);
	Parms.bHandleImpact = bHandleImpact;
	Parms.MoveRecord = std::move(MoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Hit = std::move(Parms.Hit);
	MoveRecord = std::move(Parms.MoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TryMoveToSlideAlongSurfaceNoMovementRecord
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PctOfDeltaToMove                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     Rotation                                               (ConstParm, Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Normal                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      Hit                                                    (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bHandleImpact                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UMovementUtils::TryMoveToSlideAlongSurfaceNoMovementRecord(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, float PctOfDeltaToMove, const struct FQuat& Rotation, const struct FVector& Normal, struct FHitResult& Hit, bool bHandleImpact)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TryMoveToSlideAlongSurfaceNoMovementRecord");

	Params::MovementUtils_TryMoveToSlideAlongSurfaceNoMovementRecord Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.PctOfDeltaToMove = PctOfDeltaToMove;
	Parms.Rotation = std::move(Rotation);
	Parms.Normal = std::move(Normal);
	Parms.Hit = std::move(Hit);
	Parms.bHandleImpact = bHandleImpact;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Hit = std::move(Parms.Hit);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TrySafeMoveAndSlideUpdatedComponent
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     NewRotation                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSweep                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      OutHit                                                 (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// ETeleportType                           Teleport                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 MoveRecord                                             (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bSlideAlongSurface                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UMovementUtils::TrySafeMoveAndSlideUpdatedComponent(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, const struct FQuat& NewRotation, bool bSweep, struct FHitResult& OutHit, ETeleportType Teleport, struct FMovementRecord& MoveRecord, bool bSlideAlongSurface)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TrySafeMoveAndSlideUpdatedComponent");

	Params::MovementUtils_TrySafeMoveAndSlideUpdatedComponent Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.NewRotation = std::move(NewRotation);
	Parms.bSweep = bSweep;
	Parms.OutHit = std::move(OutHit);
	Parms.Teleport = Teleport;
	Parms.MoveRecord = std::move(MoveRecord);
	Parms.bSlideAlongSurface = bSlideAlongSurface;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	OutHit = std::move(Parms.OutHit);
	MoveRecord = std::move(Parms.MoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TrySafeMoveAndSlideUpdatedComponentNoMovementRecord
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     NewRotation                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSweep                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      OutHit                                                 (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// ETeleportType                           Teleport                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSlideAlongSurface                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UMovementUtils::TrySafeMoveAndSlideUpdatedComponentNoMovementRecord(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, const struct FQuat& NewRotation, bool bSweep, struct FHitResult& OutHit, ETeleportType Teleport, bool bSlideAlongSurface)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TrySafeMoveAndSlideUpdatedComponentNoMovementRecord");

	Params::MovementUtils_TrySafeMoveAndSlideUpdatedComponentNoMovementRecord Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.NewRotation = std::move(NewRotation);
	Parms.bSweep = bSweep;
	Parms.OutHit = std::move(OutHit);
	Parms.Teleport = Teleport;
	Parms.bSlideAlongSurface = bSlideAlongSurface;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	OutHit = std::move(Parms.OutHit);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TrySafeMoveUpdatedComponent
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     NewRotation                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSweep                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      OutHit                                                 (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// ETeleportType                           Teleport                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMovementRecord&                 MoveRecord                                             (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::TrySafeMoveUpdatedComponent(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, const struct FQuat& NewRotation, bool bSweep, struct FHitResult& OutHit, ETeleportType Teleport, struct FMovementRecord& MoveRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TrySafeMoveUpdatedComponent");

	Params::MovementUtils_TrySafeMoveUpdatedComponent Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.NewRotation = std::move(NewRotation);
	Parms.bSweep = bSweep;
	Parms.OutHit = std::move(OutHit);
	Parms.Teleport = Teleport;
	Parms.MoveRecord = std::move(MoveRecord);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	OutHit = std::move(Parms.OutHit);
	MoveRecord = std::move(Parms.MoveRecord);

	return Parms.ReturnValue;
}


// Function Mover.MovementUtils.TrySafeMoveUpdatedComponentNoMovementRecord
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FMovingComponentSet&       MovingComps                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     NewRotation                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSweep                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult&                      OutHit                                                 (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// ETeleportType                           Teleport                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMovementUtils::TrySafeMoveUpdatedComponentNoMovementRecord(const struct FMovingComponentSet& MovingComps, const struct FVector& Delta, const struct FQuat& NewRotation, bool bSweep, struct FHitResult& OutHit, ETeleportType Teleport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MovementUtils", "TrySafeMoveUpdatedComponentNoMovementRecord");

	Params::MovementUtils_TrySafeMoveUpdatedComponentNoMovementRecord Parms{};

	Parms.MovingComps = std::move(MovingComps);
	Parms.Delta = std::move(Delta);
	Parms.NewRotation = std::move(NewRotation);
	Parms.bSweep = bSweep;
	Parms.OutHit = std::move(OutHit);
	Parms.Teleport = Teleport;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	OutHit = std::move(Parms.OutHit);

	return Parms.ReturnValue;
}


// Function Mover.PlayMoverMontageCallbackProxy.CreateProxyObjectForPlayMoverMontage
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UMoverComponent*                  InMoverComponent                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PlayRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StartingPosition                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartingSection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPlayMoverMontageCallbackProxy*   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPlayMoverMontageCallbackProxy* UPlayMoverMontageCallbackProxy::CreateProxyObjectForPlayMoverMontage(class UMoverComponent* InMoverComponent, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, class FName StartingSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PlayMoverMontageCallbackProxy", "CreateProxyObjectForPlayMoverMontage");

	Params::PlayMoverMontageCallbackProxy_CreateProxyObjectForPlayMoverMontage Parms{};

	Parms.InMoverComponent = InMoverComponent;
	Parms.MontageToPlay = MontageToPlay;
	Parms.PlayRate = PlayRate;
	Parms.StartingPosition = StartingPosition;
	Parms.StartingSection = StartingSection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.PlayMoverMontageCallbackProxy.OnMoverMontageEnded
// (Final, RequiredAPI, Native, Protected)
// Parameters:
// class FName                             IgnoredNotifyName                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayMoverMontageCallbackProxy::OnMoverMontageEnded(class FName IgnoredNotifyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayMoverMontageCallbackProxy", "OnMoverMontageEnded");

	Params::PlayMoverMontageCallbackProxy_OnMoverMontageEnded Parms{};

	Parms.IgnoredNotifyName = IgnoredNotifyName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Mover.MoverSimulation.GetBlackboard_Mutable
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UMoverBlackboard*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMoverBlackboard* UMoverSimulation::GetBlackboard_Mutable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverSimulation", "GetBlackboard_Mutable");

	Params::MoverSimulation_GetBlackboard_Mutable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Mover.MoverSimulation.GetBlackboard
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UMoverBlackboard*           ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UMoverBlackboard* UMoverSimulation::GetBlackboard() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverSimulation", "GetBlackboard");

	Params::MoverSimulation_GetBlackboard Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


SDK_NAMESPACE_END
