#pragma once

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

// Package: BPF_Libraly

#include "Basic.hpp"

#include "BPF_Libraly_classes.hpp"
#include "BPF_Libraly_parameters.hpp"


SDK_NAMESPACE_START

// Function BPF_Libraly.BPF_Libraly_C.AddForceComponentCheck
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           TargetActor                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UPrimitiveComponent**             PrimitiveComp                                          (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// bool*                                   State                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::AddForceComponentCheck(class AActor* TargetActor, class UObject* __WorldContext, class UPrimitiveComponent** PrimitiveComp, bool* State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "AddForceComponentCheck");

	Params::BPF_Libraly_C_AddForceComponentCheck Parms{};

	Parms.TargetActor = TargetActor;
	Parms.__WorldContext = __WorldContext;

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

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

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


// Function BPF_Libraly.BPF_Libraly_C.Attraction
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  kp                                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  kd                                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   TargetPosition                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   CurrentPosition                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UPrimitiveComponent*              Pritmitive                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FVector*                         Force                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::Attraction(double kp, double kd, const struct FVector& TargetPosition, const struct FVector& CurrentPosition, class UPrimitiveComponent* Pritmitive, class UObject* __WorldContext, struct FVector* Force)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "Attraction");

	Params::BPF_Libraly_C_Attraction Parms{};

	Parms.kp = kp;
	Parms.kd = kd;
	Parms.TargetPosition = std::move(TargetPosition);
	Parms.CurrentPosition = std::move(CurrentPosition);
	Parms.Pritmitive = Pritmitive;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.CameraViewCheck
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   A                                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   B                                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Field_of_View                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Aspect_Ratio                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   Return_Value                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::CameraViewCheck(const struct FVector& A, const struct FVector& B, double Field_of_View, double Aspect_Ratio, class UObject* __WorldContext, bool* Return_Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "CameraViewCheck");

	Params::BPF_Libraly_C_CameraViewCheck Parms{};

	Parms.A = std::move(A);
	Parms.B = std::move(B);
	Parms.Field_of_View = Field_of_View;
	Parms.Aspect_Ratio = Aspect_Ratio;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.CentorCursor
// (Static, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::CentorCursor(class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "CentorCursor");

	Params::BPF_Libraly_C_CentorCursor Parms{};

	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.CheckMatchKeys
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class FString>&                  NeedKeys                                               (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// TArray<class FString>&                  CheckKeys                                              (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   Return                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::CheckMatchKeys(TArray<class FString>& NeedKeys, TArray<class FString>& CheckKeys, class UObject* __WorldContext, bool* Return)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "CheckMatchKeys");

	Params::BPF_Libraly_C_CheckMatchKeys Parms{};

	Parms.NeedKeys = std::move(NeedKeys);
	Parms.CheckKeys = std::move(CheckKeys);
	Parms.__WorldContext = __WorldContext;

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

	NeedKeys = std::move(Parms.NeedKeys);
	CheckKeys = std::move(Parms.CheckKeys);

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


// Function BPF_Libraly.BPF_Libraly_C.CountDownText
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  TimerValue                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Show_decimal_point                                     (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class FText*                            ReturnText                                             (Parm, OutParm)

void UBPF_Libraly_C::CountDownText(double TimerValue, bool Show_decimal_point, class UObject* __WorldContext, class FText* ReturnText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "CountDownText");

	Params::BPF_Libraly_C_CountDownText Parms{};

	Parms.TimerValue = TimerValue;
	Parms.Show_decimal_point = Show_decimal_point;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.CustomAddWidget
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UClass*                           WidgetClass                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UUserWidget*&                     Variable                                               (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, InstancedReference, ReferenceParm, NoDestructor, HasGetValueTypeHash)
// int32                                   ZOrder                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Ignore                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UWidget**                         CreatedeWidget                                         (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::CustomAddWidget(class UClass* WidgetClass, class UUserWidget*& Variable, int32 ZOrder, bool Ignore, class UObject* __WorldContext, class UWidget** CreatedeWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "CustomAddWidget");

	Params::BPF_Libraly_C_CustomAddWidget Parms{};

	Parms.WidgetClass = WidgetClass;
	Parms.Variable = Variable;
	Parms.ZOrder = ZOrder;
	Parms.Ignore = Ignore;
	Parms.__WorldContext = __WorldContext;

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

	Variable = Parms.Variable;

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


// Function BPF_Libraly.BPF_Libraly_C.CustomGetGameInstance
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UBPGI_Main_C**                    GameInstance                                           (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::CustomGetGameInstance(class UObject* __WorldContext, class UBPGI_Main_C** GameInstance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "CustomGetGameInstance");

	Params::BPF_Libraly_C_CustomGetGameInstance Parms{};

	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.CustomTruncate
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double&                                 Variable                                               (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   NumberOfDigits                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::CustomTruncate(double& Variable, int32 NumberOfDigits, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "CustomTruncate");

	Params::BPF_Libraly_C_CustomTruncate Parms{};

	Parms.Variable = Variable;
	Parms.NumberOfDigits = NumberOfDigits;
	Parms.__WorldContext = __WorldContext;

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

	Variable = Parms.Variable;
}


// Function BPF_Libraly.BPF_Libraly_C.DebugDrawLine
// (Static, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   SelfPositon                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   Direction                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Length                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  DrawTime                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::DebugDrawLine(const struct FVector& SelfPositon, const struct FVector& Direction, double Length, double DrawTime, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "DebugDrawLine");

	Params::BPF_Libraly_C_DebugDrawLine Parms{};

	Parms.SelfPositon = std::move(SelfPositon);
	Parms.Direction = std::move(Direction);
	Parms.Length = Length;
	Parms.DrawTime = DrawTime;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.DivideSet
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double&                                 Variable                                               (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  DivideValue1                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  DivideValue2                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::DivideSet(double& Variable, double DivideValue1, double DivideValue2, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "DivideSet");

	Params::BPF_Libraly_C_DivideSet Parms{};

	Parms.Variable = Variable;
	Parms.DivideValue1 = DivideValue1;
	Parms.DivideValue2 = DivideValue2;
	Parms.__WorldContext = __WorldContext;

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

	Variable = Parms.Variable;
}


// Function BPF_Libraly.BPF_Libraly_C.FullToHarfNumberString
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    String                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class FString*                          Rezult                                                 (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash)

void UBPF_Libraly_C::FullToHarfNumberString(const class FString& String, class UObject* __WorldContext, class FString* Rezult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "FullToHarfNumberString");

	Params::BPF_Libraly_C_FullToHarfNumberString Parms{};

	Parms.String = std::move(String);
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.GetChildComponentByClass
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class USceneComponent*                  Target                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class UClass*                           Class_0                                                (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class USceneComponent**                 Compoent                                               (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::GetChildComponentByClass(class USceneComponent* Target, class UClass* Class_0, class UObject* __WorldContext, class USceneComponent** Compoent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "GetChildComponentByClass");

	Params::BPF_Libraly_C_GetChildComponentByClass Parms{};

	Parms.Target = Target;
	Parms.Class_0 = Class_0;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.GetCollisionSound
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// EHitMaterial                            MaterialType                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class USoundBase**                      Sound                                                  (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::GetCollisionSound(EHitMaterial MaterialType, class UObject* __WorldContext, class USoundBase** Sound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "GetCollisionSound");

	Params::BPF_Libraly_C_GetCollisionSound Parms{};

	Parms.MaterialType = MaterialType;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.GetLookatForwardVector
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AActor*                           Start                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Target                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FVector*                         Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::GetLookatForwardVector(class AActor* Start, class AActor* Target, class UObject* __WorldContext, struct FVector* Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "GetLookatForwardVector");

	Params::BPF_Libraly_C_GetLookatForwardVector Parms{};

	Parms.Start = Start;
	Parms.Target = Target;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.GetLookatRotation
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AActor*                           Start                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Target                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FRotator*                        Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor)

void UBPF_Libraly_C::GetLookatRotation(class AActor* Start, class AActor* Target, class UObject* __WorldContext, struct FRotator* Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "GetLookatRotation");

	Params::BPF_Libraly_C_GetLookatRotation Parms{};

	Parms.Start = Start;
	Parms.Target = Target;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.GetMarkup
// (Static, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    Front                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    Back                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    Source                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::GetMarkup(const class FString& Front, const class FString& Back, const class FString& Source, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "GetMarkup");

	Params::BPF_Libraly_C_GetMarkup Parms{};

	Parms.Front = std::move(Front);
	Parms.Back = std::move(Back);
	Parms.Source = std::move(Source);
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.GetYawOnlyRotation
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const struct FRotator&                  Rotation                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FRotator*                        NewParam                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor)

void UBPF_Libraly_C::GetYawOnlyRotation(const struct FRotator& Rotation, class UObject* __WorldContext, struct FRotator* NewParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "GetYawOnlyRotation");

	Params::BPF_Libraly_C_GetYawOnlyRotation Parms{};

	Parms.Rotation = std::move(Rotation);
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.InitializeTransform
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FTransform*                      Transform                                              (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::InitializeTransform(class UObject* __WorldContext, struct FTransform* Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "InitializeTransform");

	Params::BPF_Libraly_C_InitializeTransform Parms{};

	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.LerpIdleWalk
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  DeltaTime                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  LerpSpeed                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           SourceObject                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UCharacterMovementComponent*      CharacterMovementComp                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// double&                                 NormalizeSpeed                                         (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector&                         BeforeVector                                           (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector&                         VectorSpeed                                            (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  MultiplySpeed                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::LerpIdleWalk(double DeltaTime, double LerpSpeed, class AActor* SourceObject, class UCharacterMovementComponent* CharacterMovementComp, double& NormalizeSpeed, struct FVector& BeforeVector, struct FVector& VectorSpeed, double MultiplySpeed, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "LerpIdleWalk");

	Params::BPF_Libraly_C_LerpIdleWalk Parms{};

	Parms.DeltaTime = DeltaTime;
	Parms.LerpSpeed = LerpSpeed;
	Parms.SourceObject = SourceObject;
	Parms.CharacterMovementComp = CharacterMovementComp;
	Parms.NormalizeSpeed = NormalizeSpeed;
	Parms.BeforeVector = std::move(BeforeVector);
	Parms.VectorSpeed = std::move(VectorSpeed);
	Parms.MultiplySpeed = MultiplySpeed;
	Parms.__WorldContext = __WorldContext;

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

	NormalizeSpeed = Parms.NormalizeSpeed;
	BeforeVector = std::move(Parms.BeforeVector);
	VectorSpeed = std::move(Parms.VectorSpeed);
}


// Function BPF_Libraly.BPF_Libraly_C.LerpIdleWalkMover
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double                                  DeltaTime                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  LerpSpeed                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           SourceObject                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double&                                 NormalizeSpeed                                         (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector&                         BeforeVector                                           (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// struct FVector&                         VectorSpeed                                            (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  MultiplySpeed                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  MaxSpeed                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::LerpIdleWalkMover(double DeltaTime, double LerpSpeed, class AActor* SourceObject, double& NormalizeSpeed, struct FVector& BeforeVector, struct FVector& VectorSpeed, double MultiplySpeed, double MaxSpeed, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "LerpIdleWalkMover");

	Params::BPF_Libraly_C_LerpIdleWalkMover Parms{};

	Parms.DeltaTime = DeltaTime;
	Parms.LerpSpeed = LerpSpeed;
	Parms.SourceObject = SourceObject;
	Parms.NormalizeSpeed = NormalizeSpeed;
	Parms.BeforeVector = std::move(BeforeVector);
	Parms.VectorSpeed = std::move(VectorSpeed);
	Parms.MultiplySpeed = MultiplySpeed;
	Parms.MaxSpeed = MaxSpeed;
	Parms.__WorldContext = __WorldContext;

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

	NormalizeSpeed = Parms.NormalizeSpeed;
	BeforeVector = std::move(Parms.BeforeVector);
	VectorSpeed = std::move(Parms.VectorSpeed);
}


// Function BPF_Libraly.BPF_Libraly_C.LocalizeInputKey
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    Text                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// const class FString&                    DeviceName                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class FString*                          ReturnText                                             (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash)

void UBPF_Libraly_C::LocalizeInputKey(const class FString& Text, const class FString& DeviceName, class UObject* __WorldContext, class FString* ReturnText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "LocalizeInputKey");

	Params::BPF_Libraly_C_LocalizeInputKey Parms{};

	Parms.Text = std::move(Text);
	Parms.DeviceName = std::move(DeviceName);
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.LocalSaveBool
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const bool&                             InValue                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::LocalSaveBool(const bool& InValue, class UObject* __WorldContext, bool* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "LocalSaveBool");

	Params::BPF_Libraly_C_LocalSaveBool Parms{};

	Parms.InValue = InValue;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.LocalSaveFloat
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const double&                           InValue                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double*                                 Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::LocalSaveFloat(const double& InValue, class UObject* __WorldContext, double* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "LocalSaveFloat");

	Params::BPF_Libraly_C_LocalSaveFloat Parms{};

	Parms.InValue = InValue;
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.MakeUniqueActorsArray
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class AActor*>&                  Actors                                                 (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// TArray<class AActor*>*                  UniqueActors                                           (Parm, OutParm)

void UBPF_Libraly_C::MakeUniqueActorsArray(TArray<class AActor*>& Actors, class UObject* __WorldContext, TArray<class AActor*>* UniqueActors)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "MakeUniqueActorsArray");

	Params::BPF_Libraly_C_MakeUniqueActorsArray Parms{};

	Parms.Actors = std::move(Actors);
	Parms.__WorldContext = __WorldContext;

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

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

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


// Function BPF_Libraly.BPF_Libraly_C.MinusEqual
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double&                                 Variable                                               (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  PlusValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::MinusEqual(double& Variable, double PlusValue, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "MinusEqual");

	Params::BPF_Libraly_C_MinusEqual Parms{};

	Parms.Variable = Variable;
	Parms.PlusValue = PlusValue;
	Parms.__WorldContext = __WorldContext;

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

	Variable = Parms.Variable;
}


// Function BPF_Libraly.BPF_Libraly_C.NewCameraViewCheck
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FRotator&                  A                                                      (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor)
// double                                  Field_of_View                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Aspect_Ratio                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   B_Vector                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool*                                   Return_Value                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::NewCameraViewCheck(const struct FRotator& A, double Field_of_View, double Aspect_Ratio, const struct FVector& B_Vector, class UObject* __WorldContext, bool* Return_Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "NewCameraViewCheck");

	Params::BPF_Libraly_C_NewCameraViewCheck Parms{};

	Parms.A = std::move(A);
	Parms.Field_of_View = Field_of_View;
	Parms.Aspect_Ratio = Aspect_Ratio;
	Parms.B_Vector = std::move(B_Vector);
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.ParryStanEffect
// (Static, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Player                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Target                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  Distance                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    Mini                                                   (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::ParryStanEffect(class AActor* Player, class AActor* Target, double Distance, bool Mini, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "ParryStanEffect");

	Params::BPF_Libraly_C_ParryStanEffect Parms{};

	Parms.Player = Player;
	Parms.Target = Target;
	Parms.Distance = Distance;
	Parms.Mini = Mini;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.PlaySoundAndReportNoise
// (Static, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USoundBase*                       Sound                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const struct FVector&                   Location                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   VolumeMultiplier                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   PitchMultiplier                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// float                                   StartTime                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class USoundAttenuation*                AttenuationSettings                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class USoundConcurrency*                ConcurrencySettings                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// const class AActor*                     OwningActor                                            (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// float                                   MaxRange                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class FName                             Tag                                                    (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class AActor*                           Instigator                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    DebugDraw                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::PlaySoundAndReportNoise(class USoundBase* Sound, const struct FVector& Location, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundAttenuation* AttenuationSettings, class USoundConcurrency* ConcurrencySettings, const class AActor* OwningActor, float MaxRange, class FName Tag, class AActor* Instigator, bool DebugDraw, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "PlaySoundAndReportNoise");

	Params::BPF_Libraly_C_PlaySoundAndReportNoise Parms{};

	Parms.Sound = Sound;
	Parms.Location = std::move(Location);
	Parms.VolumeMultiplier = VolumeMultiplier;
	Parms.PitchMultiplier = PitchMultiplier;
	Parms.StartTime = StartTime;
	Parms.AttenuationSettings = AttenuationSettings;
	Parms.ConcurrencySettings = ConcurrencySettings;
	Parms.OwningActor = OwningActor;
	Parms.MaxRange = MaxRange;
	Parms.Tag = Tag;
	Parms.Instigator = Instigator;
	Parms.DebugDraw = DebugDraw;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.PlusEqual
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double&                                 Variable                                               (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  PlusValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::PlusEqual(double& Variable, double PlusValue, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "PlusEqual");

	Params::BPF_Libraly_C_PlusEqual Parms{};

	Parms.Variable = Variable;
	Parms.PlusValue = PlusValue;
	Parms.__WorldContext = __WorldContext;

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

	Variable = Parms.Variable;
}


// Function BPF_Libraly.BPF_Libraly_C.PlusEqualWithClamp
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// double&                                 Variable                                               (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  PlusValue                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  min_0                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  max_0                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::PlusEqualWithClamp(double& Variable, double PlusValue, double min_0, double max_0, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "PlusEqualWithClamp");

	Params::BPF_Libraly_C_PlusEqualWithClamp Parms{};

	Parms.Variable = Variable;
	Parms.PlusValue = PlusValue;
	Parms.min_0 = min_0;
	Parms.max_0 = max_0;
	Parms.__WorldContext = __WorldContext;

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

	Variable = Parms.Variable;
}


// Function BPF_Libraly.BPF_Libraly_C.RayTraceFront
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USceneComponent*                  Component                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// double                                  StartAddPosition                                       (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// double                                  Length                                                 (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// ETraceTypeQuery                         TraceChannel                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    bTraceComplex                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// const TArray<class AActor*>&            ActorsToIgnore                                         (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// EDrawDebugTrace                         DrawDebugType                                          (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

bool UBPF_Libraly_C::RayTraceFront(class USceneComponent* Component, double StartAddPosition, double Length, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, EDrawDebugTrace DrawDebugType, class UObject* __WorldContext, struct FHitResult* OutHit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "RayTraceFront");

	Params::BPF_Libraly_C_RayTraceFront Parms{};

	Parms.Component = Component;
	Parms.StartAddPosition = StartAddPosition;
	Parms.Length = Length;
	Parms.TraceChannel = TraceChannel;
	Parms.bTraceComplex = bTraceComplex;
	Parms.ActorsToIgnore = std::move(ActorsToIgnore);
	Parms.DrawDebugType = DrawDebugType;
	Parms.__WorldContext = __WorldContext;

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

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

	return Parms.ReturnValue;
}


// Function BPF_Libraly.BPF_Libraly_C.RemoveAndClear
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UWidget*&                         Widget                                                 (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ZeroConstructor, InstancedReference, ReferenceParm, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::RemoveAndClear(class UWidget*& Widget, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "RemoveAndClear");

	Params::BPF_Libraly_C_RemoveAndClear Parms{};

	Parms.Widget = Widget;
	Parms.__WorldContext = __WorldContext;

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

	Widget = Parms.Widget;
}


// Function BPF_Libraly.BPF_Libraly_C.ReplaceSaveText
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FString&                    InputText                                              (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class FString*                          OutPutText                                             (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash)

void UBPF_Libraly_C::ReplaceSaveText(const class FString& InputText, class UObject* __WorldContext, class FString* OutPutText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "ReplaceSaveText");

	Params::BPF_Libraly_C_ReplaceSaveText Parms{};

	Parms.InputText = std::move(InputText);
	Parms.__WorldContext = __WorldContext;

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

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


// Function BPF_Libraly.BPF_Libraly_C.RitchTextMarkupArray
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class FString>&                  StringArray                                            (BlueprintVisible, BlueprintReadOnly, Parm, OutParm, ReferenceParm)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// TArray<class FString>*                  ReturnStrings                                          (Parm, OutParm)

void UBPF_Libraly_C::RitchTextMarkupArray(TArray<class FString>& StringArray, class UObject* __WorldContext, TArray<class FString>* ReturnStrings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "RitchTextMarkupArray");

	Params::BPF_Libraly_C_RitchTextMarkupArray Parms{};

	Parms.StringArray = std::move(StringArray);
	Parms.__WorldContext = __WorldContext;

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

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

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


// Function BPF_Libraly.BPF_Libraly_C.SaveDataUpdate
// (Static, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBP_SaveGame_C*                   SaveGame                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// ENUM_SaveDataUpdateType                 UpdateType                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::SaveDataUpdate(class UBP_SaveGame_C* SaveGame, ENUM_SaveDataUpdateType UpdateType, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "SaveDataUpdate");

	Params::BPF_Libraly_C_SaveDataUpdate Parms{};

	Parms.SaveGame = SaveGame;
	Parms.UpdateType = UpdateType;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.SetAnimationPosiiton
// (Static, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UUserWidget*                      UserWidget                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// class UWidgetAnimation*                 WidgetAnimation                                        (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// double                                  position                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::SetAnimationPosiiton(class UUserWidget* UserWidget, class UWidgetAnimation* WidgetAnimation, double position, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "SetAnimationPosiiton");

	Params::BPF_Libraly_C_SetAnimationPosiiton Parms{};

	Parms.UserWidget = UserWidget;
	Parms.WidgetAnimation = WidgetAnimation;
	Parms.position = position;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.SetLogicState
// (Static, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           TargetActor                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// bool                                    LogicState                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// bool                                    StopMovement                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::SetLogicState(class AActor* TargetActor, bool LogicState, bool StopMovement, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "SetLogicState");

	Params::BPF_Libraly_C_SetLogicState Parms{};

	Parms.TargetActor = TargetActor;
	Parms.LogicState = LogicState;
	Parms.StopMovement = StopMovement;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.SplitText
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FText&                      SourceText                                             (BlueprintVisible, BlueprintReadOnly, Parm)
// const class FString&                    SplitSource                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ReturnParm)

TArray<class FString> UBPF_Libraly_C::SplitText(const class FText& SourceText, const class FString& SplitSource, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "SplitText");

	Params::BPF_Libraly_C_SplitText Parms{};

	Parms.SourceText = std::move(SourceText);
	Parms.SplitSource = std::move(SplitSource);
	Parms.__WorldContext = __WorldContext;

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

	return Parms.ReturnValue;
}


// Function BPF_Libraly.BPF_Libraly_C.SplitTextPure
// (Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const class FText&                      SourceText                                             (BlueprintVisible, BlueprintReadOnly, Parm)
// const class FString&                    SplitSource                                            (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ReturnParm)

TArray<class FString> UBPF_Libraly_C::SplitTextPure(const class FText& SourceText, const class FString& SplitSource, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "SplitTextPure");

	Params::BPF_Libraly_C_SplitTextPure Parms{};

	Parms.SourceText = std::move(SourceText);
	Parms.SplitSource = std::move(SplitSource);
	Parms.__WorldContext = __WorldContext;

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

	return Parms.ReturnValue;
}


// Function BPF_Libraly.BPF_Libraly_C.StopAnimMontage
// (Static, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USkeletalMeshComponent*           SkeletalMesh                                           (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// const class UAnimMontage*               Montage                                                (ConstParm, BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::StopAnimMontage(class USkeletalMeshComponent* SkeletalMesh, const class UAnimMontage* Montage, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "StopAnimMontage");

	Params::BPF_Libraly_C_StopAnimMontage Parms{};

	Parms.SkeletalMesh = SkeletalMesh;
	Parms.Montage = Montage;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.TextSizeAdjust
// (Static, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UTextBlock*                       Text_Block                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash)
// double                                  MaxWidth                                               (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::TextSizeAdjust(class UTextBlock* Text_Block, double MaxWidth, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "TextSizeAdjust");

	Params::BPF_Libraly_C_TextSizeAdjust Parms{};

	Parms.Text_Block = Text_Block;
	Parms.MaxWidth = MaxWidth;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.UI_MouseState
// (Static, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    MouseState                                             (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)

void UBPF_Libraly_C::UI_MouseState(bool MouseState, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "UI_MouseState");

	Params::BPF_Libraly_C_UI_MouseState Parms{};

	Parms.MouseState = MouseState;
	Parms.__WorldContext = __WorldContext;

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


// Function BPF_Libraly.BPF_Libraly_C.WrapSnap(Integer)
// (Static, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// int32                                   Value                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   min_0                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int32                                   max_0                                                  (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// class UObject*                          __WorldContext                                         (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)

int32 UBPF_Libraly_C::WrapSnap_Integer_(int32 Value, int32 min_0, int32 max_0, class UObject* __WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BPF_Libraly_C", "WrapSnap(Integer)");

	Params::BPF_Libraly_C_WrapSnap_Integer_ Parms{};

	Parms.Value = Value;
	Parms.min_0 = min_0;
	Parms.max_0 = max_0;
	Parms.__WorldContext = __WorldContext;

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

	return Parms.ReturnValue;
}


SDK_NAMESPACE_END
