#pragma once

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

// Package: CyaAI

#include "Basic.hpp"

#include "CyaAI_classes.hpp"
#include "CyaAI_parameters.hpp"


namespace SDK
{

// Function CyaAI.CyaAICharacterInterface.SetSpeed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FCyaAISpeed&               SpeedName                                              (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ICyaAICharacterInterface::SetSpeed(const struct FCyaAISpeed& SpeedName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAICharacterInterface", "SetSpeed");

	Params::CyaAICharacterInterface_SetSpeed Parms{};

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

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAICharacterInterface.CanPlayPatrolAnimation
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class ACyaAIPatrolNode*                 PatrolNodeConcern                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ICyaAICharacterInterface::CanPlayPatrolAnimation(class ACyaAIPatrolNode* PatrolNodeConcern) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAICharacterInterface", "CanPlayPatrolAnimation");

	Params::CyaAICharacterInterface_CanPlayPatrolAnimation Parms{};

	Parms.PatrolNodeConcern = PatrolNodeConcern;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPatrolObjectInterface.GetPatrolSnapTransform
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// class ACyaAIPatrolNode*                 Node                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform ICyaAIPatrolObjectInterface::GetPatrolSnapTransform(class ACyaAIPatrolNode* Node)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIPatrolObjectInterface", "GetPatrolSnapTransform");

	Params::CyaAIPatrolObjectInterface_GetPatrolSnapTransform Parms{};

	Parms.Node = Node;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPatrolObjectInterface.PatrolNodeAssigned
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class ACyaAIPatrolNode*                 Node                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ICyaAIPatrolObjectInterface::PatrolNodeAssigned(class ACyaAIPatrolNode* Node)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIPatrolObjectInterface", "PatrolNodeAssigned");

	Params::CyaAIPatrolObjectInterface_PatrolNodeAssigned Parms{};

	Parms.Node = Node;

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolObjectInterface.PatrolNodeRemoved
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class ACyaAIPatrolNode*                 Node                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ICyaAIPatrolObjectInterface::PatrolNodeRemoved(class ACyaAIPatrolNode* Node)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIPatrolObjectInterface", "PatrolNodeRemoved");

	Params::CyaAIPatrolObjectInterface_PatrolNodeRemoved Parms{};

	Parms.Node = Node;

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolObjectInterface.PatrolUserReady
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class ACyaCharacter*                    User                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACyaAIPatrolNode*                 Node                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ICyaAIPatrolObjectInterface::PatrolUserReady(class ACyaCharacter* User, class ACyaAIPatrolNode* Node)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIPatrolObjectInterface", "PatrolUserReady");

	Params::CyaAIPatrolObjectInterface_PatrolUserReady Parms{};

	Parms.User = User;
	Parms.Node = Node;

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolObjectInterface.SetPatrolNodeActive
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class ACyaAIPatrolNode*                 Node                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bNewActive                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ICyaAIPatrolObjectInterface::SetPatrolNodeActive(class ACyaAIPatrolNode* Node, const bool bNewActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIPatrolObjectInterface", "SetPatrolNodeActive");

	Params::CyaAIPatrolObjectInterface_SetPatrolNodeActive Parms{};

	Parms.Node = Node;
	Parms.bNewActive = bNewActive;

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolObjectInterface.ShouldExecute
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const bool                              bUserCanPlayAnimation                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ICyaAIPatrolObjectInterface::ShouldExecute(const bool bUserCanPlayAnimation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIPatrolObjectInterface", "ShouldExecute");

	Params::CyaAIPatrolObjectInterface_ShouldExecute Parms{};

	Parms.bUserCanPlayAnimation = bUserCanPlayAnimation;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPatrolObjectInterface.ShouldSnapTransform
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ICyaAIPatrolObjectInterface::ShouldSnapTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIPatrolObjectInterface", "ShouldSnapTransform");

	Params::CyaAIPatrolObjectInterface_ShouldSnapTransform Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIShouldTriggerInstantPerceptionShapeInterface.ShouldTriggerShape
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ICyaAIShouldTriggerInstantPerceptionShapeInterface::ShouldTriggerShape() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAIShouldTriggerInstantPerceptionShapeInterface", "ShouldTriggerShape");

	Params::CyaAIShouldTriggerInstantPerceptionShapeInterface_ShouldTriggerShape Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAISightTagInterface.GetTagForSight
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class FName*                            OutTag                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ICyaAISightTagInterface::GetTagForSight(class FName* OutTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAISightTagInterface", "GetTagForSight");

	Params::CyaAISightTagInterface_GetTagForSight Parms{};

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

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

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAISightUserInterface.GetActorsToIgnoreForSightTrace
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TArray<class AActor*>*                  ActorsToIgnore                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void ICyaAISightUserInterface::GetActorsToIgnoreForSightTrace(TArray<class AActor*>* ActorsToIgnore) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAISightUserInterface", "GetActorsToIgnoreForSightTrace");

	Params::CyaAISightUserInterface_GetActorsToIgnoreForSightTrace Parms{};

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

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

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAISpeedFunctionLibrary.EqualEqual_AISpeed
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FCyaAISpeed&               A                                                      (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCyaAISpeed&               B                                                      (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCyaAISpeedFunctionLibrary::EqualEqual_AISpeed(const struct FCyaAISpeed& A, const struct FCyaAISpeed& B)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CyaAISpeedFunctionLibrary", "EqualEqual_AISpeed");

	Params::CyaAISpeedFunctionLibrary_EqualEqual_AISpeed Parms{};

	Parms.A = std::move(A);
	Parms.B = std::move(B);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAITouchTagInterface.GetTagForTouching
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class FName*                            OutTag                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ICyaAITouchTagInterface::GetTagForTouching(class FName* OutTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("CyaAITouchTagInterface", "GetTagForTouching");

	Params::CyaAITouchTagInterface_GetTagForTouching Parms{};

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

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

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAIStateCondition.BP_Evaluate
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const class ACyaAIController*           Controller                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCyaStateMachineReaderComponent*Reader                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCyaAIStateCondition::BP_Evaluate(const class ACyaAIController* Controller, const class UCyaStateMachineReaderComponent* Reader) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIStateCondition", "BP_Evaluate");

	Params::CyaAIStateCondition_BP_Evaluate Parms{};

	Parms.Controller = Controller;
	Parms.Reader = Reader;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIStateSheet.OnEnter
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const class ACyaAIController*           OwnerController                                        (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APawn*                      OwnerPawn                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIStateSheet::OnEnter(const class ACyaAIController* OwnerController, const class APawn* OwnerPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIStateSheet", "OnEnter");

	Params::CyaAIStateSheet_OnEnter Parms{};

	Parms.OwnerController = OwnerController;
	Parms.OwnerPawn = OwnerPawn;

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


// Function CyaAI.CyaAIStateSheet.OnExit
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// const class ACyaAIController*           OwnerController                                        (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APawn*                      OwnerPawn                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIStateSheet::OnExit(const class ACyaAIController* OwnerController, const class APawn* OwnerPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIStateSheet", "OnExit");

	Params::CyaAIStateSheet_OnExit Parms{};

	Parms.OwnerController = OwnerController;
	Parms.OwnerPawn = OwnerPawn;

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


// Function CyaAI.CyaAINoisyActor.OnHitOrBounced_BP
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const float                             ImpactStrength                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void ACyaAINoisyActor::OnHitOrBounced_BP(const float ImpactStrength, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAINoisyActor", "OnHitOrBounced_BP");

	Params::CyaAINoisyActor_OnHitOrBounced_BP Parms{};

	Parms.ImpactStrength = ImpactStrength;
	Parms.OtherActor = OtherActor;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

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


// Function CyaAI.CyaAINoisyActor.OnHitOrBounced_Feedback_BP
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void ACyaAINoisyActor::OnHitOrBounced_Feedback_BP(class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAINoisyActor", "OnHitOrBounced_Feedback_BP");

	Params::CyaAINoisyActor_OnHitOrBounced_Feedback_BP Parms{};

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

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


// Function CyaAI.CyaAIPerceptibleComponent.GetPerceptionRatio
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaAIPerceptibleComponent::GetPerceptionRatio() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptibleComponent", "GetPerceptionRatio");

	Params::CyaAIPerceptibleComponent_GetPerceptionRatio Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.AddGaugePausedState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EGaugePauseState                        State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPerceptionGaugeComponent::AddGaugePausedState(EGaugePauseState State, class AActor* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "AddGaugePausedState");

	Params::CyaAIPerceptionGaugeComponent_AddGaugePausedState Parms{};

	Parms.State = State;
	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.ClampPerceptionIntensityBetween
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   MinValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           PerceptionTarget                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPerceptionGaugeComponent::ClampPerceptionIntensityBetween(float MinValue, float MaxValue, class AActor* PerceptionTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "ClampPerceptionIntensityBetween");

	Params::CyaAIPerceptionGaugeComponent_ClampPerceptionIntensityBetween Parms{};

	Parms.MinValue = MinValue;
	Parms.MaxValue = MaxValue;
	Parms.PerceptionTarget = PerceptionTarget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetActiveBufferDetection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCyaAIPerceptionGaugeComponent::GetActiveBufferDetection(class AActor* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetActiveBufferDetection");

	Params::CyaAIPerceptionGaugeComponent_GetActiveBufferDetection Parms{};

	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetMostRelevantStimulusForTarget
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class AActor*                     Target                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus*                     OutStimulus                                            (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class UCyaAISense>          ClassFilter                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCyaAIPerceptionGaugeComponent::GetMostRelevantStimulusForTarget(const class AActor* Target, struct FAIStimulus* OutStimulus, TSubclassOf<class UCyaAISense> ClassFilter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetMostRelevantStimulusForTarget");

	Params::CyaAIPerceptionGaugeComponent_GetMostRelevantStimulusForTarget Parms{};

	Parms.Target = Target;
	Parms.ClassFilter = ClassFilter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetStimulusSense
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FAIStimulus&               Stimulus                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class UCyaAISense>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UCyaAISense> UCyaAIPerceptionGaugeComponent::GetStimulusSense(const struct FAIStimulus& Stimulus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetStimulusSense");

	Params::CyaAIPerceptionGaugeComponent_GetStimulusSense Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetStrongestPerceptionInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bActiveStimulusOnly                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bSenseEnemiesOnly                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UCyaAISense>          ClassFilter                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           PerceptionTarget                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             IntensityFilter                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FCyaAIPerceptionInfo             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FCyaAIPerceptionInfo UCyaAIPerceptionGaugeComponent::GetStrongestPerceptionInfo(const bool bActiveStimulusOnly, const bool bSenseEnemiesOnly, TSubclassOf<class UCyaAISense> ClassFilter, class AActor* PerceptionTarget, const float IntensityFilter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetStrongestPerceptionInfo");

	Params::CyaAIPerceptionGaugeComponent_GetStrongestPerceptionInfo Parms{};

	Parms.bActiveStimulusOnly = bActiveStimulusOnly;
	Parms.bSenseEnemiesOnly = bSenseEnemiesOnly;
	Parms.ClassFilter = ClassFilter;
	Parms.PerceptionTarget = PerceptionTarget;
	Parms.IntensityFilter = IntensityFilter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.RemoveGaugePausedState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EGaugePauseState                        State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPerceptionGaugeComponent::RemoveGaugePausedState(EGaugePauseState State, class AActor* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "RemoveGaugePausedState");

	Params::CyaAIPerceptionGaugeComponent_RemoveGaugePausedState Parms{};

	Parms.State = State;
	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.ResetGauges
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           PerceptionTarget                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPerceptionGaugeComponent::ResetGauges(class AActor* PerceptionTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "ResetGauges");

	Params::CyaAIPerceptionGaugeComponent_ResetGauges Parms{};

	Parms.PerceptionTarget = PerceptionTarget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.SetActiveBufferDetection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPerceptionGaugeComponent::SetActiveBufferDetection(class AActor* Target, bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "SetActiveBufferDetection");

	Params::CyaAIPerceptionGaugeComponent_SetActiveBufferDetection Parms{};

	Parms.Target = Target;
	Parms.bValue = bValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.SetIconMaterialInstanceInfos
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UTexture2D*                       IconTexture                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              Color                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPerceptionGaugeComponent::SetIconMaterialInstanceInfos(class UTexture2D* IconTexture, const struct FLinearColor& Color)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "SetIconMaterialInstanceInfos");

	Params::CyaAIPerceptionGaugeComponent_SetIconMaterialInstanceInfos Parms{};

	Parms.IconTexture = IconTexture;
	Parms.Color = std::move(Color);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetListActorTargettedByGauges
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AActor*>*                  OutActors                                              (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const float                             IntensityFilter                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPerceptionGaugeComponent::GetListActorTargettedByGauges(TArray<class AActor*>* OutActors, const float IntensityFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetListActorTargettedByGauges");

	Params::CyaAIPerceptionGaugeComponent_GetListActorTargettedByGauges Parms{};

	Parms.IntensityFilter = IntensityFilter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetMostRecentStimulusPerceiveAge
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UCyaAISense>          ClassFilter                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaAIPerceptionGaugeComponent::GetMostRecentStimulusPerceiveAge(TSubclassOf<class UCyaAISense> ClassFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetMostRecentStimulusPerceiveAge");

	Params::CyaAIPerceptionGaugeComponent_GetMostRecentStimulusPerceiveAge Parms{};

	Parms.ClassFilter = ClassFilter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetPerceptionIntensity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           PerceptionTarget                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaAIPerceptionGaugeComponent::GetPerceptionIntensity(class AActor* PerceptionTarget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetPerceptionIntensity");

	Params::CyaAIPerceptionGaugeComponent_GetPerceptionIntensity Parms{};

	Parms.PerceptionTarget = PerceptionTarget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPerceptionGaugeComponent.GetStrongestPerceptionIntensity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaAIPerceptionGaugeComponent::GetStrongestPerceptionIntensity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPerceptionGaugeComponent", "GetStrongestPerceptionIntensity");

	Params::CyaAIPerceptionGaugeComponent_GetStrongestPerceptionIntensity Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIVisibleActor.BP_IsPerceiveBy
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class ACyaAIController*                 Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAIStimulus&               Stimulus                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIVisibleActor::BP_IsPerceiveBy(class ACyaAIController* Controller, const struct FAIStimulus& Stimulus, float Strength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIVisibleActor", "BP_IsPerceiveBy");

	Params::CyaAIVisibleActor_BP_IsPerceiveBy Parms{};

	Parms.Controller = Controller;
	Parms.Stimulus = std::move(Stimulus);
	Parms.Strength = Strength;

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


// Function CyaAI.CyaAIVisibleActor.SetAsPerceptible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIVisibleActor::SetAsPerceptible(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIVisibleActor", "SetAsPerceptible");

	Params::CyaAIVisibleActor_SetAsPerceptible Parms{};

	Parms.bValue = bValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIVisibleActor.CanBeSeen_BP
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class AActor*                     ActorSeeing                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ACyaAIVisibleActor::CanBeSeen_BP(const class AActor* ActorSeeing) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIVisibleActor", "CanBeSeen_BP");

	Params::CyaAIVisibleActor_CanBeSeen_BP Parms{};

	Parms.ActorSeeing = ActorSeeing;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIVisibleActor.ComputeSightFactor_BP
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ACyaAIVisibleActor::ComputeSightFactor_BP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIVisibleActor", "ComputeSightFactor_BP");

	Params::CyaAIVisibleActor_ComputeSightFactor_BP Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAISense_Damage.ReportCyaDamageEvent
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DamageAmount                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EventLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAISense_Damage::ReportCyaDamageEvent(class UObject* WorldContextObject, class AActor* DamagedActor, class AActor* Instigator, float DamageAmount, const struct FVector& EventLocation, const struct FVector& HitLocation, class FName Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CyaAISense_Damage", "ReportCyaDamageEvent");

	Params::CyaAISense_Damage_ReportCyaDamageEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.DamagedActor = DamagedActor;
	Parms.Instigator = Instigator;
	Parms.DamageAmount = DamageAmount;
	Parms.EventLocation = std::move(EventLocation);
	Parms.HitLocation = std::move(HitLocation);
	Parms.Tag = Tag;

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAISense_DamageDone.ReportDamageDoneEvent
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DamageAmount                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EventLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAISense_DamageDone::ReportDamageDoneEvent(class UObject* WorldContextObject, class AActor* DamagedActor, class AActor* Instigator, float DamageAmount, const struct FVector& EventLocation, const struct FVector& HitLocation, class FName Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CyaAISense_DamageDone", "ReportDamageDoneEvent");

	Params::CyaAISense_DamageDone_ReportDamageDoneEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.DamagedActor = DamagedActor;
	Parms.Instigator = Instigator;
	Parms.DamageAmount = DamageAmount;
	Parms.EventLocation = std::move(EventLocation);
	Parms.HitLocation = std::move(HitLocation);
	Parms.Tag = Tag;

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAISense_Hearing.ReportCyaNoiseEvent
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NoiseLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UCyaAISoundEventConfig>SoundEventConfig                                       (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAISense_Hearing::ReportCyaNoiseEvent(class UObject* WorldContextObject, const struct FVector& NoiseLocation, TSubclassOf<class UCyaAISoundEventConfig> SoundEventConfig, class AActor* Instigator, class FName Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CyaAISense_Hearing", "ReportCyaNoiseEvent");

	Params::CyaAISense_Hearing_ReportCyaNoiseEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.NoiseLocation = std::move(NoiseLocation);
	Parms.SoundEventConfig = SoundEventConfig;
	Parms.Instigator = Instigator;
	Parms.Tag = Tag;

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

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

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaPerceptionShape.GetApertureAngle
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaPerceptionShape::GetApertureAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaPerceptionShape", "GetApertureAngle");

	Params::CyaPerceptionShape_GetApertureAngle Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaPerceptionShape.GetMaxDistance
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaPerceptionShape::GetMaxDistance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaPerceptionShape", "GetMaxDistance");

	Params::CyaPerceptionShape_GetMaxDistance Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAISenseStrengthCombiner.GetStrength
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class UCyaPerceptionShape*        Shape                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     Source                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     Target                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaAISenseStrengthCombiner::GetStrength(const class UCyaPerceptionShape* Shape, const class AActor* Source, const class AActor* Target) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAISenseStrengthCombiner", "GetStrength");

	Params::CyaAISenseStrengthCombiner_GetStrength Parms{};

	Parms.Shape = Shape;
	Parms.Source = Source;
	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAISenseStrengthFunction.GetStrength
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class UCyaPerceptionShape*        Shape                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     Source                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     Target                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCyaAISenseStrengthFunction::GetStrength(const class UCyaPerceptionShape* Shape, const class AActor* Source, const class AActor* Target) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAISenseStrengthFunction", "GetStrength");

	Params::CyaAISenseStrengthFunction_GetStrength Parms{};

	Parms.Shape = Shape;
	Parms.Source = Source;
	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIJobBase.BP_OnStartJob
// (Event, Protected, BlueprintEvent)
// Parameters:
// class ACyaAIController*                 AIController                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACyaCharacter*                    AICharacter                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::BP_OnStartJob(class ACyaAIController* AIController, class ACyaCharacter* AICharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "BP_OnStartJob");

	Params::CyaAIJobBase_BP_OnStartJob Parms{};

	Parms.AIController = AIController;
	Parms.AICharacter = AICharacter;

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


// Function CyaAI.CyaAIJobBase.BP_OnStopJob
// (Event, Protected, BlueprintEvent)
// Parameters:
// class ACyaAIController*                 AIController                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACyaCharacter*                    AICharacter                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::BP_OnStopJob(class ACyaAIController* AIController, class ACyaCharacter* AICharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "BP_OnStopJob");

	Params::CyaAIJobBase_BP_OnStopJob Parms{};

	Parms.AIController = AIController;
	Parms.AICharacter = AICharacter;

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


// Function CyaAI.CyaAIJobBase.OnPerceiveNewThings
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus&                     Stimulus                                               (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::OnPerceiveNewThings(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus& Stimulus, float Strength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "OnPerceiveNewThings");

	Params::CyaAIJobBase_OnPerceiveNewThings Parms{};

	Parms.AI = AI;
	Parms.Target = Target;
	Parms.Stimulus = std::move(Stimulus);
	Parms.Strength = Strength;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAIJobBase.OnPerceiveThingsEnded
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus*                     Stimulus                                               (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)

void UCyaAIJobBase::OnPerceiveThingsEnded(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus* Stimulus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "OnPerceiveThingsEnded");

	Params::CyaAIJobBase_OnPerceiveThingsEnded Parms{};

	Parms.AI = AI;
	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAIJobBase.OnPerceiveThingsEndedDelayed
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus*                     Stimulus                                               (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)

void UCyaAIJobBase::OnPerceiveThingsEndedDelayed(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus* Stimulus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "OnPerceiveThingsEndedDelayed");

	Params::CyaAIJobBase_OnPerceiveThingsEndedDelayed Parms{};

	Parms.AI = AI;
	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAIJobBase.OnPerceiveThingsStartDelayed
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus&                     Stimulus                                               (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::OnPerceiveThingsStartDelayed(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus& Stimulus, float Strength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "OnPerceiveThingsStartDelayed");

	Params::CyaAIJobBase_OnPerceiveThingsStartDelayed Parms{};

	Parms.AI = AI;
	Parms.Target = Target;
	Parms.Stimulus = std::move(Stimulus);
	Parms.Strength = Strength;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAIJobBase.OnPerceptionIntensityUpdated
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus&                     Stimulus                                               (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::OnPerceptionIntensityUpdated(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus& Stimulus, float Strength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "OnPerceptionIntensityUpdated");

	Params::CyaAIJobBase_OnPerceptionIntensityUpdated Parms{};

	Parms.AI = AI;
	Parms.Target = Target;
	Parms.Stimulus = std::move(Stimulus);
	Parms.Strength = Strength;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function CyaAI.CyaAIJobBase.BP_OnPerceiveNewThings
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus&                     Stimulus                                               (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::BP_OnPerceiveNewThings(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus& Stimulus, float Strength) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "BP_OnPerceiveNewThings");

	Params::CyaAIJobBase_BP_OnPerceiveNewThings Parms{};

	Parms.AI = AI;
	Parms.Target = Target;
	Parms.Stimulus = std::move(Stimulus);
	Parms.Strength = Strength;

	UObject::ProcessEvent(Func, &Parms);

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


// Function CyaAI.CyaAIJobBase.BP_OnPerceiveThingsEnded
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus*                     Stimulus                                               (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)

void UCyaAIJobBase::BP_OnPerceiveThingsEnded(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus* Stimulus) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "BP_OnPerceiveThingsEnded");

	Params::CyaAIJobBase_BP_OnPerceiveThingsEnded Parms{};

	Parms.AI = AI;
	Parms.Target = Target;

	UObject::ProcessEvent(Func, &Parms);

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


// Function CyaAI.CyaAIJobBase.BP_OnPerceiveThingsEndedDelayed
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus*                     Stimulus                                               (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)

void UCyaAIJobBase::BP_OnPerceiveThingsEndedDelayed(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus* Stimulus) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "BP_OnPerceiveThingsEndedDelayed");

	Params::CyaAIJobBase_BP_OnPerceiveThingsEndedDelayed Parms{};

	Parms.AI = AI;
	Parms.Target = Target;

	UObject::ProcessEvent(Func, &Parms);

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


// Function CyaAI.CyaAIJobBase.BP_OnPerceiveThingsStartDelayed
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus&                     Stimulus                                               (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::BP_OnPerceiveThingsStartDelayed(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus& Stimulus, float Strength) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "BP_OnPerceiveThingsStartDelayed");

	Params::CyaAIJobBase_BP_OnPerceiveThingsStartDelayed Parms{};

	Parms.AI = AI;
	Parms.Target = Target;
	Parms.Stimulus = std::move(Stimulus);
	Parms.Strength = Strength;

	UObject::ProcessEvent(Func, &Parms);

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


// Function CyaAI.CyaAIJobBase.BP_OnPerceptionIntensityUpdated
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class ACyaAIController*                 AI                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAIStimulus&                     Stimulus                                               (Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIJobBase::BP_OnPerceptionIntensityUpdated(class ACyaAIController* AI, class AActor* Target, struct FAIStimulus& Stimulus, float Strength) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIJobBase", "BP_OnPerceptionIntensityUpdated");

	Params::CyaAIJobBase_BP_OnPerceptionIntensityUpdated Parms{};

	Parms.AI = AI;
	Parms.Target = Target;
	Parms.Stimulus = std::move(Stimulus);
	Parms.Strength = Strength;

	UObject::ProcessEvent(Func, &Parms);

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


// Function CyaAI.CyaAIController.ApplySensesConfigSheet
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UCyaAISenseConfigSheet>SenseConfigSheet                                       (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIController::ApplySensesConfigSheet(TSubclassOf<class UCyaAISenseConfigSheet> SenseConfigSheet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "ApplySensesConfigSheet");

	Params::CyaAIController_ApplySensesConfigSheet Parms{};

	Parms.SenseConfigSheet = SenseConfigSheet;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIController.CopyPerceptionFrom
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ACyaAIController*                 SourceController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bOnlyIfLower                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ACyaAIController::CopyPerceptionFrom(class ACyaAIController* SourceController, const bool bOnlyIfLower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "CopyPerceptionFrom");

	Params::CyaAIController_CopyPerceptionFrom Parms{};

	Parms.SourceController = SourceController;
	Parms.bOnlyIfLower = bOnlyIfLower;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIController.RestartJob
// (Final, Native, Public, BlueprintCallable)

void ACyaAIController::RestartJob()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "RestartJob");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIController.SetAvailableForNewJob
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIController::SetAvailableForNewJob(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "SetAvailableForNewJob");

	Params::CyaAIController_SetAvailableForNewJob Parms{};

	Parms.bValue = bValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIController.SetDetectionEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIController::SetDetectionEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "SetDetectionEnabled");

	Params::CyaAIController_SetDetectionEnabled Parms{};

	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIController.StartJob
// (Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UCyaAIJobBase>        NewJob                                                 (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIController::StartJob(TSubclassOf<class UCyaAIJobBase> NewJob)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "StartJob");

	Params::CyaAIController_StartJob Parms{};

	Parms.NewJob = NewJob;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIController.StopCurrentJob
// (Final, Native, Public, BlueprintCallable)

void ACyaAIController::StopCurrentJob()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "StopCurrentJob");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIController.CanTakeNewJob
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ACyaAIController::CanTakeNewJob() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "CanTakeNewJob");

	Params::CyaAIController_CanTakeNewJob Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIController.GetCurrentSensesConfigSheet
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UCyaAISenseConfigSheet*     ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UCyaAISenseConfigSheet* ACyaAIController::GetCurrentSensesConfigSheet() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "GetCurrentSensesConfigSheet");

	Params::CyaAIController_GetCurrentSensesConfigSheet Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIController.GetPerceptionGaugeCasted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UCyaAIPerceptionGaugeComponent>PerceptionGaugeType                                    (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCyaAIPerceptionGaugeComponent*   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UCyaAIPerceptionGaugeComponent* ACyaAIController::GetPerceptionGaugeCasted(TSubclassOf<class UCyaAIPerceptionGaugeComponent> PerceptionGaugeType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIController", "GetPerceptionGaugeCasted");

	Params::CyaAIController_GetPerceptionGaugeCasted Parms{};

	Parms.PerceptionGaugeType = PerceptionGaugeType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIDirector.OnAIEnterState_BP
// (Event, Public, BlueprintEvent)
// Parameters:
// class ACyaAIController*                 Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCyaAIStateSheet*           State                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIDirector::OnAIEnterState_BP(class ACyaAIController* Controller, const class UCyaAIStateSheet* State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIDirector", "OnAIEnterState_BP");

	Params::CyaAIDirector_OnAIEnterState_BP Parms{};

	Parms.Controller = Controller;
	Parms.State = State;

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


// Function CyaAI.CyaAIDirector.OnAILeaveState_BP
// (Event, Public, BlueprintEvent)
// Parameters:
// class ACyaAIController*                 Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCyaAIStateSheet*           State                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIDirector::OnAILeaveState_BP(class ACyaAIController* Controller, const class UCyaAIStateSheet* State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIDirector", "OnAILeaveState_BP");

	Params::CyaAIDirector_OnAILeaveState_BP Parms{};

	Parms.Controller = Controller;
	Parms.State = State;

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


// Function CyaAI.CyaAIDirector.ResetPerceptionOnAllAliveAI
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           ObjectFilter                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIDirector::ResetPerceptionOnAllAliveAI(class AActor* ObjectFilter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIDirector", "ResetPerceptionOnAllAliveAI");

	Params::CyaAIDirector_ResetPerceptionOnAllAliveAI Parms{};

	Parms.ObjectFilter = ObjectFilter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIDirector.SetDetectionEnabledOnAllAliveAIS
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIDirector::SetDetectionEnabledOnAllAliveAIS(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIDirector", "SetDetectionEnabledOnAllAliveAIS");

	Params::CyaAIDirector_SetDetectionEnabledOnAllAliveAIS Parms{};

	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIDirector.CollectAndSortAIAround
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
// Parameters:
// const struct FVector&                   CollectOriginActor                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SortOriginLocation                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxDistance                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ACyaCharacter*>            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ACyaCharacter*> ACyaAIDirector::CollectAndSortAIAround(const struct FVector& CollectOriginActor, const struct FVector& SortOriginLocation, float MaxDistance) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIDirector", "CollectAndSortAIAround");

	Params::CyaAIDirector_CollectAndSortAIAround Parms{};

	Parms.CollectOriginActor = std::move(CollectOriginActor);
	Parms.SortOriginLocation = std::move(SortOriginLocation);
	Parms.MaxDistance = MaxDistance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAISettings.GetSpeedList
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FCyaAIGabaritHandle&       Gabarit                                                (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCyaAISpeedHandle          ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

const struct FCyaAISpeedHandle UCyaAISettings::GetSpeedList(const struct FCyaAIGabaritHandle& Gabarit) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAISettings", "GetSpeedList");

	Params::CyaAISettings_GetSpeedList Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIWorldSubsystem.GetAIDirector
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ACyaAIDirector*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ACyaAIDirector* UCyaAIWorldSubsystem::GetAIDirector() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIWorldSubsystem", "GetAIDirector");

	Params::CyaAIWorldSubsystem_GetAIDirector Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIWorldSubsystem.GetAIDirectorCasted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class ACyaAIDirector>       DirectorType                                           (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACyaAIDirector*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ACyaAIDirector* UCyaAIWorldSubsystem::GetAIDirectorCasted(TSubclassOf<class ACyaAIDirector> DirectorType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIWorldSubsystem", "GetAIDirectorCasted");

	Params::CyaAIWorldSubsystem_GetAIDirectorCasted Parms{};

	Parms.DirectorType = DirectorType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAINavArea.IsMovementFinished
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class AAIController*                    Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCyaAINavArea::IsMovementFinished(class AAIController* Controller) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAINavArea", "IsMovementFinished");

	Params::CyaAINavArea_IsMovementFinished Parms{};

	Parms.Controller = Controller;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAINavArea.OnEnteringArea
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// class AAIController*                    Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartPoint                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Endpoint                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAINavArea::OnEnteringArea(class AAIController* Controller, const struct FVector& StartPoint, const struct FVector& Endpoint) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAINavArea", "OnEnteringArea");

	Params::CyaAINavArea_OnEnteringArea Parms{};

	Parms.Controller = Controller;
	Parms.StartPoint = std::move(StartPoint);
	Parms.Endpoint = std::move(Endpoint);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAINavArea.OnLeavingArea
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// class AAIController*                    Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartPoint                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Endpoint                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAINavArea::OnLeavingArea(class AAIController* Controller, const struct FVector& StartPoint, const struct FVector& Endpoint) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAINavArea", "OnLeavingArea");

	Params::CyaAINavArea_OnLeavingArea Parms{};

	Parms.Controller = Controller;
	Parms.StartPoint = std::move(StartPoint);
	Parms.Endpoint = std::move(Endpoint);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAINavigationHelper.CyaAINavigationRaycast
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outHitLocation                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayStart                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RayEnd                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ZThreshold                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UNavigationQueryFilter>FilterClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      Querier                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCyaAINavigationHelper::CyaAINavigationRaycast(class UObject* WorldContextObject, struct FVector* outHitLocation, const struct FVector& RayStart, const struct FVector& RayEnd, float ZThreshold, TSubclassOf<class UNavigationQueryFilter> FilterClass, class AController* Querier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CyaAINavigationHelper", "CyaAINavigationRaycast");

	Params::CyaAINavigationHelper_CyaAINavigationRaycast Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.RayStart = std::move(RayStart);
	Parms.RayEnd = std::move(RayEnd);
	Parms.ZThreshold = ZThreshold;
	Parms.FilterClass = FilterClass;
	Parms.Querier = Querier;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAINavigationHelper.CyaAIProjectDownwardToNavigation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Point                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ExtentDownward                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AAIController*              AICon                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCyaAINavigationHelper::CyaAIProjectDownwardToNavigation(class UObject* WorldContextObject, const struct FVector& Point, struct FVector* OutLocation, const struct FVector& ExtentDownward, const class AAIController* AICon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CyaAINavigationHelper", "CyaAIProjectDownwardToNavigation");

	Params::CyaAINavigationHelper_CyaAIProjectDownwardToNavigation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Point = std::move(Point);
	Parms.ExtentDownward = std::move(ExtentDownward);
	Parms.AICon = AICon;

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

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

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAINavigationSystem.UpdateActorOctree
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAINavigationSystem::UpdateActorOctree(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAINavigationSystem", "UpdateActorOctree");

	Params::CyaAINavigationSystem_UpdateActorOctree Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAINavigationSystem.UpdateCompOctree
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UActorComponent*                  Comp                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAINavigationSystem::UpdateCompOctree(class UActorComponent* Comp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAINavigationSystem", "UpdateCompOctree");

	Params::CyaAINavigationSystem_UpdateCompOctree Parms{};

	Parms.Comp = Comp;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPathFollowingComponent.SetBackTrackHistoryEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bNewEnabled                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPathFollowingComponent::SetBackTrackHistoryEnabled(const bool bNewEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPathFollowingComponent", "SetBackTrackHistoryEnabled");

	Params::CyaAIPathFollowingComponent_SetBackTrackHistoryEnabled Parms{};

	Parms.bNewEnabled = bNewEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolFollowingComponent.AssignNewPatrolNode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class ACyaAIPatrolNode>  NewPatrolNode                                          (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCyaAIPatrolFollowingComponent::AssignNewPatrolNode(TSoftObjectPtr<class ACyaAIPatrolNode> NewPatrolNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolFollowingComponent", "AssignNewPatrolNode");

	Params::CyaAIPatrolFollowingComponent_AssignNewPatrolNode Parms{};

	Parms.NewPatrolNode = NewPatrolNode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolFollowingComponent.ResumeAfterLinkedObject
// (Final, Native, Public, BlueprintCallable)

void UCyaAIPatrolFollowingComponent::ResumeAfterLinkedObject()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolFollowingComponent", "ResumeAfterLinkedObject");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolFollowingComponent.ResumePatrol
// (Native, Public, BlueprintCallable)

void UCyaAIPatrolFollowingComponent::ResumePatrol()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolFollowingComponent", "ResumePatrol");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolFollowingComponent.StopPatrol
// (Native, Public, BlueprintCallable)

void UCyaAIPatrolFollowingComponent::StopPatrol()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolFollowingComponent", "StopPatrol");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolNode.BP_RefreshVisual
// (Event, Public, BlueprintEvent)
// Parameters:
// const bool                              bIsSelected                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIPatrolNode::BP_RefreshVisual(const bool bIsSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolNode", "BP_RefreshVisual");

	Params::CyaAIPatrolNode_BP_RefreshVisual Parms{};

	Parms.bIsSelected = bIsSelected;

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


// Function CyaAI.CyaAIPatrolNode.NavigationBuilt
// (Final, Native, Public)
// Parameters:
// class ANavigationData*                  NavData                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIPatrolNode::NavigationBuilt(class ANavigationData* NavData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolNode", "NavigationBuilt");

	Params::CyaAIPatrolNode_NavigationBuilt Parms{};

	Parms.NavData = NavData;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolNode.RemoveUser
// (Final, Native, Public)
// Parameters:
// class AActor*                           User                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIPatrolNode::RemoveUser(class AActor* User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolNode", "RemoveUser");

	Params::CyaAIPatrolNode_RemoveUser Parms{};

	Parms.User = User;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolNodeCondition.GetNextNodeIndex
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class ACyaAIPatrolNode*           PatrolNode                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACyaAIController*                 Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UCyaAIPatrolNodeCondition::GetNextNodeIndex(const class ACyaAIPatrolNode* PatrolNode, class ACyaAIController* Controller)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolNodeCondition", "GetNextNodeIndex");

	Params::CyaAIPatrolNodeCondition_GetNextNodeIndex Parms{};

	Parms.PatrolNode = PatrolNode;
	Parms.Controller = Controller;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPatrolNodeCondition.GetPreviousNodeIndex
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class ACyaAIPatrolNode*           PatrolNode                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACyaAIController*                 Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UCyaAIPatrolNodeCondition::GetPreviousNodeIndex(const class ACyaAIPatrolNode* PatrolNode, class ACyaAIController* Controller)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolNodeCondition", "GetPreviousNodeIndex");

	Params::CyaAIPatrolNodeCondition_GetPreviousNodeIndex Parms{};

	Parms.PatrolNode = PatrolNode;
	Parms.Controller = Controller;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function CyaAI.CyaAIPatrolSynchronizer.ClearWaitingUser
// (Final, Native, Private, BlueprintCallable)

void ACyaAIPatrolSynchronizer::ClearWaitingUser()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolSynchronizer", "ClearWaitingUser");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function CyaAI.CyaAIPatrolSynchronizer.OnUsersSynchronized_BP
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<class ACyaCharacter*>&     SyncCharacters                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const bool                              bSyncSuccess                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACyaAIPatrolSynchronizer::OnUsersSynchronized_BP(const TArray<class ACyaCharacter*>& SyncCharacters, const bool bSyncSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CyaAIPatrolSynchronizer", "OnUsersSynchronized_BP");

	Params::CyaAIPatrolSynchronizer_OnUsersSynchronized_BP Parms{};

	Parms.SyncCharacters = std::move(SyncCharacters);
	Parms.bSyncSuccess = bSyncSuccess;

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

}