#pragma once

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

// Package: Everholm

#include "Basic.hpp"

#include "Everholm_classes.hpp"
#include "Everholm_parameters.hpp"


namespace SDK
{

// Function Everholm.AbilityActivationComponent.AddExternalAbility
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TScriptInterface<class IAbilityInterface>&abilityInstance                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldBeGranted                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::AddExternalAbility(const TScriptInterface<class IAbilityInterface>& abilityInstance, const class UObject*& Instigator, bool bShouldBeGranted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "AddExternalAbility");

	Params::AbilityActivationComponent_AddExternalAbility Parms{};

	Parms.abilityInstance = abilityInstance;
	Parms.Instigator = Instigator;
	Parms.bShouldBeGranted = bShouldBeGranted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.AddLooseGameplayTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::AddLooseGameplayTag(const struct FGameplayTag& Tag, const class UObject*& Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "AddLooseGameplayTag");

	Params::AbilityActivationComponent_AddLooseGameplayTag Parms{};

	Parms.Tag = std::move(Tag);
	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.AddLooseGameplayTags
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     TagContainer                                           (ConstParm, Parm, NativeAccessSpecifierPublic)
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::AddLooseGameplayTags(const struct FGameplayTagContainer& TagContainer, const class UObject*& Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "AddLooseGameplayTags");

	Params::AbilityActivationComponent_AddLooseGameplayTags Parms{};

	Parms.TagContainer = std::move(TagContainer);
	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.GetAbilityClass
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayTag&              abilityTag                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSoftClassPtr<class UClass>       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const TSoftClassPtr<class UClass> UAbilityActivationComponent::GetAbilityClass(const struct FGameplayTag& abilityTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "GetAbilityClass");

	Params::AbilityActivationComponent_GetAbilityClass Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.GrantAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TSoftClassPtr<class UClass>       AbilityClass                                           (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::GrantAbility(const TSoftClassPtr<class UClass> AbilityClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "GrantAbility");

	Params::AbilityActivationComponent_GrantAbility Parms{};

	Parms.AbilityClass = AbilityClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.OnMirroredComponentActorDestroyed
// (Final, Native, Private)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::OnMirroredComponentActorDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "OnMirroredComponentActorDestroyed");

	Params::AbilityActivationComponent_OnMirroredComponentActorDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.OnMirroredTagChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ChangedTag                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::OnMirroredTagChanged(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& ChangedTag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "OnMirroredTagChanged");

	Params::AbilityActivationComponent_OnMirroredTagChanged Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.ChangedTag = std::move(ChangedTag);
	Parms.bWasAdded = bWasAdded;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.OnOwnerPossessed
// (Final, Native, Public)
// Parameters:
// class AController*                      possessingController                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::OnOwnerPossessed(class AController* possessingController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "OnOwnerPossessed");

	Params::AbilityActivationComponent_OnOwnerPossessed Parms{};

	Parms.possessingController = possessingController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.OnRep_GameplayTags
// (Final, Native, Private)

void UAbilityActivationComponent::OnRep_GameplayTags()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "OnRep_GameplayTags");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.RemoveExternalAbility
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::RemoveExternalAbility(const class UObject*& Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "RemoveExternalAbility");

	Params::AbilityActivationComponent_RemoveExternalAbility Parms{};

	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.RemoveLooseGameplayTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::RemoveLooseGameplayTag(const struct FGameplayTag& Tag, const class UObject*& Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "RemoveLooseGameplayTag");

	Params::AbilityActivationComponent_RemoveLooseGameplayTag Parms{};

	Parms.Tag = std::move(Tag);
	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.RemoveLooseGameplayTags
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     tagsToRemove                                           (ConstParm, Parm, NativeAccessSpecifierPublic)
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::RemoveLooseGameplayTags(const struct FGameplayTagContainer& tagsToRemove, const class UObject*& Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "RemoveLooseGameplayTags");

	Params::AbilityActivationComponent_RemoveLooseGameplayTags Parms{};

	Parms.tagsToRemove = std::move(tagsToRemove);
	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.RemoveLooseGameplayTagsFromInstigator
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::RemoveLooseGameplayTagsFromInstigator(const class UObject*& Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "RemoveLooseGameplayTagsFromInstigator");

	Params::AbilityActivationComponent_RemoveLooseGameplayTagsFromInstigator Parms{};

	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.ReplicateTags_Server
// (Final, Net, Native, Event, Private, NetServer)
// Parameters:
// const struct FGameplayTagContainer&     explicitTags                                           (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::ReplicateTags_Server(const struct FGameplayTagContainer& explicitTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "ReplicateTags_Server");

	Params::AbilityActivationComponent_ReplicateTags_Server Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.RevokeAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TSoftClassPtr<class UClass>       AbilityClass                                           (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::RevokeAbility(const TSoftClassPtr<class UClass> AbilityClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "RevokeAbility");

	Params::AbilityActivationComponent_RevokeAbility Parms{};

	Parms.AbilityClass = AbilityClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.TryActivatingAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TSoftClassPtr<class UClass>       AbilityClass                                           (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::TryActivatingAbility(const TSoftClassPtr<class UClass> AbilityClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "TryActivatingAbility");

	Params::AbilityActivationComponent_TryActivatingAbility Parms{};

	Parms.AbilityClass = AbilityClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.TryDeactivatingAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TSoftClassPtr<class UClass>       AbilityClass                                           (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::TryDeactivatingAbility(const TSoftClassPtr<class UClass> AbilityClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "TryDeactivatingAbility");

	Params::AbilityActivationComponent_TryDeactivatingAbility Parms{};

	Parms.AbilityClass = AbilityClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.WaitGameplayTagAdd
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAASWaitExecPins                        execPin                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bSkipIfAdded                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::WaitGameplayTagAdd(EAASWaitExecPins execPin, const struct FGameplayTag& Tag, const struct FLatentActionInfo& LatentInfo, bool bSkipIfAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "WaitGameplayTagAdd");

	Params::AbilityActivationComponent_WaitGameplayTagAdd Parms{};

	Parms.execPin = execPin;
	Parms.Tag = std::move(Tag);
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.bSkipIfAdded = bSkipIfAdded;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.WaitGameplayTagRemove
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAASWaitExecPins                        execPin                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bSkipIfNotAdded                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityActivationComponent::WaitGameplayTagRemove(EAASWaitExecPins execPin, const struct FGameplayTag& Tag, const struct FLatentActionInfo& LatentInfo, bool bSkipIfNotAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "WaitGameplayTagRemove");

	Params::AbilityActivationComponent_WaitGameplayTagRemove Parms{};

	Parms.execPin = execPin;
	Parms.Tag = std::move(Tag);
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.bSkipIfNotAdded = bSkipIfNotAdded;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityActivationComponent.CanActivateAbility
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftClassPtr<class UClass>       AbilityClass                                           (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDevAllowFailureLogging                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::CanActivateAbility(const TSoftClassPtr<class UClass> AbilityClass, const bool bDevAllowFailureLogging) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "CanActivateAbility");

	Params::AbilityActivationComponent_CanActivateAbility Parms{};

	Parms.AbilityClass = AbilityClass;
	Parms.bDevAllowFailureLogging = bDevAllowFailureLogging;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.EvaluateTagQuery
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTagQuery&         Query                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::EvaluateTagQuery(const struct FGameplayTagQuery& Query) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "EvaluateTagQuery");

	Params::AbilityActivationComponent_EvaluateTagQuery Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.GetAbilityInstance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSubclassOf<class UObject>        AbilityClass                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UAbilityActivationComponent::GetAbilityInstance(const TSubclassOf<class UObject> AbilityClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "GetAbilityInstance");

	Params::AbilityActivationComponent_GetAbilityInstance Parms{};

	Parms.AbilityClass = AbilityClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.HasExternalAbility
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::HasExternalAbility(const class UObject*& Instigator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "HasExternalAbility");

	Params::AbilityActivationComponent_HasExternalAbility Parms{};

	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.HasMatchingGameplayTag
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::HasMatchingGameplayTag(const struct FGameplayTag& Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "HasMatchingGameplayTag");

	Params::AbilityActivationComponent_HasMatchingGameplayTag Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.IsAbilityActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftClassPtr<class UClass>       AbilityClass                                           (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::IsAbilityActive(const TSoftClassPtr<class UClass> AbilityClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "IsAbilityActive");

	Params::AbilityActivationComponent_IsAbilityActive Parms{};

	Parms.AbilityClass = AbilityClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityActivationComponent.IsAbilityGranted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSoftClassPtr<class UClass>       AbilityClass                                           (ConstParm, Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityActivationComponent::IsAbilityGranted(const TSoftClassPtr<class UClass> AbilityClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityActivationComponent", "IsAbilityGranted");

	Params::AbilityActivationComponent_IsAbilityGranted Parms{};

	Parms.AbilityClass = AbilityClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AligningToInteractable.OnAlignmentEnded
// (Final, Native, Private)
// Parameters:
// const EEndAlignmentResult               alignmentResult                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAligningToInteractable::OnAlignmentEnded(const EEndAlignmentResult alignmentResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AligningToInteractable", "OnAlignmentEnded");

	Params::AligningToInteractable_OnAlignmentEnded Parms{};

	Parms.alignmentResult = alignmentResult;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityComponent.OnActivated
// (Native, Event, Public, BlueprintEvent)

void UAbilityComponent::OnActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "OnActivated");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityComponent.OnActivationFailed
// (Native, Event, Public, BlueprintEvent)

void UAbilityComponent::OnActivationFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "OnActivationFailed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityComponent.OnDeactivated
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const EAbilityDeactivationReason        deactivationReason                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityComponent::OnDeactivated(const EAbilityDeactivationReason deactivationReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "OnDeactivated");

	Params::AbilityComponent_OnDeactivated Parms{};

	Parms.deactivationReason = deactivationReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityComponent.OnGranted
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               abilityOwner                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityComponent::OnGranted(class AEverholmCharacter* abilityOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "OnGranted");

	Params::AbilityComponent_OnGranted Parms{};

	Parms.abilityOwner = abilityOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityComponent.OnRevoked
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               abilityOwner                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityComponent::OnRevoked(class AEverholmCharacter* abilityOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "OnRevoked");

	Params::AbilityComponent_OnRevoked Parms{};

	Parms.abilityOwner = abilityOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityComponent.TryActivateAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityComponent::TryActivateAbility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "TryActivateAbility");

	Params::AbilityComponent_TryActivateAbility Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityComponent.TryDeactivateAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityComponent::TryDeactivateAbility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "TryDeactivateAbility");

	Params::AbilityComponent_TryDeactivateAbility Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityComponent.CanActivate
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityComponent::CanActivate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "CanActivate");

	Params::AbilityComponent_CanActivate Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAbilityComponent::CanActivateAbility() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "CanActivateAbility");

	Params::AbilityComponent_CanActivateAbility Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityComponent.GetAbilityActivationComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAbilityActivationComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityActivationComponent* UAbilityComponent::GetAbilityActivationComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "GetAbilityActivationComponent");

	Params::AbilityComponent_GetAbilityActivationComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityComponent.GetAbilityOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmCharacter*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmCharacter* UAbilityComponent::GetAbilityOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "GetAbilityOwner");

	Params::AbilityComponent_GetAbilityOwner Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAbilityComponent::IsAbilityActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "IsAbilityActive");

	Params::AbilityComponent_IsAbilityActive Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAbilityComponent::IsLocallyControlled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityComponent", "IsLocallyControlled");

	Params::AbilityComponent_IsLocallyControlled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityInterface.GetAbilityTags
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAbilityTags               ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FAbilityTags IAbilityInterface::GetAbilityTags() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("AbilityInterface", "GetAbilityTags");

	Params::AbilityInterface_GetAbilityTags Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityObject.OnActivated
// (Native, Event, Public, BlueprintEvent)

void UAbilityObject::OnActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "OnActivated");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityObject.OnActivationFailed
// (Native, Event, Public, BlueprintEvent)

void UAbilityObject::OnActivationFailed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "OnActivationFailed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityObject.OnDeactivated
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const EAbilityDeactivationReason        deactivationReason                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityObject::OnDeactivated(const EAbilityDeactivationReason deactivationReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "OnDeactivated");

	Params::AbilityObject_OnDeactivated Parms{};

	Parms.deactivationReason = deactivationReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityObject.OnGranted
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               abilityOwner                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityObject::OnGranted(class AEverholmCharacter* abilityOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "OnGranted");

	Params::AbilityObject_OnGranted Parms{};

	Parms.abilityOwner = abilityOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityObject.OnRevoked
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               abilityOwner                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityObject::OnRevoked(class AEverholmCharacter* abilityOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "OnRevoked");

	Params::AbilityObject_OnRevoked Parms{};

	Parms.abilityOwner = abilityOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityObject.TickAbility
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityObject::TickAbility(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "TickAbility");

	Params::AbilityObject_TickAbility Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AbilityObject.TryActivateAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityObject::TryActivateAbility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "TryActivateAbility");

	Params::AbilityObject_TryActivateAbility Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityObject.TryDeactivateAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityObject::TryDeactivateAbility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "TryDeactivateAbility");

	Params::AbilityObject_TryDeactivateAbility Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityObject.CanActivate
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityObject::CanActivate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "CanActivate");

	Params::AbilityObject_CanActivate Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAbilityObject::CanActivateAbility() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "CanActivateAbility");

	Params::AbilityObject_CanActivateAbility Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AbilityObject.GetAbilityOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmCharacter*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmCharacter* UAbilityObject::GetAbilityOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "GetAbilityOwner");

	Params::AbilityObject_GetAbilityOwner Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAbilityObject::IsAbilityActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityObject", "IsAbilityActive");

	Params::AbilityObject_IsAbilityActive Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AchievementBlueprintFunctionLibrary.GetAchievementProgress
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmPlayerCharacter*   Player                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// int32*                                  Current                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  Target                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAchievementBlueprintFunctionLibrary::GetAchievementProgress(const class UObject* WorldContextObject, const class AEverholmPlayerCharacter* Player, const struct FAchievementKey& Key, int32* Current, int32* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "GetAchievementProgress");

	Params::AchievementBlueprintFunctionLibrary_GetAchievementProgress Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;
	Parms.Key = std::move(Key);

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

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

	Func->FunctionFlags = Flgs;

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

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


// Function Everholm.AchievementBlueprintFunctionLibrary.IncrementAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmPlayerCharacter*   Player                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAchievementBlueprintFunctionLibrary::IncrementAchievement(class UObject* WorldContextObject, const class AEverholmPlayerCharacter* Player, const struct FAchievementKey& Key, int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "IncrementAchievement");

	Params::AchievementBlueprintFunctionLibrary_IncrementAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;
	Parms.Key = std::move(Key);
	Parms.Amount = Amount;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementBlueprintFunctionLibrary.IncrementAchievementForBothPlayers
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAchievementBlueprintFunctionLibrary::IncrementAchievementForBothPlayers(class UObject* WorldContextObject, const struct FAchievementKey& Key, int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "IncrementAchievementForBothPlayers");

	Params::AchievementBlueprintFunctionLibrary_IncrementAchievementForBothPlayers Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Key = std::move(Key);
	Parms.Amount = Amount;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementBlueprintFunctionLibrary.IncrementAchievementReference
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmPlayerCharacter*   Player                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const class FName&                      Reference                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAchievementBlueprintFunctionLibrary::IncrementAchievementReference(class UObject* WorldContextObject, const class AEverholmPlayerCharacter* Player, const struct FAchievementKey& Key, const class FName& Reference)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "IncrementAchievementReference");

	Params::AchievementBlueprintFunctionLibrary_IncrementAchievementReference Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;
	Parms.Key = std::move(Key);
	Parms.Reference = Reference;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementBlueprintFunctionLibrary.IncrementAchievementReferenceForBothPlayers
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const class FName&                      Reference                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAchievementBlueprintFunctionLibrary::IncrementAchievementReferenceForBothPlayers(class UObject* WorldContextObject, const struct FAchievementKey& Key, const class FName& Reference)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "IncrementAchievementReferenceForBothPlayers");

	Params::AchievementBlueprintFunctionLibrary_IncrementAchievementReferenceForBothPlayers Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Key = std::move(Key);
	Parms.Reference = Reference;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementBlueprintFunctionLibrary.IsAchievementUnlocked
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmPlayerCharacter*   Player                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAchievementBlueprintFunctionLibrary::IsAchievementUnlocked(const class UObject* WorldContextObject, const class AEverholmPlayerCharacter* Player, const struct FAchievementKey& Key)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "IsAchievementUnlocked");

	Params::AchievementBlueprintFunctionLibrary_IsAchievementUnlocked Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;
	Parms.Key = std::move(Key);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AchievementBlueprintFunctionLibrary.UnlockAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmPlayerCharacter*   Player                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UAchievementBlueprintFunctionLibrary::UnlockAchievement(class UObject* WorldContextObject, const class AEverholmPlayerCharacter* Player, const struct FAchievementKey& Key)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "UnlockAchievement");

	Params::AchievementBlueprintFunctionLibrary_UnlockAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;
	Parms.Key = std::move(Key);

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementBlueprintFunctionLibrary.UnlockAchievementForBothPlayers
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UAchievementBlueprintFunctionLibrary::UnlockAchievementForBothPlayers(class UObject* WorldContextObject, const struct FAchievementKey& Key)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementBlueprintFunctionLibrary", "UnlockAchievementForBothPlayers");

	Params::AchievementBlueprintFunctionLibrary_UnlockAchievementForBothPlayers Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Key = std::move(Key);

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementsProjectSettings.GetAchievementIDs
// (Final, Native, Static, Public)
// Parameters:
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UAchievementsProjectSettings::GetAchievementIDs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AchievementsProjectSettings", "GetAchievementIDs");

	Params::AchievementsProjectSettings_GetAchievementIDs Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleIntentInterpComponent.ResetTargetIntent
// (Final, Native, Public, BlueprintCallable)

void UVehicleIntentInterpComponent::ResetTargetIntent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleIntentInterpComponent", "ResetTargetIntent");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleIntentInterpComponent.SetIntent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FVehicleControlData&       Intent                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleIntentInterpComponent::SetIntent(const struct FVehicleControlData& Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleIntentInterpComponent", "SetIntent");

	Params::VehicleIntentInterpComponent_SetIntent Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementSubsystem.QueryAchievementsWhenPrimaryUserIsInitialized
// (Final, Native, Private)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Error                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAchievementSubsystem::QueryAchievementsWhenPrimaryUserIsInitialized(ELocalUserType localUserType, const class UCommonUserInfo* UserInfo, bool bSuccess, const class FString& Error)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AchievementSubsystem", "QueryAchievementsWhenPrimaryUserIsInitialized");

	Params::AchievementSubsystem_QueryAchievementsWhenPrimaryUserIsInitialized Parms{};

	Parms.localUserType = localUserType;
	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AchievementSubsystem.QueryAchievementsWhenUserIsInitialized
// (Final, Native, Private)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Error                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAchievementSubsystem::QueryAchievementsWhenUserIsInitialized(ELocalUserType localUserType, const class UCommonUserInfo* UserInfo, bool bSuccess, const class FString& Error)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AchievementSubsystem", "QueryAchievementsWhenUserIsInitialized");

	Params::AchievementSubsystem_QueryAchievementsWhenUserIsInitialized Parms{};

	Parms.localUserType = localUserType;
	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TarsierActivatableWidget.HandleVisibilityChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// ESlateVisibility                        previousVisibility                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ESlateVisibility                        NewVisibility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTarsierActivatableWidget::HandleVisibilityChanged(ESlateVisibility previousVisibility, ESlateVisibility NewVisibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TarsierActivatableWidget", "HandleVisibilityChanged");

	Params::TarsierActivatableWidget_HandleVisibilityChanged Parms{};

	Parms.previousVisibility = previousVisibility;
	Parms.NewVisibility = NewVisibility;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TarsierActivatableWidget.UpdateLastFocused
// (Final, Native, Public, BlueprintCallable)

void UTarsierActivatableWidget::UpdateLastFocused()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TarsierActivatableWidget", "UpdateLastFocused");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TarsierActivatableWidget.GetEverholmHUD
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmBaseHUD*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmBaseHUD* UTarsierActivatableWidget::GetEverholmHUD() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TarsierActivatableWidget", "GetEverholmHUD");

	Params::TarsierActivatableWidget_GetEverholmHUD Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GenericControllerMessage.OnPhysicalControllerUpdate
// (Final, Native, Protected)
// Parameters:
// bool                                    bConnected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   _ControllerId                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            InputDevice                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                _PlayerController                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGenericControllerMessage::OnPhysicalControllerUpdate(bool bConnected, int32 _ControllerId, const struct FInputDeviceId& InputDevice, class APlayerController* _PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerMessage", "OnPhysicalControllerUpdate");

	Params::GenericControllerMessage_OnPhysicalControllerUpdate Parms{};

	Parms.bConnected = bConnected;
	Parms._ControllerId = _ControllerId;
	Parms.InputDevice = std::move(InputDevice);
	Parms._PlayerController = _PlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericControllerMessage.ShowPromptWithMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (Parm, NativeAccessSpecifierPublic)
// int32                                   ControllerId                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGenericControllerMessage::ShowPromptWithMessage(const class FText& InText, int32 ControllerId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerMessage", "ShowPromptWithMessage");

	Params::GenericControllerMessage_ShowPromptWithMessage Parms{};

	Parms.InText = std::move(InText);
	Parms.ControllerId = ControllerId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIActionPoint_FollowSpline.GetFollowSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmSplineComponent*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmSplineComponent* AAIActionPoint_FollowSpline::GetFollowSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIActionPoint_FollowSpline", "GetFollowSpline");

	Params::AIActionPoint_FollowSpline_GetFollowSpline Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAction_AimAtTarget.GetRemainingAimTime
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAIAction_AimAtTarget::GetRemainingAimTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_AimAtTarget", "GetRemainingAimTime");

	Params::AIAction_AimAtTarget_GetRemainingAimTime Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameFlowEvents.GameplayLevelsStreamedOut
// (Native, Event, Public, BlueprintEvent)

void IEverholmGameFlowEvents::GameplayLevelsStreamedOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EverholmGameFlowEvents", "GameplayLevelsStreamedOut");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowEvents.PlayersDestroyed
// (Native, Event, Public, BlueprintEvent)

void IEverholmGameFlowEvents::PlayersDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EverholmGameFlowEvents", "PlayersDestroyed");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowEvents.PlayerSpawned
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AController*                      Controller                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IEverholmGameFlowEvents::PlayerSpawned(class AController* Controller)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EverholmGameFlowEvents", "PlayerSpawned");

	Params::EverholmGameFlowEvents_PlayerSpawned Parms{};

	Parms.Controller = Controller;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowEvents.PlayersSpawned
// (Native, Event, Public, BlueprintEvent)

void IEverholmGameFlowEvents::PlayersSpawned()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EverholmGameFlowEvents", "PlayersSpawned");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowEvents.SaveDataCleared
// (Native, Event, Public, BlueprintEvent)

void IEverholmGameFlowEvents::SaveDataCleared()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EverholmGameFlowEvents", "SaveDataCleared");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowEvents.StartLocationStreamedIn
// (Native, Event, Public, BlueprintEvent)

void IEverholmGameFlowEvents::StartLocationStreamedIn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EverholmGameFlowEvents", "StartLocationStreamedIn");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_AvoidTargets.SetCrowdAvoidanceDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 crowdAvoidanceVector                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_AvoidTargets::SetCrowdAvoidanceDirection(const struct FVector2D& crowdAvoidanceVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_AvoidTargets", "SetCrowdAvoidanceDirection");

	Params::AIAction_AvoidTargets_SetCrowdAvoidanceDirection Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.OnOwnerTeleported
// (Native, Public, BlueprintCallable)

void UFloatInWaterComponent::OnOwnerTeleported()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "OnOwnerTeleported");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.RegisterComponentToFollow
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  inSceneComponent                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFloatInWaterComponent::RegisterComponentToFollow(class USceneComponent* inSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "RegisterComponentToFollow");

	Params::FloatInWaterComponent_RegisterComponentToFollow Parms{};

	Parms.inSceneComponent = inSceneComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.RegisterComponentToFollowLocation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  inSceneComponent                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFloatInWaterComponent::RegisterComponentToFollowLocation(class USceneComponent* inSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "RegisterComponentToFollowLocation");

	Params::FloatInWaterComponent_RegisterComponentToFollowLocation Parms{};

	Parms.inSceneComponent = inSceneComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.RegisterComponentToFollowRotation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  inSceneComponent                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFloatInWaterComponent::RegisterComponentToFollowRotation(class USceneComponent* inSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "RegisterComponentToFollowRotation");

	Params::FloatInWaterComponent_RegisterComponentToFollowRotation Parms{};

	Parms.inSceneComponent = inSceneComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.SetCurrentWaterBody
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AWaterBody*                       inWaterBody                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFloatInWaterComponent::SetCurrentWaterBody(class AWaterBody* inWaterBody)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "SetCurrentWaterBody");

	Params::FloatInWaterComponent_SetCurrentWaterBody Parms{};

	Parms.inWaterBody = inWaterBody;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFloatInWaterComponent::SetEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "SetEnabled");

	Params::FloatInWaterComponent_SetEnabled Parms{};

	Parms.bEnable = bEnable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.SetHeightOffset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Offset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFloatInWaterComponent::SetHeightOffset(float Offset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "SetHeightOffset");

	Params::FloatInWaterComponent_SetHeightOffset Parms{};

	Parms.Offset = Offset;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FloatInWaterComponent.GetCurrentWaterBody
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWaterBody*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWaterBody* UFloatInWaterComponent::GetCurrentWaterBody() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "GetCurrentWaterBody");

	Params::FloatInWaterComponent_GetCurrentWaterBody Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

float UFloatInWaterComponent::GetHeightOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "GetHeightOffset");

	Params::FloatInWaterComponent_GetHeightOffset Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UFloatInWaterComponent::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FloatInWaterComponent", "IsEnabled");

	Params::FloatInWaterComponent_IsEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GameProgressionScript.GetStartingInventoryFor
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStartingInventory*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UStartingInventory* UGameProgressionScript::GetStartingInventoryFor(EPlayerPawnType pawnType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameProgressionScript", "GetStartingInventoryFor");

	Params::GameProgressionScript_GetStartingInventoryFor Parms{};

	Parms.pawnType = pawnType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GameProgressionScript.K2_ApplyProgression
// (Event, Protected, BlueprintEvent, Const)

void UGameProgressionScript::K2_ApplyProgression() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameProgressionScript", "K2_ApplyProgression");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.GrabHelperUserInterface.CanInteract
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IGrabHelperUserInterface::CanInteract(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("GrabHelperUserInterface", "CanInteract");

	Params::GrabHelperUserInterface_CanInteract Parms{};

	Parms.Initiator = Initiator;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GrabHelperUserInterface.GetSurfaceOffset
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IGrabHelperUserInterface::GetSurfaceOffset(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("GrabHelperUserInterface", "GetSurfaceOffset");

	Params::GrabHelperUserInterface_GetSurfaceOffset Parms{};

	Parms.Initiator = Initiator;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GrabHelperUserInterface.IsEnabled
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IGrabHelperUserInterface::IsEnabled(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("GrabHelperUserInterface", "IsEnabled");

	Params::GrabHelperUserInterface_IsEnabled Parms{};

	Parms.Initiator = Initiator;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GrabHelperUserInterface.OnInteract
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelperComponent*             GrabHelper                                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IGrabHelperUserInterface::OnInteract(class APawn* Initiator, class UGrabHelperComponent* GrabHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("GrabHelperUserInterface", "OnInteract");

	Params::GrabHelperUserInterface_OnInteract Parms{};

	Parms.Initiator = Initiator;
	Parms.GrabHelper = GrabHelper;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabHelperUserInterface.OnInteractEnd
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IGrabHelperUserInterface::OnInteractEnd(class APawn* Initiator, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("GrabHelperUserInterface", "OnInteractEnd");

	Params::GrabHelperUserInterface_OnInteractEnd Parms{};

	Parms.Initiator = Initiator;
	Parms.interactEndReason = interactEndReason;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabHelperUserInterface.OnInteractFailed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IGrabHelperUserInterface::OnInteractFailed(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("GrabHelperUserInterface", "OnInteractFailed");

	Params::GrabHelperUserInterface_OnInteractFailed Parms{};

	Parms.Initiator = Initiator;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabHelperUserInterface.GetInteractablePriority
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// EInteractablePriority                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInteractablePriority IGrabHelperUserInterface::GetInteractablePriority() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("GrabHelperUserInterface", "GetInteractablePriority");

	Params::GrabHelperUserInterface_GetInteractablePriority Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GenericPrompt.CallPromptSelected
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bSelected                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGenericPrompt::CallPromptSelected(bool bSelected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericPrompt", "CallPromptSelected");

	Params::GenericPrompt_CallPromptSelected Parms{};

	Parms.bSelected = bSelected;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericPrompt.NoButtonClicked
// (Final, Native, Protected)

void UGenericPrompt::NoButtonClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericPrompt", "NoButtonClicked");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericPrompt.ShowPromptWithMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (Parm, NativeAccessSpecifierPublic)

void UGenericPrompt::ShowPromptWithMessage(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericPrompt", "ShowPromptWithMessage");

	Params::GenericPrompt_ShowPromptWithMessage Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericPrompt.YesButtonClicked
// (Final, Native, Protected)

void UGenericPrompt::YesButtonClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericPrompt", "YesButtonClicked");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_CrowdFollowTarget.SetCrowdAvoidanceDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 crowdAvoidanceVector                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_CrowdFollowTarget::SetCrowdAvoidanceDirection(const struct FVector2D& crowdAvoidanceVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_CrowdFollowTarget", "SetCrowdAvoidanceDirection");

	Params::AIAction_CrowdFollowTarget_SetCrowdAvoidanceDirection Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_CrowdFollowTarget.SetCurrentFollowActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           FollowActor_0                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_CrowdFollowTarget::SetCurrentFollowActor(class AActor* FollowActor_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_CrowdFollowTarget", "SetCurrentFollowActor");

	Params::AIAction_CrowdFollowTarget_SetCurrentFollowActor Parms{};

	Parms.FollowActor_0 = FollowActor_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_DragObject.GetBestGrabHelper
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UDraggableComponent*              DraggableComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelperComponent**            bestGrabHelper                                         (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelperComponent**            followActorGrabHelper                                  (Parm, OutParm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_DragObject::GetBestGrabHelper(class UDraggableComponent* DraggableComponent, class UGrabHelperComponent** bestGrabHelper, class UGrabHelperComponent** followActorGrabHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_DragObject", "GetBestGrabHelper");

	Params::AIAction_DragObject_GetBestGrabHelper Parms{};

	Parms.DraggableComponent = DraggableComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Everholm.AIAction_DragObject.GetGoalLoactionMoveDirection
// (Native, Event, Protected, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UDraggableComponent*              currentlyDraggedObject                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UAIAction_DragObject::GetGoalLoactionMoveDirection(class UDraggableComponent* currentlyDraggedObject) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_DragObject", "GetGoalLoactionMoveDirection");

	Params::AIAction_DragObject_GetGoalLoactionMoveDirection Parms{};

	Parms.currentlyDraggedObject = currentlyDraggedObject;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAction_DragObject.GetMoveDirection
// (Native, Event, Protected, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class UDraggableComponent*              currentlyDraggedObject                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelperComponent*             bestGrabHelper                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         otherDragger                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldMimicIntentDirectly                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UAIAction_DragObject::GetMoveDirection(class UDraggableComponent* currentlyDraggedObject, class UGrabHelperComponent* bestGrabHelper, class AEverholmPlayerCharacter* otherDragger, bool bShouldMimicIntentDirectly) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_DragObject", "GetMoveDirection");

	Params::AIAction_DragObject_GetMoveDirection Parms{};

	Parms.currentlyDraggedObject = currentlyDraggedObject;
	Parms.bestGrabHelper = bestGrabHelper;
	Parms.otherDragger = otherDragger;
	Parms.bShouldMimicIntentDirectly = bShouldMimicIntentDirectly;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.OnActionPointQueryResult
// (Native, Protected)
// Parameters:
// class UEnvQueryInstanceBlueprintWrapper*QueryInstance                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEnvQueryStatus                         QueryStatus                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackComponentBase::OnActionPointQueryResult(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus QueryStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "OnActionPointQueryResult");

	Params::AttackComponentBase_OnActionPointQueryResult Parms{};

	Parms.QueryInstance = QueryInstance;
	Parms.QueryStatus = QueryStatus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.OnBeginOverlapWithCapsule
// (Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UAttackComponentBase::OnBeginOverlapWithCapsule(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "OnBeginOverlapWithCapsule");

	Params::AttackComponentBase_OnBeginOverlapWithCapsule Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.OnCapsuleOverlap_Multicast
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// class AEverholmCharacter*               OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackComponentBase::OnCapsuleOverlap_Multicast(class AEverholmCharacter* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "OnCapsuleOverlap_Multicast");

	Params::AttackComponentBase_OnCapsuleOverlap_Multicast Parms{};

	Parms.OtherActor = OtherActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.OnCapsuleOverlap_Server
// (Net, Native, Event, Protected, NetServer)
// Parameters:
// class AEverholmCharacter*               OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackComponentBase::OnCapsuleOverlap_Server(class AEverholmCharacter* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "OnCapsuleOverlap_Server");

	Params::AttackComponentBase_OnCapsuleOverlap_Server Parms{};

	Parms.OtherActor = OtherActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.PredictActorWithinReach
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSkipAngleCheck                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSkipClientAnimation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttackComponentBase::PredictActorWithinReach(class AActor* TargetActor, bool bSkipAngleCheck, bool bSkipClientAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "PredictActorWithinReach");

	Params::AttackComponentBase_PredictActorWithinReach Parms{};

	Parms.TargetActor = TargetActor;
	Parms.bSkipAngleCheck = bSkipAngleCheck;
	Parms.bSkipClientAnimation = bSkipClientAnimation;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.PrepareAttack
// (Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackComponentBase::PrepareAttack(class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "PrepareAttack");

	Params::AttackComponentBase_PrepareAttack Parms{};

	Parms.TargetActor = TargetActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.ResolveAttack
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FAttackData&               AttackData                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UAttackComponentBase::ResolveAttack(const struct FAttackData& AttackData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "ResolveAttack");

	Params::AttackComponentBase_ResolveAttack Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.SetPrimaryTargetActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackComponentBase::SetPrimaryTargetActor(class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "SetPrimaryTargetActor");

	Params::AttackComponentBase_SetPrimaryTargetActor Parms{};

	Parms.TargetActor = TargetActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.StartAttack
// (Native, Public, BlueprintCallable)

void UAttackComponentBase::StartAttack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "StartAttack");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.StopAttack
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bWasAborted                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       customStopSection                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackComponentBase::StopAttack(bool bWasAborted, const class FName customStopSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "StopAttack");

	Params::AttackComponentBase_StopAttack Parms{};

	Parms.bWasAborted = bWasAborted;
	Parms.customStopSection = customStopSection;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.TryToStartAttack_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSkipAngleCheck                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackComponentBase::TryToStartAttack_Multicast(class AActor* TargetActor, bool bSkipAngleCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "TryToStartAttack_Multicast");

	Params::AttackComponentBase_TryToStartAttack_Multicast Parms{};

	Parms.TargetActor = TargetActor;
	Parms.bSkipAngleCheck = bSkipAngleCheck;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackComponentBase.AllowedToAttackTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         targetEVChar                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              checkIfIntendedTarget                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttackComponentBase::AllowedToAttackTarget(const class AEverholmCharacter* targetEVChar, const bool checkIfIntendedTarget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "AllowedToAttackTarget");

	Params::AttackComponentBase_AllowedToAttackTarget Parms{};

	Parms.targetEVChar = targetEVChar;
	Parms.checkIfIntendedTarget = checkIfIntendedTarget;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.CanIgnoreClientAIPrediction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APawn*                      TargetPawn                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttackComponentBase::CanIgnoreClientAIPrediction(const class APawn* TargetPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "CanIgnoreClientAIPrediction");

	Params::AttackComponentBase_CanIgnoreClientAIPrediction Parms{};

	Parms.TargetPawn = TargetPawn;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.GetPrimaryTargetActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UAttackComponentBase::GetPrimaryTargetActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "GetPrimaryTargetActor");

	Params::AttackComponentBase_GetPrimaryTargetActor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.HasVisibility
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     TargetActor                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EVisibilityCheckMethod            overrideVisibilityCheckMethod                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttackComponentBase::HasVisibility(const class AActor* TargetActor, const EVisibilityCheckMethod overrideVisibilityCheckMethod) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "HasVisibility");

	Params::AttackComponentBase_HasVisibility Parms{};

	Parms.TargetActor = TargetActor;
	Parms.overrideVisibilityCheckMethod = overrideVisibilityCheckMethod;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.IsActorWithinReach
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     TargetActor                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSkipAngleCheck                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUsePredictedActorLocation                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttackComponentBase::IsActorWithinReach(const class AActor* TargetActor, bool bSkipAngleCheck, bool bUsePredictedActorLocation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "IsActorWithinReach");

	Params::AttackComponentBase_IsActorWithinReach Parms{};

	Parms.TargetActor = TargetActor;
	Parms.bSkipAngleCheck = bSkipAngleCheck;
	Parms.bUsePredictedActorLocation = bUsePredictedActorLocation;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.IsAllowedToAttackActor
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AController*                Controller                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttackComponentBase::IsAllowedToAttackActor(const class AActor* Actor, const class AController* Controller) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "IsAllowedToAttackActor");

	Params::AttackComponentBase_IsAllowedToAttackActor Parms{};

	Parms.Actor = Actor;
	Parms.Controller = Controller;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackComponentBase.IsPositionWithinReach
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   TargetPosition                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSkipAngleCheck                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttackComponentBase::IsPositionWithinReach(const struct FVector& TargetPosition, bool bSkipAngleCheck) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackComponentBase", "IsPositionWithinReach");

	Params::AttackComponentBase_IsPositionWithinReach Parms{};

	Parms.TargetPosition = std::move(TargetPosition);
	Parms.bSkipAngleCheck = bSkipAngleCheck;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GrabAttackComponent.DetachTarget_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabAttackComponent::DetachTarget_Multicast(class AActor* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabAttackComponent", "DetachTarget_Multicast");

	Params::GrabAttackComponent_DetachTarget_Multicast Parms{};

	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabAttackComponent.OnTargetGrabbed_Server
// (Final, Native, Public, HasOutParams)
// Parameters:
// class AActor*                           grabbedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ParentActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      SocketName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabAttackComponent::OnTargetGrabbed_Server(class AActor* grabbedActor, class AActor* ParentActor, const class FName& SocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabAttackComponent", "OnTargetGrabbed_Server");

	Params::GrabAttackComponent_OnTargetGrabbed_Server Parms{};

	Parms.grabbedActor = grabbedActor;
	Parms.ParentActor = ParentActor;
	Parms.SocketName = SocketName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabAttackComponent.OverrideAttachPointRadius_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// EAttackAttachPoint                      AttachPoint                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabAttackComponent::OverrideAttachPointRadius_Multicast(EAttackAttachPoint AttachPoint, float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabAttackComponent", "OverrideAttachPointRadius_Multicast");

	Params::GrabAttackComponent_OverrideAttachPointRadius_Multicast Parms{};

	Parms.AttachPoint = AttachPoint;
	Parms.Radius = Radius;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabAttackComponent.SetGrabTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabAttackComponent::SetGrabTarget(class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabAttackComponent", "SetGrabTarget");

	Params::GrabAttackComponent_SetGrabTarget Parms{};

	Parms.TargetActor = TargetActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabAttackComponent.StopListeningToGrabs
// (Final, Native, Public, BlueprintCallable)

void UGrabAttackComponent::StopListeningToGrabs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabAttackComponent", "StopListeningToGrabs");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GrabAttackComponent.GetAttachPointRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAttackAttachPoint                      AttachPoint                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UGrabAttackComponent::GetAttachPointRadius(EAttackAttachPoint AttachPoint) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabAttackComponent", "GetAttachPointRadius");

	Params::GrabAttackComponent_GetAttachPointRadius Parms{};

	Parms.AttachPoint = AttachPoint;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractableActor.OnInteract
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnInteract(class UEverholmInteractionComponent* InteractionComponent_0, class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnInteract");

	Params::EverholmInteractableActor_OnInteract Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractableActor.OnInteractEnd
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnInteractEnd(class UEverholmInteractionComponent* InteractionComponent_0, class APawn* Initiator, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnInteractEnd");

	Params::EverholmInteractableActor_OnInteractEnd Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.Initiator = Initiator;
	Parms.interactEndReason = interactEndReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractableActor.OnInteractFailed
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnInteractFailed(class UEverholmInteractionComponent* InteractionComponent_0, class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnInteractFailed");

	Params::EverholmInteractableActor_OnInteractFailed Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractableActor.OnInteractFocus
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bHasFocus                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnInteractFocus(class UEverholmInteractionComponent* InteractionComponent_0, class APawn* Initiator, bool bHasFocus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnInteractFocus");

	Params::EverholmInteractableActor_OnInteractFocus Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.Initiator = Initiator;
	Parms.bHasFocus = bHasFocus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractableActor.OnPrepareEndInteraction
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnPrepareEndInteraction(class UEverholmInteractionComponent* InteractionComponent_0, class AEverholmCharacter* interactor, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnPrepareEndInteraction");

	Params::EverholmInteractableActor_OnPrepareEndInteraction Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.interactor = interactor;
	Parms.interactEndReason = interactEndReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractableActor.OnPrepareStartInteraction
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnPrepareStartInteraction(class UEverholmInteractionComponent* InteractionComponent_0, class AEverholmCharacter* interactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnPrepareStartInteraction");

	Params::EverholmInteractableActor_OnPrepareStartInteraction Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.interactor = interactor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractableActor.OnSharedEventTriggered
// (Native, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      EventName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnSharedEventTriggered(class UEverholmInteractionComponent* InteractionComponent_0, const class FName& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnSharedEventTriggered");

	Params::EverholmInteractableActor_OnSharedEventTriggered Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.EventName = EventName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractableActor.OnValueChanged
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent_0                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ESharedInteractableValueID              ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsInitialization                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmInteractableActor::OnValueChanged(class UEverholmInteractionComponent* InteractionComponent_0, ESharedInteractableValueID ID, int32 NewValue, bool bIsInitialization)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractableActor", "OnValueChanged");

	Params::EverholmInteractableActor_OnValueChanged Parms{};

	Parms.InteractionComponent_0 = InteractionComponent_0;
	Parms.ID = ID;
	Parms.NewValue = NewValue;
	Parms.bIsInitialization = bIsInitialization;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.GetOffsetSockets
// (Final, Native, Static, Public)
// Parameters:
// const TArray<class FName>               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class FName> APickupBase::GetOffsetSockets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PickupBase", "GetOffsetSockets");

	Params::PickupBase_GetOffsetSockets Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetOwnerSockets
// (Final, Native, Static, Public)
// Parameters:
// const TArray<class FName>               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class FName> APickupBase::GetOwnerSockets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("PickupBase", "GetOwnerSockets");

	Params::PickupBase_GetOwnerSockets Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.AddAsStashedTo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               NewOwner                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::AddAsStashedTo(class AEverholmCharacter* NewOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "AddAsStashedTo");

	Params::PickupBase_AddAsStashedTo Parms{};

	Parms.NewOwner = NewOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.ForceDropPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bOverrideUndroppable                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDisableAfterDrop                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::ForceDropPickup(bool bOverrideUndroppable, bool bDisableAfterDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "ForceDropPickup");

	Params::PickupBase_ForceDropPickup Parms{};

	Parms.bOverrideUndroppable = bOverrideUndroppable;
	Parms.bDisableAfterDrop = bDisableAfterDrop;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.ForceStashPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::ForceStashPickup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "ForceStashPickup");

	Params::PickupBase_ForceStashPickup Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.ForceStopCurrentThrow
// (Final, Native, Public, BlueprintCallable)

void APickupBase::ForceStopCurrentThrow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "ForceStopCurrentThrow");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.HandleBeginStashing
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsQuickStash                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleBeginStashing(bool bIsQuickStash)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleBeginStashing");

	Params::PickupBase_HandleBeginStashing Parms{};

	Parms.bIsQuickStash = bIsQuickStash;

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


// Function Everholm.PickupBase.HandleBeginUnstash
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsQuickStash                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleBeginUnstash(bool bIsQuickStash)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleBeginUnstash");

	Params::PickupBase_HandleBeginUnstash Parms{};

	Parms.bIsQuickStash = bIsQuickStash;

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


// Function Everholm.PickupBase.HandleConsumed
// (Event, Protected, BlueprintEvent)

void APickupBase::HandleConsumed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleConsumed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PickupBase.HandleDrop
// (Event, Protected, BlueprintEvent)

void APickupBase::HandleDrop()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleDrop");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PickupBase.HandleHolderAnimNotify
// (Native, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void APickupBase::HandleHolderAnimNotify(class AActor* Actor, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleHolderAnimNotify");

	Params::PickupBase_HandleHolderAnimNotify Parms{};

	Parms.Actor = Actor;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.HandleHolderChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           holder                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleHolderChanged(class AActor* holder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleHolderChanged");

	Params::PickupBase_HandleHolderChanged Parms{};

	Parms.holder = holder;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.HandleInteractionEnded
// (Final, Native, Public)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleInteractionEnded(class APawn* Initiator, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleInteractionEnded");

	Params::PickupBase_HandleInteractionEnded Parms{};

	Parms.Initiator = Initiator;
	Parms.interactEndReason = interactEndReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.HandlePickedUp
// (Event, Protected, BlueprintEvent)

void APickupBase::HandlePickedUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandlePickedUp");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PickupBase.HandlePickupOwnerChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               previousOwner                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               NewOwner                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandlePickupOwnerChanged(class AEverholmCharacter* previousOwner, class AEverholmCharacter* NewOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandlePickupOwnerChanged");

	Params::PickupBase_HandlePickupOwnerChanged Parms{};

	Parms.previousOwner = previousOwner;
	Parms.NewOwner = NewOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.HandlePickupUsedForInteraction
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    interactionComp                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandlePickupUsedForInteraction(class UEverholmInteractionComponent* interactionComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandlePickupUsedForInteraction");

	Params::PickupBase_HandlePickupUsedForInteraction Parms{};

	Parms.interactionComp = interactionComp;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.HandleReleased
// (Event, Protected, BlueprintEvent)

void APickupBase::HandleReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleReleased");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PickupBase.HandleSlotted
// (Event, Protected, BlueprintEvent)
// Parameters:
// class USlotInteractionComponent*        Slot                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleSlotted(class USlotInteractionComponent* Slot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleSlotted");

	Params::PickupBase_HandleSlotted Parms{};

	Parms.Slot = Slot;

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


// Function Everholm.PickupBase.HandleStashed
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsQuickStash                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleStashed(bool bIsQuickStash)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleStashed");

	Params::PickupBase_HandleStashed Parms{};

	Parms.bIsQuickStash = bIsQuickStash;

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


// Function Everholm.PickupBase.HandleThrow
// (Event, Protected, BlueprintEvent)

void APickupBase::HandleThrow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleThrow");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PickupBase.HandleThrowImpact
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APickupBase::HandleThrowImpact(const struct FHitResult& ImpactResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleThrowImpact");

	Params::PickupBase_HandleThrowImpact Parms{};

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

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


// Function Everholm.PickupBase.HandleUnslotted
// (Event, Protected, BlueprintEvent)
// Parameters:
// class USlotInteractionComponent*        Slot                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleUnslotted(class USlotInteractionComponent* Slot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleUnslotted");

	Params::PickupBase_HandleUnslotted Parms{};

	Parms.Slot = Slot;

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


// Function Everholm.PickupBase.HandleUnstashed
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsQuickStash                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HandleUnstashed(bool bIsQuickStash)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HandleUnstashed");

	Params::PickupBase_HandleUnstashed Parms{};

	Parms.bIsQuickStash = bIsQuickStash;

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


// Function Everholm.PickupBase.HIP_EnableAutoDrop
// (Final, Native, Protected)
// Parameters:
// bool                                    bEnableAutoDrop                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::HIP_EnableAutoDrop(bool bEnableAutoDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HIP_EnableAutoDrop");

	Params::PickupBase_HIP_EnableAutoDrop Parms{};

	Parms.bEnableAutoDrop = bEnableAutoDrop;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.HOP_PickedUp
// (Final, Native, Protected)

void APickupBase::HOP_PickedUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "HOP_PickedUp");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.OnAlignmentStarted
// (Final, Native, Protected)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::OnAlignmentStarted(class AEverholmCharacter* interactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "OnAlignmentStarted");

	Params::PickupBase_OnAlignmentStarted Parms{};

	Parms.interactor = interactor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.OnIsStashedChanged
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bInIsStashed                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::OnIsStashedChanged(bool bInIsStashed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "OnIsStashedChanged");

	Params::PickupBase_OnIsStashedChanged Parms{};

	Parms.bInIsStashed = bInIsStashed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.OnProjectileStop
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void APickupBase::OnProjectileStop(const struct FHitResult& ImpactResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "OnProjectileStop");

	Params::PickupBase_OnProjectileStop Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.RemoteAttachForHandover
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Other                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::RemoteAttachForHandover(class AEverholmPlayerCharacter* Other)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "RemoteAttachForHandover");

	Params::PickupBase_RemoteAttachForHandover Parms{};

	Parms.Other = Other;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.RequestConsume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::RequestConsume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "RequestConsume");

	Params::PickupBase_RequestConsume Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.SetPickupEnabled
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsEnabled                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupBase::SetPickupEnabled(bool bInIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "SetPickupEnabled");

	Params::PickupBase_SetPickupEnabled Parms{};

	Parms.bInIsEnabled = bInIsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupBase.CanInteract
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::CanInteract(class APawn* Initiator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "CanInteract");

	Params::PickupBase_CanInteract Parms{};

	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.CanOnlyUnstash
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::CanOnlyUnstash() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "CanOnlyUnstash");

	Params::PickupBase_CanOnlyUnstash Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetCurrentSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USlotInteractionComponent*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USlotInteractionComponent* APickupBase::GetCurrentSlot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetCurrentSlot");

	Params::PickupBase_GetCurrentSlot Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetHolder
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* APickupBase::GetHolder() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetHolder");

	Params::PickupBase_GetHolder Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetInventoryName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName APickupBase::GetInventoryName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetInventoryName");

	Params::PickupBase_GetInventoryName Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::GetIsHeld() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetIsHeld");

	Params::PickupBase_GetIsHeld Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::GetIsReserved() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetIsReserved");

	Params::PickupBase_GetIsReserved Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetOwnerPickupComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmPickupComponent*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmPickupComponent* APickupBase::GetOwnerPickupComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetOwnerPickupComponent");

	Params::PickupBase_GetOwnerPickupComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetPickupOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* APickupBase::GetPickupOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetPickupOwner");

	Params::PickupBase_GetPickupOwner Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetPreviewAnim
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimSequence*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequence* APickupBase::GetPreviewAnim() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetPreviewAnim");

	Params::PickupBase_GetPreviewAnim Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetPrimitiveComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPrimitiveComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPrimitiveComponent* APickupBase::GetPrimitiveComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetPrimitiveComponent");

	Params::PickupBase_GetPrimitiveComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetProjectileComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UProjectileMovementComponent*     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UProjectileMovementComponent* APickupBase::GetProjectileComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetProjectileComponent");

	Params::PickupBase_GetProjectileComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetStashSocketName
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName APickupBase::GetStashSocketName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetStashSocketName");

	Params::PickupBase_GetStashSocketName Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.GetThrowComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UThrowItemAbilityComponent*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UThrowItemAbilityComponent* APickupBase::GetThrowComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "GetThrowComponent");

	Params::PickupBase_GetThrowComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.IsAvailableForEquipBy
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::IsAvailableForEquipBy(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsAvailableForEquipBy");

	Params::PickupBase_IsAvailableForEquipBy Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::IsClientDirected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsClientDirected");

	Params::PickupBase_IsClientDirected Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::IsDroppable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsDroppable");

	Params::PickupBase_IsDroppable Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsEnabled");

	Params::PickupBase_IsEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.IsInteractionEnabled
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::IsInteractionEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsInteractionEnabled");

	Params::PickupBase_IsInteractionEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::IsQuickStashed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsQuickStashed");

	Params::PickupBase_IsQuickStashed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::IsStashed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsStashed");

	Params::PickupBase_IsStashed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::IsThrowable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsThrowable");

	Params::PickupBase_IsThrowable Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool APickupBase::IsThrown() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "IsThrown");

	Params::PickupBase_IsThrown Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.ShouldScalePreviewHeadBone
// (Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::ShouldScalePreviewHeadBone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "ShouldScalePreviewHeadBone");

	Params::PickupBase_ShouldScalePreviewHeadBone Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupBase.ShouldToggleVisibilityWithOwner
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool APickupBase::ShouldToggleVisibilityWithOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupBase", "ShouldToggleVisibilityWithOwner");

	Params::PickupBase_ShouldToggleVisibilityWithOwner Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.StaticMeshPickup.GetMeshComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UStaticMeshComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UStaticMeshComponent* AStaticMeshPickup::GetMeshComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StaticMeshPickup", "GetMeshComponent");

	Params::StaticMeshPickup_GetMeshComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.HurdyGurdyPickup.OnOwnerChanged
// (Event, Protected, BlueprintEvent)

void AHurdyGurdyPickup::OnOwnerChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HurdyGurdyPickup", "OnOwnerChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.HurdyGurdyPickup.OnToggleUse
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AHurdyGurdyPickup::OnToggleUse()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HurdyGurdyPickup", "OnToggleUse");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.AIAction_ExecuteMultipleActions.GetCurrentActionIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAIAction_ExecuteMultipleActions::GetCurrentActionIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_ExecuteMultipleActions", "GetCurrentActionIndex");

	Params::AIAction_ExecuteMultipleActions_GetCurrentActionIndex Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.HandholdingAbility.OnCharacterSwap
// (Native, Public)

void UHandholdingAbility::OnCharacterSwap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HandholdingAbility", "OnCharacterSwap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehiclePassengerComponent.ActOnInteract
// (Native, Event, Protected, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   authForward                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehiclePassengerComponent::ActOnInteract(const struct FVector& authForward)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehiclePassengerComponent", "ActOnInteract");

	Params::VehiclePassengerComponent_ActOnInteract Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehiclePassengerComponent.Multicast_ReplicateInteract
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FVector_NetQuantizeNormal& forwardVec                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehiclePassengerComponent::Multicast_ReplicateInteract(const struct FVector_NetQuantizeNormal& forwardVec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehiclePassengerComponent", "Multicast_ReplicateInteract");

	Params::VehiclePassengerComponent_Multicast_ReplicateInteract Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehiclePassengerComponent.Multicast_ReplicateLocalRotation
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FVector_NetQuantize10&     rotationVec                                            (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehiclePassengerComponent::Multicast_ReplicateLocalRotation(const struct FVector_NetQuantize10& rotationVec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehiclePassengerComponent", "Multicast_ReplicateLocalRotation");

	Params::VehiclePassengerComponent_Multicast_ReplicateLocalRotation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehiclePassengerComponent.SetVisualParent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  sceneComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehiclePassengerComponent::SetVisualParent(class USceneComponent* sceneComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehiclePassengerComponent", "SetVisualParent");

	Params::VehiclePassengerComponent_SetVisualParent Parms{};

	Parms.sceneComp = sceneComp;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehiclePassengerComponent.UpdateTargetRotation
// (Native, Event, Protected, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UVehiclePassengerComponent::UpdateTargetRotation(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehiclePassengerComponent", "UpdateTargetRotation");

	Params::VehiclePassengerComponent_UpdateTargetRotation Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehiclePassengerComponent.UpdateVisual
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehiclePassengerComponent::UpdateVisual(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehiclePassengerComponent", "UpdateVisual");

	Params::VehiclePassengerComponent_UpdateVisual Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.BP_PostPlayerStartInVehicle
// (Event, Public, BlueprintEvent)

void AVehicleActor::BP_PostPlayerStartInVehicle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "BP_PostPlayerStartInVehicle");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.VehicleActor.CanExitVehicle
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AVehicleActor::CanExitVehicle(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "CanExitVehicle");

	Params::VehicleActor_CanExitVehicle Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.ExitAllCharactersOnVehicle
// (Final, Native, Public, BlueprintCallable)

void AVehicleActor::ExitAllCharactersOnVehicle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "ExitAllCharactersOnVehicle");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.GetUseVehicleForward
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AVehicleActor::GetUseVehicleForward()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetUseVehicleForward");

	Params::VehicleActor_GetUseVehicleForward Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.HIP_ToggleVehicle
// (Final, Native, Public)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::HIP_ToggleVehicle(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "HIP_ToggleVehicle");

	Params::VehicleActor_HIP_ToggleVehicle Parms{};

	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.Multicast_PlayStartOnVehicle
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bDriverIsBoy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::Multicast_PlayStartOnVehicle(const struct FVector& Location, const struct FRotator& Rotation, bool bDriverIsBoy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "Multicast_PlayStartOnVehicle");

	Params::VehicleActor_Multicast_PlayStartOnVehicle Parms{};

	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.bDriverIsBoy = bDriverIsBoy;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.NPCKidEnterVehicle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::NPCKidEnterVehicle(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "NPCKidEnterVehicle");

	Params::VehicleActor_NPCKidEnterVehicle Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.NPCKidExitVehicle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::NPCKidExitVehicle(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "NPCKidExitVehicle");

	Params::VehicleActor_NPCKidExitVehicle Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.OnRep_ControlledByPlayer
// (Final, Native, Protected)

void AVehicleActor::OnRep_ControlledByPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "OnRep_ControlledByPlayer");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.OnRep_DriverCharacter
// (Final, Native, Protected)
// Parameters:
// class AEverholmCharacter*               prevCharacter                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::OnRep_DriverCharacter(class AEverholmCharacter* prevCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "OnRep_DriverCharacter");

	Params::VehicleActor_OnRep_DriverCharacter Parms{};

	Parms.prevCharacter = prevCharacter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.OnRep_KidsOnVehicle
// (Final, Native, Protected)
// Parameters:
// const TArray<TWeakObjectPtr<class AEverholmCharacter>>&previousKidsOnVehicle                                  (Parm, ZeroConstructor, UObjectWrapper, NativeAccessSpecifierPublic)

void AVehicleActor::OnRep_KidsOnVehicle(const TArray<TWeakObjectPtr<class AEverholmCharacter>>& previousKidsOnVehicle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "OnRep_KidsOnVehicle");

	Params::VehicleActor_OnRep_KidsOnVehicle Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.OnRep_PassengerCharacter
// (Final, Native, Protected)
// Parameters:
// class AEverholmCharacter*               prevCharacter                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::OnRep_PassengerCharacter(class AEverholmCharacter* prevCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "OnRep_PassengerCharacter");

	Params::VehicleActor_OnRep_PassengerCharacter Parms{};

	Parms.prevCharacter = prevCharacter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.OnRep_VehicleEnabled
// (Final, Native, Protected)

void AVehicleActor::OnRep_VehicleEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "OnRep_VehicleEnabled");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.OnSpawnedFromPlayerStart
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AEverholmPlayerStartInVehicleBase*PlayerStart                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::OnSpawnedFromPlayerStart(class AEverholmPlayerStartInVehicleBase* PlayerStart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "OnSpawnedFromPlayerStart");

	Params::VehicleActor_OnSpawnedFromPlayerStart Parms{};

	Parms.PlayerStart = PlayerStart;

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


// Function Everholm.VehicleActor.PreModifyRawInput
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 controlInput                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 lookAroundInput                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector2D*                       controlInputOut                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector2D*                       lookAroundInputOut                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::PreModifyRawInput(class AEverholmCharacter* Character, const struct FVector2D& controlInput, const struct FVector2D& lookAroundInput, struct FVector2D* controlInputOut, struct FVector2D* lookAroundInputOut)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "PreModifyRawInput");

	Params::VehicleActor_PreModifyRawInput Parms{};

	Parms.Character = Character;
	Parms.controlInput = std::move(controlInput);
	Parms.lookAroundInput = std::move(lookAroundInput);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Everholm.VehicleActor.ProcessClientRawCollisionEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   rawCollisionEvent                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::ProcessClientRawCollisionEvent(int32 rawCollisionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "ProcessClientRawCollisionEvent");

	Params::VehicleActor_ProcessClientRawCollisionEvent Parms{};

	Parms.rawCollisionEvent = rawCollisionEvent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.SetControlledByPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    controlledByPlayer                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::SetControlledByPlayer(bool controlledByPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "SetControlledByPlayer");

	Params::VehicleActor_SetControlledByPlayer Parms{};

	Parms.controlledByPlayer = controlledByPlayer;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.SetDriver
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               NewDriver                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               OldDriver                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::SetDriver(class AEverholmCharacter* NewDriver, class AEverholmCharacter* OldDriver)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "SetDriver");

	Params::VehicleActor_SetDriver Parms{};

	Parms.NewDriver = NewDriver;
	Parms.OldDriver = OldDriver;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.SetDrivingCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::SetDrivingCharacter(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "SetDrivingCharacter");

	Params::VehicleActor_SetDrivingCharacter Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.SetNPC
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               NewNPC                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               OldNPC                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::SetNPC(class AEverholmCharacter* NewNPC, class AEverholmCharacter* OldNPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "SetNPC");

	Params::VehicleActor_SetNPC Parms{};

	Parms.NewNPC = NewNPC;
	Parms.OldNPC = OldNPC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.SetPassenger
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               newPassenger                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               oldPassenger                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::SetPassenger(class AEverholmCharacter* newPassenger, class AEverholmCharacter* oldPassenger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "SetPassenger");

	Params::VehicleActor_SetPassenger Parms{};

	Parms.newPassenger = newPassenger;
	Parms.oldPassenger = oldPassenger;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.SetPassengerCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::SetPassengerCharacter(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "SetPassengerCharacter");

	Params::VehicleActor_SetPassengerCharacter Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActor.UseVehicleEvent
// (Event, Protected, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   localVehicleLocation                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   localVehicleUseForward                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::UseVehicleEvent(const struct FVector& localVehicleLocation, const struct FVector& localVehicleUseForward, class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "UseVehicleEvent");

	Params::VehicleActor_UseVehicleEvent Parms{};

	Parms.localVehicleLocation = std::move(localVehicleLocation);
	Parms.localVehicleUseForward = std::move(localVehicleUseForward);
	Parms.Character = Character;

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


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

bool AVehicleActor::AreNPCKidsReady() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "AreNPCKidsReady");

	Params::VehicleActor_AreNPCKidsReady Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

float AVehicleActor::GetAlignedVehicleSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetAlignedVehicleSpeed");

	Params::VehicleActor_GetAlignedVehicleSpeed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetBaseLocationAndRotationForCharacter
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         Location                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleActor::GetBaseLocationAndRotationForCharacter(const class AEverholmCharacter* Character, struct FVector* Location, struct FRotator* Rotation, float DeltaTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetBaseLocationAndRotationForCharacter");

	Params::VehicleActor_GetBaseLocationAndRotationForCharacter Parms{};

	Parms.Character = Character;
	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


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

bool AVehicleActor::GetControlledByPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetControlledByPlayer");

	Params::VehicleActor_GetControlledByPlayer Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetDriverCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmCharacter*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmCharacter* AVehicleActor::GetDriverCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetDriverCharacter");

	Params::VehicleActor_GetDriverCharacter Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetDriverControlData
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVehicleControlData              ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FVehicleControlData AVehicleActor::GetDriverControlData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetDriverControlData");

	Params::VehicleActor_GetDriverControlData Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

float AVehicleActor::GetForwardVelocity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetForwardVelocity");

	Params::VehicleActor_GetForwardVelocity Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetManualLookaroundYawInput
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AVehicleActor::GetManualLookaroundYawInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetManualLookaroundYawInput");

	Params::VehicleActor_GetManualLookaroundYawInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetNPCKidsOnVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AEverholmCharacter*>       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AEverholmCharacter*> AVehicleActor::GetNPCKidsOnVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetNPCKidsOnVehicle");

	Params::VehicleActor_GetNPCKidsOnVehicle Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetPassengerCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmCharacter*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmCharacter* AVehicleActor::GetPassengerCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetPassengerCharacter");

	Params::VehicleActor_GetPassengerCharacter Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetPassengerControlData
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVehicleControlData              ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FVehicleControlData AVehicleActor::GetPassengerControlData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetPassengerControlData");

	Params::VehicleActor_GetPassengerControlData Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetPassengerSceneComponentForward
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AVehicleActor::GetPassengerSceneComponentForward() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetPassengerSceneComponentForward");

	Params::VehicleActor_GetPassengerSceneComponentForward Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

float AVehicleActor::GetRotationalVelocity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetRotationalVelocity");

	Params::VehicleActor_GetRotationalVelocity Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetVehicleBaseBoneForCharacter
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName AVehicleActor::GetVehicleBaseBoneForCharacter(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetVehicleBaseBoneForCharacter");

	Params::VehicleActor_GetVehicleBaseBoneForCharacter Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetVehicleBasePrimitive
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class UPrimitiveComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPrimitiveComponent* AVehicleActor::GetVehicleBasePrimitive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetVehicleBasePrimitive");

	Params::VehicleActor_GetVehicleBasePrimitive Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetVehicleCameraTrackingMultiplier
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AVehicleActor::GetVehicleCameraTrackingMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetVehicleCameraTrackingMultiplier");

	Params::VehicleActor_GetVehicleCameraTrackingMultiplier Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

float AVehicleActor::GetVehicleUseCooldownDuration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetVehicleUseCooldownDuration");

	Params::VehicleActor_GetVehicleUseCooldownDuration Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.GetVehicleVelocity
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AVehicleActor::GetVehicleVelocity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "GetVehicleVelocity");

	Params::VehicleActor_GetVehicleVelocity Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.IsDriver
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AVehicleActor::IsDriver(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "IsDriver");

	Params::VehicleActor_IsDriver Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.IsPassenger
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AVehicleActor::IsPassenger(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "IsPassenger");

	Params::VehicleActor_IsPassenger Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.IsQuickStashAllowed
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AVehicleActor::IsQuickStashAllowed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "IsQuickStashAllowed");

	Params::VehicleActor_IsQuickStashAllowed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AVehicleActor::IsSinglePlayerMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "IsSinglePlayerMode");

	Params::VehicleActor_IsSinglePlayerMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.ShouldModifyDriverInputToCameraSpace
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AVehicleActor::ShouldModifyDriverInputToCameraSpace() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "ShouldModifyDriverInputToCameraSpace");

	Params::VehicleActor_ShouldModifyDriverInputToCameraSpace Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.ShouldModifyInputForCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AVehicleActor::ShouldModifyInputForCharacter(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "ShouldModifyInputForCharacter");

	Params::VehicleActor_ShouldModifyInputForCharacter Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleActor.ShouldModifyPassengerInputToCameraSpace
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AVehicleActor::ShouldModifyPassengerInputToCameraSpace() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActor", "ShouldModifyPassengerInputToCameraSpace");

	Params::VehicleActor_ShouldModifyPassengerInputToCameraSpace Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAction_FreeRoam.SetCrowdAvoidanceDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 crowdAvoidanceVector                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_FreeRoam::SetCrowdAvoidanceDirection(const struct FVector2D& crowdAvoidanceVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_FreeRoam", "SetCrowdAvoidanceDirection");

	Params::AIAction_FreeRoam_SetCrowdAvoidanceDirection Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_Interact.OnInteractEnd
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_Interact::OnInteractEnd(class APawn* Initiator, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_Interact", "OnInteractEnd");

	Params::AIAction_Interact_OnInteractEnd Parms{};

	Parms.Initiator = Initiator;
	Parms.interactEndReason = interactEndReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_Interact.OnInteractPreambleEnd
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasAborted                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPreambleSuccessful                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_Interact::OnInteractPreambleEnd(class APawn* Initiator, bool bWasAborted, bool bPreambleSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_Interact", "OnInteractPreambleEnd");

	Params::AIAction_Interact_OnInteractPreambleEnd Parms{};

	Parms.Initiator = Initiator;
	Parms.bWasAborted = bWasAborted;
	Parms.bPreambleSuccessful = bPreambleSuccessful;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_Interact.OnPickupReleased
// (Final, Native, Private)

void UAIAction_Interact::OnPickupReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_Interact", "OnPickupReleased");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_MoveAlongSpline.SetPatrolSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             Speed                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_MoveAlongSpline::SetPatrolSpeed(const float Speed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_MoveAlongSpline", "SetPatrolSpeed");

	Params::AIAction_MoveAlongSpline_SetPatrolSpeed Parms{};

	Parms.Speed = Speed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_MoveAlongSpline.SetPatrolSpeedToDefaultSpeed
// (Final, Native, Public, BlueprintCallable)

void UAIAction_MoveAlongSpline::SetPatrolSpeedToDefaultSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_MoveAlongSpline", "SetPatrolSpeedToDefaultSpeed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.HandholdingPassengerMovementMode.OnAASBegunPlay
// (Final, Native, Public)

void UHandholdingPassengerMovementMode::OnAASBegunPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HandholdingPassengerMovementMode", "OnAASBegunPlay");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.HandholdingPassengerMovementMode.OnHandholdingStarted
// (Final, Native, Public)
// Parameters:
// class AEverholmCharacter*               newPartner                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHandholdingPassengerMovementMode::OnHandholdingStarted(class AEverholmCharacter* newPartner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HandholdingPassengerMovementMode", "OnHandholdingStarted");

	Params::HandholdingPassengerMovementMode_OnHandholdingStarted Parms{};

	Parms.newPartner = newPartner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.HandholdingPassengerMovementMode.OnHandholdingStopped
// (Final, Native, Public)
// Parameters:
// class AEverholmCharacter*               oldPartner                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHandholdingPassengerMovementMode::OnHandholdingStopped(class AEverholmCharacter* oldPartner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HandholdingPassengerMovementMode", "OnHandholdingStopped");

	Params::HandholdingPassengerMovementMode_OnHandholdingStopped Parms{};

	Parms.oldPartner = oldPartner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_PerformForcedInteract.OnInteractEnd
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_PerformForcedInteract::OnInteractEnd(class APawn* Initiator, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_PerformForcedInteract", "OnInteractEnd");

	Params::AIAction_PerformForcedInteract_OnInteractEnd Parms{};

	Parms.Initiator = Initiator;
	Parms.interactEndReason = interactEndReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_PerformForcedInteract.OnPickupReleased
// (Final, Native, Private)

void UAIAction_PerformForcedInteract::OnPickupReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_PerformForcedInteract", "OnPickupReleased");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_PlayAnimMontage.OnMainAnimationMontageFinished
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasInterrupted                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_PlayAnimMontage::OnMainAnimationMontageFinished(class UAnimMontage* AnimMontage, bool bWasInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_PlayAnimMontage", "OnMainAnimationMontageFinished");

	Params::AIAction_PlayAnimMontage_OnMainAnimationMontageFinished Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.bWasInterrupted = bWasInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_PlayAnimMontage.OnStartAnimationMontageFinished
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasInterrupted                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAction_PlayAnimMontage::OnStartAnimationMontageFinished(class UAnimMontage* AnimMontage, bool bWasInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_PlayAnimMontage", "OnStartAnimationMontageFinished");

	Params::AIAction_PlayAnimMontage_OnStartAnimationMontageFinished Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.bWasInterrupted = bWasInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAction_PlayMultipleAnimations.GetCurrentActionIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAIAction_PlayMultipleAnimations::GetCurrentActionIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAction_PlayMultipleAnimations", "GetCurrentActionIndex");

	Params::AIAction_PlayMultipleAnimations_GetCurrentActionIndex Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SkeletalMeshPickup.GetMeshComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* ASkeletalMeshPickup::GetMeshComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SkeletalMeshPickup", "GetMeshComponent");

	Params::SkeletalMeshPickup_GetMeshComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LanternPickup.BlowOut
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void ALanternPickup::BlowOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "BlowOut");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LanternPickup.OnRep_IsBlownOut
// (Event, Protected, BlueprintEvent)

void ALanternPickup::OnRep_IsBlownOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "OnRep_IsBlownOut");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.LanternPickup.Reignite
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void ALanternPickup::Reignite()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "Reignite");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LanternPickup.SetLightOn
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bTurnOn                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ALanternPickup::SetLightOn(bool bTurnOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "SetLightOn");

	Params::LanternPickup_SetLightOn Parms{};

	Parms.bTurnOn = bTurnOn;

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


// Function Everholm.LanternPickup.GetLightDetectionDirection
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ALanternPickup::GetLightDetectionDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "GetLightDetectionDirection");

	Params::LanternPickup_GetLightDetectionDirection Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LanternPickup.IsLightOn
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ALanternPickup::IsLightOn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "IsLightOn");

	Params::LanternPickup_IsLightOn Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


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

bool ALanternPickup::ShouldDisableLightForInteractionQuickStash() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "ShouldDisableLightForInteractionQuickStash");

	Params::LanternPickup_ShouldDisableLightForInteractionQuickStash Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LanternPickup.ShouldStayLitWhenStashed
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ALanternPickup::ShouldStayLitWhenStashed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternPickup", "ShouldStayLitWhenStashed");

	Params::LanternPickup_ShouldStayLitWhenStashed Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.AIAlertStateAnalyzer.GetCurrentAlertState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIAlertState                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIAlertState UAIAlertStateAnalyzer::GetCurrentAlertState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAlertStateAnalyzer", "GetCurrentAlertState");

	Params::AIAlertStateAnalyzer_GetCurrentAlertState Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAlertStateAnalyzer.GetPreviousAlertState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIAlertState                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIAlertState UAIAlertStateAnalyzer::GetPreviousAlertState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAlertStateAnalyzer", "GetPreviousAlertState");

	Params::AIAlertStateAnalyzer_GetPreviousAlertState Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAlertStateAnalyzer.IsCurrentAlertState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIAlertState                           State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIAlertStateAnalyzer::IsCurrentAlertState(EAIAlertState State) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAlertStateAnalyzer", "IsCurrentAlertState");

	Params::AIAlertStateAnalyzer_IsCurrentAlertState Parms{};

	Parms.State = State;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAlertStateAnalyzer.IsPreviousAlertState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIAlertState                           State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIAlertStateAnalyzer::IsPreviousAlertState(EAIAlertState State) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAlertStateAnalyzer", "IsPreviousAlertState");

	Params::AIAlertStateAnalyzer_IsPreviousAlertState Parms{};

	Parms.State = State;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TargetComponent.SetEnabled
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsEnabled                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTargetComponent::SetEnabled(bool bInIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetComponent", "SetEnabled");

	Params::TargetComponent_SetEnabled Parms{};

	Parms.bInIsEnabled = bInIsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetComponent.ApplySuggestedThrowParamsToTarget
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
// Parameters:
// const struct FVector&                   StartLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   throwingForce                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CollisionRadius                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GravityOverride                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFavorHighArc                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FThrowParams&                    throwParamsToCorrect                                   (Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UTargetComponent::ApplySuggestedThrowParamsToTarget(const struct FVector& StartLocation, float throwingForce, float CollisionRadius, float GravityOverride, bool bFavorHighArc, struct FThrowParams& throwParamsToCorrect) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetComponent", "ApplySuggestedThrowParamsToTarget");

	Params::TargetComponent_ApplySuggestedThrowParamsToTarget Parms{};

	Parms.StartLocation = std::move(StartLocation);
	Parms.throwingForce = throwingForce;
	Parms.CollisionRadius = CollisionRadius;
	Parms.GravityOverride = GravityOverride;
	Parms.bFavorHighArc = bFavorHighArc;
	Parms.throwParamsToCorrect = std::move(throwParamsToCorrect);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Everholm.TargetComponent.CalculateSuggestedThrowVelocity
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
// Parameters:
// const struct FVector&                   StartLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   throwingForce                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CollisionRadius                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GravityOverride                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFavorHighArc                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector&                         outVelocity                                            (Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTargetComponent::CalculateSuggestedThrowVelocity(const struct FVector& StartLocation, float throwingForce, float CollisionRadius, float GravityOverride, bool bFavorHighArc, struct FVector& outVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetComponent", "CalculateSuggestedThrowVelocity");

	Params::TargetComponent_CalculateSuggestedThrowVelocity Parms{};

	Parms.StartLocation = std::move(StartLocation);
	Parms.throwingForce = throwingForce;
	Parms.CollisionRadius = CollisionRadius;
	Parms.GravityOverride = GravityOverride;
	Parms.bFavorHighArc = bFavorHighArc;
	Parms.outVelocity = std::move(outVelocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


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

bool UTargetComponent::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetComponent", "IsEnabled");

	Params::TargetComponent_IsEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.JumpTargetComponent.GetClosestPointToPlayer
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   playerFeetLocation                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   playerVelocity                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UJumpTargetComponent::GetClosestPointToPlayer(const struct FVector& playerFeetLocation, const struct FVector& playerVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("JumpTargetComponent", "GetClosestPointToPlayer");

	Params::JumpTargetComponent_GetClosestPointToPlayer Parms{};

	Parms.playerFeetLocation = std::move(playerFeetLocation);
	Parms.playerVelocity = std::move(playerVelocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.JumpTargetComponent.GetLandingLocation
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   playerFeetLocation                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   playerVelocity                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UJumpTargetComponent::GetLandingLocation(const struct FVector& playerFeetLocation, const struct FVector& playerVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("JumpTargetComponent", "GetLandingLocation");

	Params::JumpTargetComponent_GetLandingLocation Parms{};

	Parms.playerFeetLocation = std::move(playerFeetLocation);
	Parms.playerVelocity = std::move(playerVelocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.JumpTargetComponent.GetTargetParameters
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FJumpTargetParameters      ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FJumpTargetParameters UJumpTargetComponent::GetTargetParameters() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("JumpTargetComponent", "GetTargetParameters");

	Params::JumpTargetComponent_GetTargetParameters Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.JumpTargetComponent.IsPlayerInActivationZone
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   playerFeetLocation                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   playerVelocity                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UJumpTargetComponent::IsPlayerInActivationZone(const struct FVector& playerFeetLocation, const struct FVector& playerVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("JumpTargetComponent", "IsPlayerInActivationZone");

	Params::JumpTargetComponent_IsPlayerInActivationZone Parms{};

	Parms.playerFeetLocation = std::move(playerFeetLocation);
	Parms.playerVelocity = std::move(playerVelocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.JumpTargetComponent.IsPlayerWellAligned
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   playerFeetLocation                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   playerVelocity                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UJumpTargetComponent::IsPlayerWellAligned(const struct FVector& playerFeetLocation, const struct FVector& playerVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("JumpTargetComponent", "IsPlayerWellAligned");

	Params::JumpTargetComponent_IsPlayerWellAligned Parms{};

	Parms.playerFeetLocation = std::move(playerFeetLocation);
	Parms.playerVelocity = std::move(playerVelocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.JumpTargetComponent.IsTargetRelevant
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   playerFeetLocation                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   playerForward                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   playerVelocity                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UJumpTargetComponent::IsTargetRelevant(const struct FVector& playerFeetLocation, const struct FVector& playerForward, const struct FVector& playerVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("JumpTargetComponent", "IsTargetRelevant");

	Params::JumpTargetComponent_IsTargetRelevant Parms{};

	Parms.playerFeetLocation = std::move(playerFeetLocation);
	Parms.playerForward = std::move(playerForward);
	Parms.playerVelocity = std::move(playerVelocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LanternDetectionComponent.EnableLightDetection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULanternDetectionComponent::EnableLightDetection(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternDetectionComponent", "EnableLightDetection");

	Params::LanternDetectionComponent_EnableLightDetection Parms{};

	Parms.bEnable = bEnable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LanternDetectionComponent.GetLanternPickups
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class ALanternPickup*>           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ALanternPickup*> ULanternDetectionComponent::GetLanternPickups() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternDetectionComponent", "GetLanternPickups");

	Params::LanternDetectionComponent_GetLanternPickups Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool ULanternDetectionComponent::IsInLight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LanternDetectionComponent", "IsInLight");

	Params::LanternDetectionComponent_IsInLight Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAnalyzer_FollowPointSplineAnalyzer.OnActionPointQueryResult
// (Native, Protected)
// Parameters:
// class UEnvQueryInstanceBlueprintWrapper*QueryInstance                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEnvQueryStatus                         QueryStatus                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_FollowPointSplineAnalyzer::OnActionPointQueryResult(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus QueryStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_FollowPointSplineAnalyzer", "OnActionPointQueryResult");

	Params::AIAnalyzer_FollowPointSplineAnalyzer_OnActionPointQueryResult Parms{};

	Parms.QueryInstance = QueryInstance;
	Parms.QueryStatus = QueryStatus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_FollowPointSplineAnalyzer.OnSplineOverrideAdded
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_FollowPointSplineAnalyzer::OnSplineOverrideAdded(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_FollowPointSplineAnalyzer", "OnSplineOverrideAdded");

	Params::AIAnalyzer_FollowPointSplineAnalyzer_OnSplineOverrideAdded Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_FollowPointSplineAnalyzer.OnSplineOverrideRemoved
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_FollowPointSplineAnalyzer::OnSplineOverrideRemoved(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_FollowPointSplineAnalyzer", "OnSplineOverrideRemoved");

	Params::AIAnalyzer_FollowPointSplineAnalyzer_OnSplineOverrideRemoved Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_GenericActorEQS.OnChalkboardCustomGateKeyAdded
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_GenericActorEQS::OnChalkboardCustomGateKeyAdded(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_GenericActorEQS", "OnChalkboardCustomGateKeyAdded");

	Params::AIAnalyzer_GenericActorEQS_OnChalkboardCustomGateKeyAdded Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_GenericActorEQS.OnChalkboardCustomGateKeyRemoved
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_GenericActorEQS::OnChalkboardCustomGateKeyRemoved(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_GenericActorEQS", "OnChalkboardCustomGateKeyRemoved");

	Params::AIAnalyzer_GenericActorEQS_OnChalkboardCustomGateKeyRemoved Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_GenericActorEQS.OnQueryResult
// (Native, Protected)
// Parameters:
// class UEnvQueryInstanceBlueprintWrapper*QueryInstance                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEnvQueryStatus                         QueryStatus                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_GenericActorEQS::OnQueryResult(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus QueryStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_GenericActorEQS", "OnQueryResult");

	Params::AIAnalyzer_GenericActorEQS_OnQueryResult Parms{};

	Parms.QueryInstance = QueryInstance;
	Parms.QueryStatus = QueryStatus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_GenericLocationEQS.OnChalkboardCustomGateKeyAdded
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_GenericLocationEQS::OnChalkboardCustomGateKeyAdded(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_GenericLocationEQS", "OnChalkboardCustomGateKeyAdded");

	Params::AIAnalyzer_GenericLocationEQS_OnChalkboardCustomGateKeyAdded Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_GenericLocationEQS.OnChalkboardCustomGateKeyRemoved
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_GenericLocationEQS::OnChalkboardCustomGateKeyRemoved(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_GenericLocationEQS", "OnChalkboardCustomGateKeyRemoved");

	Params::AIAnalyzer_GenericLocationEQS_OnChalkboardCustomGateKeyRemoved Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_GenericLocationEQS.OnQueryResult
// (Native, Protected)
// Parameters:
// class UEnvQueryInstanceBlueprintWrapper*QueryInstance                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEnvQueryStatus                         QueryStatus                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_GenericLocationEQS::OnQueryResult(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus QueryStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_GenericLocationEQS", "OnQueryResult");

	Params::AIAnalyzer_GenericLocationEQS_OnQueryResult Parms{};

	Parms.QueryInstance = QueryInstance;
	Parms.QueryStatus = QueryStatus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_GenericLocationEQS.OnQueryResult_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// EEnvQueryStatus                         QueryStatus                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_GenericLocationEQS::OnQueryResult_Blueprint(EEnvQueryStatus QueryStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_GenericLocationEQS", "OnQueryResult_Blueprint");

	Params::AIAnalyzer_GenericLocationEQS_OnQueryResult_Blueprint Parms{};

	Parms.QueryStatus = QueryStatus;

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


// Function Everholm.AIAnalyzer_HumbugPacifiedState.SetPacifiedState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EHumbugPacifiedState                    NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIAnalyzer_HumbugPacifiedState::SetPacifiedState(EHumbugPacifiedState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_HumbugPacifiedState", "SetPacifiedState");

	Params::AIAnalyzer_HumbugPacifiedState_SetPacifiedState Parms{};

	Parms.NewState = NewState;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAnalyzer_HumbugPacifiedState.GetPacifiedState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EHumbugPacifiedState                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EHumbugPacifiedState UAIAnalyzer_HumbugPacifiedState::GetPacifiedState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_HumbugPacifiedState", "GetPacifiedState");

	Params::AIAnalyzer_HumbugPacifiedState_GetPacifiedState Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.KeyLockInterface.GetKeyInsertTransform
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform IKeyLockInterface::GetKeyInsertTransform()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KeyLockInterface", "GetKeyInsertTransform");

	Params::KeyLockInterface_GetKeyInsertTransform Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.KeyLockInterface.LeaveKey
// (Native, Event, Public, BlueprintEvent)

void IKeyLockInterface::LeaveKey()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KeyLockInterface", "LeaveKey");

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

	AsUObject()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.OnInitializeLocalCoopUserPlatformOnlyCompleted
// (Final, Native, Protected)
// Parameters:
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      Error                                                  (Parm, NativeAccessSpecifierPublic)
// ECommonUserPrivilege                    RequestedPrivilege                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonUserOnlineContext                OnlineContext                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULocalUserSubsystem::OnInitializeLocalCoopUserPlatformOnlyCompleted(const class UCommonUserInfo* UserInfo, bool bSuccess, const class FText& Error, ECommonUserPrivilege RequestedPrivilege, ECommonUserOnlineContext OnlineContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "OnInitializeLocalCoopUserPlatformOnlyCompleted");

	Params::LocalUserSubsystem_OnInitializeLocalCoopUserPlatformOnlyCompleted Parms{};

	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);
	Parms.RequestedPrivilege = RequestedPrivilege;
	Parms.OnlineContext = OnlineContext;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.OnInitializePrimaryUserPlatformOnlyCompleted
// (Final, Native, Protected)
// Parameters:
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      Error                                                  (Parm, NativeAccessSpecifierPublic)
// ECommonUserPrivilege                    RequestedPrivilege                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonUserOnlineContext                OnlineContext                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULocalUserSubsystem::OnInitializePrimaryUserPlatformOnlyCompleted(const class UCommonUserInfo* UserInfo, bool bSuccess, const class FText& Error, ECommonUserPrivilege RequestedPrivilege, ECommonUserOnlineContext OnlineContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "OnInitializePrimaryUserPlatformOnlyCompleted");

	Params::LocalUserSubsystem_OnInitializePrimaryUserPlatformOnlyCompleted Parms{};

	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);
	Parms.RequestedPrivilege = RequestedPrivilege;
	Parms.OnlineContext = OnlineContext;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.OnInitLocalCoopUserForOnlinePlayCompleted
// (Final, Native, Protected)
// Parameters:
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      Error                                                  (Parm, NativeAccessSpecifierPublic)
// ECommonUserPrivilege                    RequestedPrivilege                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonUserOnlineContext                OnlineContext                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULocalUserSubsystem::OnInitLocalCoopUserForOnlinePlayCompleted(const class UCommonUserInfo* UserInfo, bool bSuccess, const class FText& Error, ECommonUserPrivilege RequestedPrivilege, ECommonUserOnlineContext OnlineContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "OnInitLocalCoopUserForOnlinePlayCompleted");

	Params::LocalUserSubsystem_OnInitLocalCoopUserForOnlinePlayCompleted Parms{};

	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);
	Parms.RequestedPrivilege = RequestedPrivilege;
	Parms.OnlineContext = OnlineContext;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.OnInitPrimaryUserForOnlinePlayCompleted
// (Final, Native, Protected)
// Parameters:
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      Error                                                  (Parm, NativeAccessSpecifierPublic)
// ECommonUserPrivilege                    RequestedPrivilege                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonUserOnlineContext                OnlineContext                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULocalUserSubsystem::OnInitPrimaryUserForOnlinePlayCompleted(const class UCommonUserInfo* UserInfo, bool bSuccess, const class FText& Error, ECommonUserPrivilege RequestedPrivilege, ECommonUserOnlineContext OnlineContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "OnInitPrimaryUserForOnlinePlayCompleted");

	Params::LocalUserSubsystem_OnInitPrimaryUserForOnlinePlayCompleted Parms{};

	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);
	Parms.RequestedPrivilege = RequestedPrivilege;
	Parms.OnlineContext = OnlineContext;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.TryToInitializeUserWithParams
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            InputDeviceId                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULocalUserSubsystem::TryToInitializeUserWithParams(ELocalUserType localUserType, int32 LocalPlayerIndex, const struct FInputDeviceId& InputDeviceId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "TryToInitializeUserWithParams");

	Params::LocalUserSubsystem_TryToInitializeUserWithParams Parms{};

	Parms.localUserType = localUserType;
	Parms.LocalPlayerIndex = LocalPlayerIndex;
	Parms.InputDeviceId = std::move(InputDeviceId);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.TryToLoginUserForOnlinePlay
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShowAccountUpgradeUIOnFailedLogin                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULocalUserSubsystem::TryToLoginUserForOnlinePlay(ELocalUserType localUserType, bool bShowAccountUpgradeUIOnFailedLogin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "TryToLoginUserForOnlinePlay");

	Params::LocalUserSubsystem_TryToLoginUserForOnlinePlay Parms{};

	Parms.localUserType = localUserType;
	Parms.bShowAccountUpgradeUIOnFailedLogin = bShowAccountUpgradeUIOnFailedLogin;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.TryToLogOutUser
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ULocalUserSubsystem::TryToLogOutUser(ELocalUserType localUserType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "TryToLogOutUser");

	Params::LocalUserSubsystem_TryToLogOutUser Parms{};

	Parms.localUserType = localUserType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalUserSubsystem.UpdateUserPrivilege_BP
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ELocalUserType                          userType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonUserOnlineContext                OnlineContext                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonUserPrivilege                    privilegeToCheck                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULocalUserSubsystem::UpdateUserPrivilege_BP(ELocalUserType userType, ECommonUserOnlineContext OnlineContext, ECommonUserPrivilege privilegeToCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "UpdateUserPrivilege_BP");

	Params::LocalUserSubsystem_UpdateUserPrivilege_BP Parms{};

	Parms.userType = userType;
	Parms.OnlineContext = OnlineContext;
	Parms.privilegeToCheck = privilegeToCheck;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LocalUserSubsystem.GetUser
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCommonUserInfo*            ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UCommonUserInfo* ULocalUserSubsystem::GetUser(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "GetUser");

	Params::LocalUserSubsystem_GetUser Parms{};

	Parms.localUserType = localUserType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalUserSubsystem.IsUserInitialized
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ULocalUserSubsystem::IsUserInitialized(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "IsUserInitialized");

	Params::LocalUserSubsystem_IsUserInitialized Parms{};

	Parms.localUserType = localUserType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalUserSubsystem.IsUserLoggedInOnNativePlatform
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ULocalUserSubsystem::IsUserLoggedInOnNativePlatform(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "IsUserLoggedInOnNativePlatform");

	Params::LocalUserSubsystem_IsUserLoggedInOnNativePlatform Parms{};

	Parms.localUserType = localUserType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalUserSubsystem.IsUserReadyForOnlinePlay
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ULocalUserSubsystem::IsUserReadyForOnlinePlay(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "IsUserReadyForOnlinePlay");

	Params::LocalUserSubsystem_IsUserReadyForOnlinePlay Parms{};

	Parms.localUserType = localUserType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool ULocalUserSubsystem::PrimaryUserInitRequiresPressToStartScreen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LocalUserSubsystem", "PrimaryUserInitRequiresPressToStartScreen");

	Params::LocalUserSubsystem_PrimaryUserInitRequiresPressToStartScreen Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MeleeAttackComponent.CheckOverlapsAndResolveAttack
// (Native, Public, BlueprintCallable)
// Parameters:
// const TSubclassOf<class ADeathHandlerBase>DeathHandler                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMeleeAttackComponent::CheckOverlapsAndResolveAttack(const TSubclassOf<class ADeathHandlerBase> DeathHandler)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MeleeAttackComponent", "CheckOverlapsAndResolveAttack");

	Params::MeleeAttackComponent_CheckOverlapsAndResolveAttack Parms{};

	Parms.DeathHandler = DeathHandler;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MeleeAttackComponent.OnActorOverlappedTrigger
// (Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMeleeAttackComponent::OnActorOverlappedTrigger(class AActor* OverlappedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MeleeAttackComponent", "OnActorOverlappedTrigger");

	Params::MeleeAttackComponent_OnActorOverlappedTrigger Parms{};

	Parms.OverlappedActor = OverlappedActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnalyzer_StuckAnalyzer.OnTargetActorUpdated
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAnalyzer_StuckAnalyzer::OnTargetActorUpdated(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnalyzer_StuckAnalyzer", "OnTargetActorUpdated");

	Params::AIAnalyzer_StuckAnalyzer_OnTargetActorUpdated Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAnimMontageDataAsset.GetMontageByTurnAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAIAnimMontageType                      animType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   animAngle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsHostile                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const uint8                             customAIAnimMontageType                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UAIAnimMontageDataAsset::GetMontageByTurnAngle(EAIAnimMontageType animType, float animAngle, bool bIsHostile, const uint8 customAIAnimMontageType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAnimMontageDataAsset", "GetMontageByTurnAngle");

	Params::AIAnimMontageDataAsset_GetMontageByTurnAngle Parms{};

	Parms.animType = animType;
	Parms.animAngle = animAngle;
	Parms.bIsHostile = bIsHostile;
	Parms.customAIAnimMontageType = customAIAnimMontageType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MainMenuWidget.OnPlaybackPaused
// (Event, Public, BlueprintEvent)

void UMainMenuWidget::OnPlaybackPaused()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MainMenuWidget", "OnPlaybackPaused");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.MainMenuWidget.OnPlaybackStarted
// (Event, Public, BlueprintEvent)

void UMainMenuWidget::OnPlaybackStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MainMenuWidget", "OnPlaybackStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.AIAttachmentEffectComponent.OnAttachmentUpdate
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class AActor*                     attachedActor                                          (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAttached                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAttachmentEffectComponent::OnAttachmentUpdate(const class AActor* attachedActor, bool bIsAttached)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachmentEffectComponent", "OnAttachmentUpdate");

	Params::AIAttachmentEffectComponent_OnAttachmentUpdate Parms{};

	Parms.attachedActor = attachedActor;
	Parms.bIsAttached = bIsAttached;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAttachmentEffectComponent.OnAttachmentUpdate_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// bool                                    bIsAttached                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAttachmentEffectComponent::OnAttachmentUpdate_Multicast(bool bIsAttached)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachmentEffectComponent", "OnAttachmentUpdate_Multicast");

	Params::AIAttachmentEffectComponent_OnAttachmentUpdate_Multicast Parms{};

	Parms.bIsAttached = bIsAttached;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAttachmentEffectComponent.OnWarningGameplayEffectApplied_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UAIAttachmentEffectComponent::OnWarningGameplayEffectApplied_Multicast()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachmentEffectComponent", "OnWarningGameplayEffectApplied_Multicast");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAttachmentEffectComponent.GetTimeLeftUntilEffectHappens
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAIAttachmentEffectComponent::GetTimeLeftUntilEffectHappens() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachmentEffectComponent", "GetTimeLeftUntilEffectHappens");

	Params::AIAttachmentEffectComponent_GetTimeLeftUntilEffectHappens Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAIAttachmentEffectComponent::IsAttachmentCountdownActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachmentEffectComponent", "IsAttachmentCountdownActive");

	Params::AIAttachmentEffectComponent_IsAttachmentCountdownActive Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAttachToMeshComponent.AttachActorToSlot_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Protected, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAttachSlot&               AttachSlot                                             (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// EAttachmentRule                         AttachmentRule                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAttachToMeshComponent::AttachActorToSlot_Multicast(class AActor* Actor, const struct FAttachSlot& AttachSlot, EAttachmentRule AttachmentRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "AttachActorToSlot_Multicast");

	Params::AIAttachToMeshComponent_AttachActorToSlot_Multicast Parms{};

	Parms.Actor = Actor;
	Parms.AttachSlot = std::move(AttachSlot);
	Parms.AttachmentRule = AttachmentRule;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAttachToMeshComponent.DetachActorFromSlot_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Protected, BlueprintCallable)
// Parameters:
// const struct FAttachSlot&               AttachSlot                                             (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// EDetachmentRule                         detachmentRule                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAttachToMeshComponent::DetachActorFromSlot_Multicast(const struct FAttachSlot& AttachSlot, EDetachmentRule detachmentRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "DetachActorFromSlot_Multicast");

	Params::AIAttachToMeshComponent_DetachActorFromSlot_Multicast Parms{};

	Parms.AttachSlot = std::move(AttachSlot);
	Parms.detachmentRule = detachmentRule;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAttachToMeshComponent.DetachAllActors
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EDetachmentRule                         detachmentRule                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAttachToMeshComponent::DetachAllActors(EDetachmentRule detachmentRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "DetachAllActors");

	Params::AIAttachToMeshComponent_DetachAllActors Parms{};

	Parms.detachmentRule = detachmentRule;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAttachToMeshComponent.GetAttachedActorsCountOfClass
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class AActor>               ActorClass                                             (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAIAttachToMeshComponent::GetAttachedActorsCountOfClass(TSubclassOf<class AActor> ActorClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "GetAttachedActorsCountOfClass");

	Params::AIAttachToMeshComponent_GetAttachedActorsCountOfClass Parms{};

	Parms.ActorClass = ActorClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAttachToMeshComponent.RemoveActorFromAttachSlot
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EDetachmentRule                         detachmentRule                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIAttachToMeshComponent::RemoveActorFromAttachSlot(const class AActor* Actor, EDetachmentRule detachmentRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "RemoveActorFromAttachSlot");

	Params::AIAttachToMeshComponent_RemoveActorFromAttachSlot Parms{};

	Parms.Actor = Actor;
	Parms.detachmentRule = detachmentRule;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIAttachToMeshComponent.TryAttachSlot
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           requestingActor                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         AttachmentRule                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIAttachToMeshComponent::TryAttachSlot(class AActor* requestingActor, EAttachmentRule AttachmentRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "TryAttachSlot");

	Params::AIAttachToMeshComponent_TryAttachSlot Parms{};

	Parms.requestingActor = requestingActor;
	Parms.AttachmentRule = AttachmentRule;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAIAttachToMeshComponent::CanBeAttached() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "CanBeAttached");

	Params::AIAttachToMeshComponent_CanBeAttached Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAttachToMeshComponent.GetFreeAttachSocket
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UAIAttachToMeshComponent::GetFreeAttachSocket() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttachToMeshComponent", "GetFreeAttachSocket");

	Params::AIAttachToMeshComponent_GetFreeAttachSocket Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIAttackAnimationsDataAsset.GetAttackAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAttackType                             attackType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Angle                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UAIAttackAnimationsDataAsset::GetAttackAnimation(EAttackType attackType, float Angle, float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIAttackAnimationsDataAsset", "GetAttackAnimation");

	Params::AIAttackAnimationsDataAsset_GetAttackAnimation Parms{};

	Parms.attackType = attackType;
	Parms.Angle = Angle;
	Parms.Distance = Distance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AICombatComponent.ClearCombatAnimDataOverride
// (Final, Native, Public, BlueprintCallable)

void UAICombatComponent::ClearCombatAnimDataOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "ClearCombatAnimDataOverride");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.ClearMaxHealthOverride
// (Final, Native, Public, BlueprintCallable)

void UAICombatComponent::ClearMaxHealthOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "ClearMaxHealthOverride");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.Die
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     killAnim                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAICombatComponent::Die(class UAnimMontage* killAnim)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "Die");

	Params::AICombatComponent_Die Parms{};

	Parms.killAnim = killAnim;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.OnAttackRecoverySuccessful
// (Final, Native, Private)

void UAICombatComponent::OnAttackRecoverySuccessful()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "OnAttackRecoverySuccessful");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.OnDamageTaken
// (Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     Instigator                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             healthPostDamage                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             healthPreDamage                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAICombatComponent::OnDamageTaken(const class AActor* Instigator, const int32 healthPostDamage, const int32 healthPreDamage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "OnDamageTaken");

	Params::AICombatComponent_OnDamageTaken Parms{};

	Parms.Instigator = Instigator;
	Parms.healthPostDamage = healthPostDamage;
	Parms.healthPreDamage = healthPreDamage;

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


// Function Everholm.AICombatComponent.OnPointDamageTaken
// (Final, Native, Private, HasDefaults)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ShotFromDirection                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAICombatComponent::OnPointDamageTaken(class AActor* DamagedActor, float Damage, class AController* InstigatedBy, const struct FVector& HitLocation, class UPrimitiveComponent* HitComponent, class FName BoneName, const struct FVector& ShotFromDirection, const class UDamageType* DamageType, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "OnPointDamageTaken");

	Params::AICombatComponent_OnPointDamageTaken Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.InstigatedBy = InstigatedBy;
	Parms.HitLocation = std::move(HitLocation);
	Parms.HitComponent = HitComponent;
	Parms.BoneName = BoneName;
	Parms.ShotFromDirection = std::move(ShotFromDirection);
	Parms.DamageType = DamageType;
	Parms.DamageCauser = DamageCauser;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.ResetHealth
// (Final, Native, Public, BlueprintCallable)

void UAICombatComponent::ResetHealth()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "ResetHealth");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.SetCombatAnimDataOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAICombatMontagesDataAsset*       animDataOverride                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAICombatComponent::SetCombatAnimDataOverride(class UAICombatMontagesDataAsset* animDataOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "SetCombatAnimDataOverride");

	Params::AICombatComponent_SetCombatAnimDataOverride Parms{};

	Parms.animDataOverride = animDataOverride;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.SetMaxHealthOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   maxHealthOverride                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAICombatComponent::SetMaxHealthOverride(float maxHealthOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "SetMaxHealthOverride");

	Params::AICombatComponent_SetMaxHealthOverride Parms{};

	Parms.maxHealthOverride = maxHealthOverride;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.SetupBrainRefs
// (Final, Native, Private)

void UAICombatComponent::SetupBrainRefs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "SetupBrainRefs");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AICombatComponent.GetCombatAnimData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAICombatMontagesDataAsset*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAICombatMontagesDataAsset* UAICombatComponent::GetCombatAnimData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "GetCombatAnimData");

	Params::AICombatComponent_GetCombatAnimData Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

float UAICombatComponent::GetMaxHealth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "GetMaxHealth");

	Params::AICombatComponent_GetMaxHealth Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AICombatComponent.GetRelevantDeathHandler
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class ADeathHandlerBase>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class ADeathHandlerBase> UAICombatComponent::GetRelevantDeathHandler() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatComponent", "GetRelevantDeathHandler");

	Params::AICombatComponent_GetRelevantDeathHandler Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MaskPickup.EquipCinematicMaskToProxyMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           maskMesh                                               (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           proxyMesh                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerPawnType                         PlayerPawnType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMaskPickup::EquipCinematicMaskToProxyMesh(class USkeletalMeshComponent* maskMesh, class USkeletalMeshComponent* proxyMesh, EPlayerPawnType PlayerPawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MaskPickup", "EquipCinematicMaskToProxyMesh");

	Params::MaskPickup_EquipCinematicMaskToProxyMesh Parms{};

	Parms.maskMesh = maskMesh;
	Parms.proxyMesh = proxyMesh;
	Parms.PlayerPawnType = PlayerPawnType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MaskPickup.HandleMaskBoneHidden
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bShouldHide                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           MeshComponent                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMaskPickup::HandleMaskBoneHidden(bool bShouldHide, class USkeletalMeshComponent* MeshComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MaskPickup", "HandleMaskBoneHidden");

	Params::MaskPickup_HandleMaskBoneHidden Parms{};

	Parms.bShouldHide = bShouldHide;
	Parms.MeshComponent = MeshComponent;

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


// Function Everholm.MaskPickup.HandleMaskSwapStarted
// (Event, Public, BlueprintEvent)

void AMaskPickup::HandleMaskSwapStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MaskPickup", "HandleMaskSwapStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.MaskPickup.OnIsEquippedAsMaskChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bIsEquipped                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMaskPickup::OnIsEquippedAsMaskChanged(bool bIsEquipped)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MaskPickup", "OnIsEquippedAsMaskChanged");

	Params::MaskPickup_OnIsEquippedAsMaskChanged Parms{};

	Parms.bIsEquipped = bIsEquipped;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


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

bool AMaskPickup::IsEquippedAsMask() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MaskPickup", "IsEquippedAsMask");

	Params::MaskPickup_IsEquippedAsMask Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AICombatMontagesDataAsset.GetMontageByHitAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EAICombatMontageType              animType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             animAngle                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UAICombatMontagesDataAsset::GetMontageByHitAngle(const EAICombatMontageType animType, const float animAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICombatMontagesDataAsset", "GetMontageByHitAngle");

	Params::AICombatMontagesDataAsset_GetMontageByHitAngle Parms{};

	Parms.animType = animType;
	Parms.animAngle = animAngle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AICrowdAnalyzer.OnActionPointQueryResult
// (Final, Native, Protected)
// Parameters:
// class UEnvQueryInstanceBlueprintWrapper*QueryInstance                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEnvQueryStatus                         QueryStatus                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAICrowdAnalyzer::OnActionPointQueryResult(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus QueryStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AICrowdAnalyzer", "OnActionPointQueryResult");

	Params::AICrowdAnalyzer_OnActionPointQueryResult Parms{};

	Parms.QueryInstance = QueryInstance;
	Parms.QueryStatus = QueryStatus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GameEffectManagerComponent.C_PlayGameEffect
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const struct FNetworkedGameEffectProperties&Data                                                   (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UGameEffectManagerComponent::C_PlayGameEffect(const struct FNetworkedGameEffectProperties& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffectManagerComponent", "C_PlayGameEffect");

	Params::GameEffectManagerComponent_C_PlayGameEffect Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GameEffectManagerComponent.OnGameEffectEnded
// (Final, Native, Protected)
// Parameters:
// class UGameEffect*                      GameEffect                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGameEffectManagerComponent::OnGameEffectEnded(class UGameEffect* GameEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffectManagerComponent", "OnGameEffectEnded");

	Params::GameEffectManagerComponent_OnGameEffectEnded Parms{};

	Parms.GameEffect = GameEffect;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GameEffectManagerComponent.PlayGameEffect
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FNetworkedGameEffectProperties&Data                                                   (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UGameEffectManagerComponent::PlayGameEffect(const struct FNetworkedGameEffectProperties& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffectManagerComponent", "PlayGameEffect");

	Params::GameEffectManagerComponent_PlayGameEffect Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GameEffectManagerComponent.S_PlayGameEffect
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const struct FNetworkedGameEffectProperties&Data                                                   (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UGameEffectManagerComponent::S_PlayGameEffect(const struct FNetworkedGameEffectProperties& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffectManagerComponent", "S_PlayGameEffect");

	Params::GameEffectManagerComponent_S_PlayGameEffect Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIEncounterDataComponent.FreeAttackSlot
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                            attacker                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIEncounterDataComponent::FreeAttackSlot(class APawn* attacker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "FreeAttackSlot");

	Params::AIEncounterDataComponent_FreeAttackSlot Parms{};

	Parms.attacker = attacker;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIEncounterDataComponent.IsAllowedToAttack
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            attacker                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIEncounterDataComponent::IsAllowedToAttack(class APawn* attacker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "IsAllowedToAttack");

	Params::AIEncounterDataComponent_IsAllowedToAttack Parms{};

	Parms.attacker = attacker;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIEncounterDataComponent.IsReserved
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            attacker                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIEncounterDataComponent::IsReserved(class APawn* attacker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "IsReserved");

	Params::AIEncounterDataComponent_IsReserved Parms{};

	Parms.attacker = attacker;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIEncounterDataComponent.PerformFakeAttack
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UAIEncounterDataComponent::PerformFakeAttack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "PerformFakeAttack");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIEncounterDataComponent.ReserveAttackSlot
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                            attacker                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIEncounterDataComponent::ReserveAttackSlot(class APawn* attacker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "ReserveAttackSlot");

	Params::AIEncounterDataComponent_ReserveAttackSlot Parms{};

	Parms.attacker = attacker;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIEncounterDataComponent.SetInDangerStatus
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bInDanger                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIEncounterDataComponent::SetInDangerStatus(const bool bInDanger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "SetInDangerStatus");

	Params::AIEncounterDataComponent_SetInDangerStatus Parms{};

	Parms.bInDanger = bInDanger;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIEncounterDataComponent.SetMaxAttackReservationSlots
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const int32                             MaxReservations                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIEncounterDataComponent::SetMaxAttackReservationSlots(const int32 MaxReservations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "SetMaxAttackReservationSlots");

	Params::AIEncounterDataComponent_SetMaxAttackReservationSlots Parms{};

	Parms.MaxReservations = MaxReservations;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIEncounterDataComponent.SetUseAttackReservations
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              useAttackReservations                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIEncounterDataComponent::SetUseAttackReservations(const bool useAttackReservations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "SetUseAttackReservations");

	Params::AIEncounterDataComponent_SetUseAttackReservations Parms{};

	Parms.useAttackReservations = useAttackReservations;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIEncounterDataComponent.GetAmountOfCurrentlyReservedAttackers
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAIEncounterDataComponent::GetAmountOfCurrentlyReservedAttackers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "GetAmountOfCurrentlyReservedAttackers");

	Params::AIEncounterDataComponent_GetAmountOfCurrentlyReservedAttackers Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAIEncounterDataComponent::IsInDanger() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "IsInDanger");

	Params::AIEncounterDataComponent_IsInDanger Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIEncounterDataComponent.ShouldFakeAttack
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APawn*                      attacker                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAIEncounterDataComponent::ShouldFakeAttack(const class APawn* attacker) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIEncounterDataComponent", "ShouldFakeAttack");

	Params::AIEncounterDataComponent_ShouldFakeAttack Parms{};

	Parms.attacker = attacker;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.ApplyExternalBlendHints
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TArray<class AExternalCameraBlendingVolume*>*blendingVolumes                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::ApplyExternalBlendHints(const struct FCameraHintInParameters& Params_0, TArray<class AExternalCameraBlendingVolume*>* blendingVolumes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "ApplyExternalBlendHints");

	Params::DirectedCameraHint_Base_ApplyExternalBlendHints Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.ComputeBlendingResult
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// double                                  BlendTarget                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldBlendIn                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldSkipSmoothBlending                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

double ADirectedCameraHint_Base::ComputeBlendingResult(double BlendTarget, bool bShouldBlendIn, float DeltaTime, bool bShouldSkipSmoothBlending)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "ComputeBlendingResult");

	Params::DirectedCameraHint_Base_ComputeBlendingResult Parms{};

	Parms.BlendTarget = BlendTarget;
	Parms.bShouldBlendIn = bShouldBlendIn;
	Parms.DeltaTime = DeltaTime;
	Parms.bShouldSkipSmoothBlending = bShouldSkipSmoothBlending;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.DebugDraw
// (Native, Event, Public, BlueprintEvent)

void ADirectedCameraHint_Base::DebugDraw()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "DebugDraw");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DirectedCameraHint_Base.GetCollisionComponents
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<class UPrimitiveComponent*>      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UPrimitiveComponent*> ADirectedCameraHint_Base::GetCollisionComponents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetCollisionComponents");

	Params::DirectedCameraHint_Base_GetCollisionComponents Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetSemantics
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<ECameraHintSemantic>             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<ECameraHintSemantic> ADirectedCameraHint_Base::GetSemantics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetSemantics");

	Params::DirectedCameraHint_Base_GetSemantics Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.HIP_ForceHintRelevant
// (Final, Native, Protected, BlueprintCallable)

void ADirectedCameraHint_Base::HIP_ForceHintRelevant()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "HIP_ForceHintRelevant");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DirectedCameraHint_Base.HIP_OverrideBlendAlpha
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// double                                  Data                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADirectedCameraHint_Base::HIP_OverrideBlendAlpha(double Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "HIP_OverrideBlendAlpha");

	Params::DirectedCameraHint_Base_HIP_OverrideBlendAlpha Parms{};

	Parms.Data = Data;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DirectedCameraHint_Base.HIP_SetEnabled
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    Data                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADirectedCameraHint_Base::HIP_SetEnabled(bool Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "HIP_SetEnabled");

	Params::DirectedCameraHint_Base_HIP_SetEnabled Parms{};

	Parms.Data = Data;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DirectedCameraHint_Base.HIP_SetMaxBlendWeight
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// double                                  Data                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADirectedCameraHint_Base::HIP_SetMaxBlendWeight(double Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "HIP_SetMaxBlendWeight");

	Params::DirectedCameraHint_Base_HIP_SetMaxBlendWeight Parms{};

	Parms.Data = Data;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DirectedCameraHint_Base.PopulateSemantics
// (Final, Native, Protected, BlueprintCallable)

void ADirectedCameraHint_Base::PopulateSemantics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "PopulateSemantics");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DirectedCameraHint_Base.TryAddExternalBlendingReference
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class AExternalCameraBlendingVolume>externalBlendingreference                              (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ADirectedCameraHint_Base::TryAddExternalBlendingReference(TSoftObjectPtr<class AExternalCameraBlendingVolume> externalBlendingreference)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "TryAddExternalBlendingReference");

	Params::DirectedCameraHint_Base_TryAddExternalBlendingReference Parms{};

	Parms.externalBlendingreference = externalBlendingreference;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.Update
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FCameraHintInParameters&   cameraHintIn                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void ADirectedCameraHint_Base::Update(const struct FCameraHintInParameters& cameraHintIn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "Update");

	Params::DirectedCameraHint_Base_Update Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DirectedCameraHint_Base.EaseBlendAlpha
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::EaseBlendAlpha() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "EaseBlendAlpha");

	Params::DirectedCameraHint_Base_EaseBlendAlpha Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetAimOffsetLeadMultiplier
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetAimOffsetLeadMultiplier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetAimOffsetLeadMultiplier");

	Params::DirectedCameraHint_Base_GetAimOffsetLeadMultiplier Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetArmLengthMultiplier
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   DefaultArmLength                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetArmLengthMultiplier(float DefaultArmLength) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetArmLengthMultiplier");

	Params::DirectedCameraHint_Base_GetArmLengthMultiplier Parms{};

	Parms.DefaultArmLength = DefaultArmLength;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetCameraAimOffset
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator ADirectedCameraHint_Base::GetCameraAimOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetCameraAimOffset");

	Params::DirectedCameraHint_Base_GetCameraAimOffset Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetCameraRotation
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator ADirectedCameraHint_Base::GetCameraRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetCameraRotation");

	Params::DirectedCameraHint_Base_GetCameraRotation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetCurrentBlendWeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetCurrentBlendWeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetCurrentBlendWeight");

	Params::DirectedCameraHint_Base_GetCurrentBlendWeight Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetDefaultArmLength
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

double ADirectedCameraHint_Base::GetDefaultArmLength() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetDefaultArmLength");

	Params::DirectedCameraHint_Base_GetDefaultArmLength Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetDeltaFOV
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   DefaultFOV                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetDeltaFOV(float DefaultFOV) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetDeltaFOV");

	Params::DirectedCameraHint_Base_GetDeltaFOV Parms{};

	Parms.DefaultFOV = DefaultFOV;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetDisableAvoidanceWithHintWeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetDisableAvoidanceWithHintWeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetDisableAvoidanceWithHintWeight");

	Params::DirectedCameraHint_Base_GetDisableAvoidanceWithHintWeight Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetDOFFocusRegion
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetDOFFocusRegion() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetDOFFocusRegion");

	Params::DirectedCameraHint_Base_GetDOFFocusRegion Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetFocalPointOffset
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADirectedCameraHint_Base::GetFocalPointOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetFocalPointOffset");

	Params::DirectedCameraHint_Base_GetFocalPointOffset Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetFOVOffset
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   DefaultFOV                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetFOVOffset(float DefaultFOV) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetFOVOffset");

	Params::DirectedCameraHint_Base_GetFOVOffset Parms{};

	Parms.DefaultFOV = DefaultFOV;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetHintDrawLocWorldSpace
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADirectedCameraHint_Base::GetHintDrawLocWorldSpace() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetHintDrawLocWorldSpace");

	Params::DirectedCameraHint_Base_GetHintDrawLocWorldSpace Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetHintFOV
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

double ADirectedCameraHint_Base::GetHintFOV() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetHintFOV");

	Params::DirectedCameraHint_Base_GetHintFOV Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetLookAroundLimits
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator ADirectedCameraHint_Base::GetLookAroundLimits() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetLookAroundLimits");

	Params::DirectedCameraHint_Base_GetLookAroundLimits Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetOverrideRotInterpSpeed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ADirectedCameraHint_Base::GetOverrideRotInterpSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetOverrideRotInterpSpeed");

	Params::DirectedCameraHint_Base_GetOverrideRotInterpSpeed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetTargetTransformAbsolute
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform ADirectedCameraHint_Base::GetTargetTransformAbsolute() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetTargetTransformAbsolute");

	Params::DirectedCameraHint_Base_GetTargetTransformAbsolute Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraHint_Base.GetTargetTransformRelative
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform ADirectedCameraHint_Base::GetTargetTransformRelative() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraHint_Base", "GetTargetTransformRelative");

	Params::DirectedCameraHint_Base_GetTargetTransformRelative Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SphereHint_Base.SetupSphereHint
// (Final, Native, Protected, BlueprintCallable)

void ASphereHint_Base::SetupSphereHint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SphereHint_Base", "SetupSphereHint");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIHordeSystem.GetAmountOfHordeAIHostileToTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     TargetActor                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSubclassOf<class AActor>         hordeAIActorClass                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAIHordeSystem::GetAmountOfHordeAIHostileToTarget(const class AActor* TargetActor, const TSubclassOf<class AActor> hordeAIActorClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHordeSystem", "GetAmountOfHordeAIHostileToTarget");

	Params::AIHordeSystem_GetAmountOfHordeAIHostileToTarget Parms{};

	Parms.TargetActor = TargetActor;
	Parms.hordeAIActorClass = hordeAIActorClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIHordeSystem.ReserveFreeSurroundSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           SelfActor                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     TargetActor                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             requestedRadius                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAISurroundComponent*             targetSurroundComponent                                (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FSurroundSlot                    ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FSurroundSlot UAIHordeSystem::ReserveFreeSurroundSlot(class AActor* SelfActor, const class AActor* TargetActor, const float requestedRadius, class UAISurroundComponent* targetSurroundComponent) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHordeSystem", "ReserveFreeSurroundSlot");

	Params::AIHordeSystem_ReserveFreeSurroundSlot Parms{};

	Parms.SelfActor = SelfActor;
	Parms.TargetActor = TargetActor;
	Parms.requestedRadius = requestedRadius;
	Parms.targetSurroundComponent = targetSurroundComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIHordeSystem.UnregisterFromSurroundSlot
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class AActor*                     TargetActor                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           SelfActor                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAISurroundComponent*             targetSurroundComponent                                (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIHordeSystem::UnregisterFromSurroundSlot(const class AActor* TargetActor, class AActor* SelfActor, class UAISurroundComponent* targetSurroundComponent) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHordeSystem", "UnregisterFromSurroundSlot");

	Params::AIHordeSystem_UnregisterFromSurroundSlot Parms{};

	Parms.TargetActor = TargetActor;
	Parms.SelfActor = SelfActor;
	Parms.targetSurroundComponent = targetSurroundComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CameraHintProcessorBase.Initialize
// (Native, Event, Public, BlueprintEvent)

void UCameraHintProcessorBase::Initialize()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintProcessorBase", "Initialize");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CameraHintProcessorBase.ProcessHint
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class ADirectedCameraHint_Base*         hint                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UCameraHintProcessorBase::ProcessHint(class ADirectedCameraHint_Base* hint, const struct FCameraHintInParameters& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintProcessorBase", "ProcessHint");

	Params::CameraHintProcessorBase_ProcessHint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MapPickup.CloseMap
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AMapPickup::CloseMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MapPickup", "CloseMap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MapPickup.OpenMap
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bSkipAnimation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMapPickup::OpenMap(bool bSkipAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MapPickup", "OpenMap");

	Params::MapPickup_OpenMap Parms{};

	Parms.bSkipAnimation = bSkipAnimation;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MapPickup.IsMapOpen
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AMapPickup::IsMapOpen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MapPickup", "IsMapOpen");

	Params::MapPickup_IsMapOpen Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.GameEffect.EndGameEffect
// (Native, Public, BlueprintCallable)

void UGameEffect::EndGameEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffect", "EndGameEffect");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GameEffect.OnEndGameEffect
// (Event, Public, BlueprintEvent)

void UGameEffect::OnEndGameEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffect", "OnEndGameEffect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.GameEffect.OnPlayGameEffect
// (Native, Event, Public, BlueprintEvent)

void UGameEffect::OnPlayGameEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffect", "OnPlayGameEffect");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIAnimator.GetMontageByTurnAngle
// (Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// EAIAnimMontageType                      animType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   animAngle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UEverholmAIAnimator::GetMontageByTurnAngle(EAIAnimMontageType animType, float animAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimator", "GetMontageByTurnAngle");

	Params::EverholmAIAnimator_GetMontageByTurnAngle Parms{};

	Parms.animType = animType;
	Parms.animAngle = animAngle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIReaction_FindAndMoveToLocation.FindAndSetNewTargetLocation
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   avoidDirection                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIReaction_FindAndMoveToLocation::FindAndSetNewTargetLocation(const struct FVector& avoidDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_FindAndMoveToLocation", "FindAndSetNewTargetLocation");

	Params::AIReaction_FindAndMoveToLocation_FindAndSetNewTargetLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIReaction_FindAndMoveToLocation.MoveToNewLocation
// (Final, Native, Protected, BlueprintCallable)

void UAIReaction_FindAndMoveToLocation::MoveToNewLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_FindAndMoveToLocation", "MoveToNewLocation");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIReaction_FollowTarget.GetAcceptanceRadius
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAIReaction_FollowTarget::GetAcceptanceRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_FollowTarget", "GetAcceptanceRadius");

	Params::AIReaction_FollowTarget_GetAcceptanceRadius Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.AIReaction_FollowTarget.GetFollowDistance
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAIReaction_FollowTarget::GetFollowDistance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_FollowTarget", "GetFollowDistance");

	Params::AIReaction_FollowTarget_GetFollowDistance Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.AIReaction_FollowTarget.GetLeewayDistance
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAIReaction_FollowTarget::GetLeewayDistance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_FollowTarget", "GetLeewayDistance");

	Params::AIReaction_FollowTarget_GetLeewayDistance Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.AIReaction_FollowTarget.GetTargetActor
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UAIReaction_FollowTarget::GetTargetActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_FollowTarget", "GetTargetActor");

	Params::AIReaction_FollowTarget_GetTargetActor Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAINavigator.AddDesiredMovement
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Movement                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAINavigator::AddDesiredMovement(const struct FVector& Movement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "AddDesiredMovement");

	Params::EverholmAINavigator_AddDesiredMovement Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAINavigator.OnQuickTurnAnimationFinished
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasInterrupted                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAINavigator::OnQuickTurnAnimationFinished(class UAnimMontage* AnimMontage, bool bWasInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "OnQuickTurnAnimationFinished");

	Params::EverholmAINavigator_OnQuickTurnAnimationFinished Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.bWasInterrupted = bWasInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAINavigator.OnWalkStartAnimationFinished
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasInterrupted                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAINavigator::OnWalkStartAnimationFinished(class UAnimMontage* AnimMontage, bool bWasInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "OnWalkStartAnimationFinished");

	Params::EverholmAINavigator_OnWalkStartAnimationFinished Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.bWasInterrupted = bWasInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAINavigator.OnWalkStopAnimationFinished
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasInterrupted                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAINavigator::OnWalkStopAnimationFinished(class UAnimMontage* AnimMontage, bool bWasInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "OnWalkStopAnimationFinished");

	Params::EverholmAINavigator_OnWalkStopAnimationFinished Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.bWasInterrupted = bWasInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAINavigator.SetDesiredMovement
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Movement                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAINavigator::SetDesiredMovement(const struct FVector& Movement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "SetDesiredMovement");

	Params::EverholmAINavigator_SetDesiredMovement Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAINavigator.SetUseDesiredRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// bool                                    bUseDesiredRotation                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  NewRotation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UEverholmAINavigator::SetUseDesiredRotation(bool bUseDesiredRotation, const struct FRotator& NewRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "SetUseDesiredRotation");

	Params::EverholmAINavigator_SetUseDesiredRotation Parms{};

	Parms.bUseDesiredRotation = bUseDesiredRotation;
	Parms.NewRotation = std::move(NewRotation);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAINavigator.GetCurrentSpeed2D
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bIsActualVelocity                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

double UEverholmAINavigator::GetCurrentSpeed2D(bool bIsActualVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetCurrentSpeed2D");

	Params::EverholmAINavigator_GetCurrentSpeed2D Parms{};

	Parms.bIsActualVelocity = bIsActualVelocity;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAINavigator.GetDefaultCrouchAcceleration
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAINavigator::GetDefaultCrouchAcceleration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetDefaultCrouchAcceleration");

	Params::EverholmAINavigator_GetDefaultCrouchAcceleration Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAINavigator.GetDefaultMaxCrouchMovementSpeed
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAINavigator::GetDefaultMaxCrouchMovementSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetDefaultMaxCrouchMovementSpeed");

	Params::EverholmAINavigator_GetDefaultMaxCrouchMovementSpeed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAINavigator.GetDefaultMaxSprintSpeed
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAINavigator::GetDefaultMaxSprintSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetDefaultMaxSprintSpeed");

	Params::EverholmAINavigator_GetDefaultMaxSprintSpeed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAINavigator.GetDefaultMaxWalkMovementSpeed
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAINavigator::GetDefaultMaxWalkMovementSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetDefaultMaxWalkMovementSpeed");

	Params::EverholmAINavigator_GetDefaultMaxWalkMovementSpeed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAINavigator.GetDefaultWalkAcceleration
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAINavigator::GetDefaultWalkAcceleration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetDefaultWalkAcceleration");

	Params::EverholmAINavigator_GetDefaultWalkAcceleration Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmAINavigator::GetIsCrouching() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetIsCrouching");

	Params::EverholmAINavigator_GetIsCrouching Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmAINavigator::GetIsJumping() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetIsJumping");

	Params::EverholmAINavigator_GetIsJumping Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmAINavigator::GetIsSprinting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetIsSprinting");

	Params::EverholmAINavigator_GetIsSprinting Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAINavigator.GetMovementDelta
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmAINavigator::GetMovementDelta() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAINavigator", "GetMovementDelta");

	Params::EverholmAINavigator_GetMovementDelta Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AIReaction_PinDownTarget.OnFakeAttackDone
// (Final, Native, Public)
// Parameters:
// const bool                              bWasAborted                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIReaction_PinDownTarget::OnFakeAttackDone(const bool bWasAborted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_PinDownTarget", "OnFakeAttackDone");

	Params::AIReaction_PinDownTarget_OnFakeAttackDone Parms{};

	Parms.bWasAborted = bWasAborted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIReaction_PinDownTarget.OnIntoAnimResolvedEvent
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FAttackData&               AttackData                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UAIReaction_PinDownTarget::OnIntoAnimResolvedEvent(const struct FAttackData& AttackData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_PinDownTarget", "OnIntoAnimResolvedEvent");

	Params::AIReaction_PinDownTarget_OnIntoAnimResolvedEvent Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIReaction_PinDownTarget.ReleaseVictim
// (Final, Native, Public)
// Parameters:
// const bool                              bWasAborted                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIReaction_PinDownTarget::ReleaseVictim(const bool bWasAborted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_PinDownTarget", "ReleaseVictim");

	Params::AIReaction_PinDownTarget_ReleaseVictim Parms{};

	Parms.bWasAborted = bWasAborted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIReaction_PinDownAndSaveVictim.OnPindownSaved
// (Final, Native, Private)

void UAIReaction_PinDownAndSaveVictim::OnPindownSaved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_PinDownAndSaveVictim", "OnPindownSaved");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AIReaction_PinDownAndSaveVictim.OnPindownTimerEnded
// (Final, Native, Private)

void UAIReaction_PinDownAndSaveVictim::OnPindownTimerEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIReaction_PinDownAndSaveVictim", "OnPindownTimerEnded");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.CheckPickupConditions
// (Native, Protected, BlueprintCallable)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInteractionComponent::CheckPickupConditions(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "CheckPickupConditions");

	Params::EverholmInteractionComponent_CheckPickupConditions Parms{};

	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.EndPreamble
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bAbortInteraction                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::EndPreamble(bool bAbortInteraction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "EndPreamble");

	Params::EverholmInteractionComponent_EndPreamble Parms{};

	Parms.bAbortInteraction = bAbortInteraction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.HasRequiredPickup
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIgnorePickupOptionality                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInteractionComponent::HasRequiredPickup(class APawn* Initiator, bool bIgnorePickupOptionality)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "HasRequiredPickup");

	Params::EverholmInteractionComponent_HasRequiredPickup Parms{};

	Parms.Initiator = Initiator;
	Parms.bIgnorePickupOptionality = bIgnorePickupOptionality;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.HIP_EndInteraction
// (Final, Native, Protected)

void UEverholmInteractionComponent::HIP_EndInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "HIP_EndInteraction");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.HIP_OrderCompanionInteract
// (Final, Native, Protected)

void UEverholmInteractionComponent::HIP_OrderCompanionInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "HIP_OrderCompanionInteract");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.HIP_SetInteractionEnabled
// (Final, Native, Protected)
// Parameters:
// bool                                    newIsEnabled                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::HIP_SetInteractionEnabled(bool newIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "HIP_SetInteractionEnabled");

	Params::EverholmInteractionComponent_HIP_SetInteractionEnabled Parms{};

	Parms.newIsEnabled = newIsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.HOP_OnInteractEnd
// (Final, Native, Protected)

void UEverholmInteractionComponent::HOP_OnInteractEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "HOP_OnInteractEnd");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.HOP_OnInteractStart
// (Final, Native, Protected)

void UEverholmInteractionComponent::HOP_OnInteractStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "HOP_OnInteractStart");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnAlignmentEnded
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEndAlignmentResult                     alignmentResult                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnAlignmentEnded(class AEverholmCharacter* interactor, EEndAlignmentResult alignmentResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnAlignmentEnded");

	Params::EverholmInteractionComponent_OnAlignmentEnded Parms{};

	Parms.interactor = interactor;
	Parms.alignmentResult = alignmentResult;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnAlignmentStarted
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnAlignmentStarted(class AEverholmCharacter* interactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnAlignmentStarted");

	Params::EverholmInteractionComponent_OnAlignmentStarted Parms{};

	Parms.interactor = interactor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnBlockingMontageBlendingOut
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnBlockingMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnBlockingMontageBlendingOut");

	Params::EverholmInteractionComponent_OnBlockingMontageBlendingOut Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnInteractorAnimNotify
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class AActor*                           interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnInteractorAnimNotify(class AActor* interactor, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnInteractorAnimNotify");

	Params::EverholmInteractionComponent_OnInteractorAnimNotify Parms{};

	Parms.interactor = interactor;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnPrepareEndInteraction
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnPrepareEndInteraction(class AEverholmCharacter* interactor, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnPrepareEndInteraction");

	Params::EverholmInteractionComponent_OnPrepareEndInteraction Parms{};

	Parms.interactor = interactor;
	Parms.interactEndReason = interactEndReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnPrepareStartInteraction
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnPrepareStartInteraction(class AEverholmCharacter* interactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnPrepareStartInteraction");

	Params::EverholmInteractionComponent_OnPrepareStartInteraction Parms{};

	Parms.interactor = interactor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnSharedEventTriggered
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class FName&                      EventName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnSharedEventTriggered(const class FName& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnSharedEventTriggered");

	Params::EverholmInteractionComponent_OnSharedEventTriggered Parms{};

	Parms.EventName = EventName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.OnValueChanged
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const ESharedInteractableValueID        ID                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32&                            NewValue                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsInitialization                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::OnValueChanged(const ESharedInteractableValueID ID, const int32& NewValue, bool bIsInitialization)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "OnValueChanged");

	Params::EverholmInteractionComponent_OnValueChanged Parms{};

	Parms.ID = ID;
	Parms.NewValue = NewValue;
	Parms.bIsInitialization = bIsInitialization;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.PlayBlockingMontage
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FPlayAnimMontageSettings&  Settings                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmInteractionComponent::PlayBlockingMontage(const struct FPlayAnimMontageSettings& Settings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "PlayBlockingMontage");

	Params::EverholmInteractionComponent_PlayBlockingMontage Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.SetAdditionalInteractorLocalOffset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FTransformUnscaled&        Offset                                                 (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)
// const float                             alignmentSpeedOverride                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::SetAdditionalInteractorLocalOffset(const struct FTransformUnscaled& Offset, const float alignmentSpeedOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "SetAdditionalInteractorLocalOffset");

	Params::EverholmInteractionComponent_SetAdditionalInteractorLocalOffset Parms{};

	Parms.Offset = std::move(Offset);
	Parms.alignmentSpeedOverride = alignmentSpeedOverride;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.SetPickupConditionEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    newIsEnabled                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::SetPickupConditionEnabled(bool newIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "SetPickupConditionEnabled");

	Params::EverholmInteractionComponent_SetPickupConditionEnabled Parms{};

	Parms.newIsEnabled = newIsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.SetSharedValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const ESharedInteractableValueID        ID                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Value                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::SetSharedValue(const ESharedInteractableValueID ID, const int32 Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "SetSharedValue");

	Params::EverholmInteractionComponent_SetSharedValue Parms{};

	Parms.ID = ID;
	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionComponent.TriggerSharedEvent
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      EventName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         optionalLocalExecutor                                  (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractionComponent::TriggerSharedEvent(const class FName& EventName, class AEverholmPlayerCharacter* optionalLocalExecutor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "TriggerSharedEvent");

	Params::EverholmInteractionComponent_TriggerSharedEvent Parms{};

	Parms.EventName = EventName;
	Parms.optionalLocalExecutor = optionalLocalExecutor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


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

bool UEverholmInteractionComponent::AllowsEmptyHands() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "AllowsEmptyHands");

	Params::EverholmInteractionComponent_AllowsEmptyHands Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmInteractionComponent::DontUnstashAfterInteract() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "DontUnstashAfterInteract");

	Params::EverholmInteractionComponent_DontUnstashAfterInteract Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.GetCurrentInteractor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UEverholmInteractionComponent::GetCurrentInteractor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "GetCurrentInteractor");

	Params::EverholmInteractionComponent_GetCurrentInteractor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.GetIconWorldLocation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform UEverholmInteractionComponent::GetIconWorldLocation(class APawn* Initiator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "GetIconWorldLocation");

	Params::EverholmInteractionComponent_GetIconWorldLocation Parms{};

	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.GetInteractionCancelBehaviour
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInteractionComponent::GetInteractionCancelBehaviour() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "GetInteractionCancelBehaviour");

	Params::EverholmInteractionComponent_GetInteractionCancelBehaviour Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.GetLastInteractor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UEverholmInteractionComponent::GetLastInteractor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "GetLastInteractor");

	Params::EverholmInteractionComponent_GetLastInteractor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractionComponent.GetSharedValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const ESharedInteractableValueID        ID                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInteractionComponent::GetSharedValue(const ESharedInteractableValueID ID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "GetSharedValue");

	Params::EverholmInteractionComponent_GetSharedValue Parms{};

	Parms.ID = ID;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmInteractionComponent::HasInteractor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "HasInteractor");

	Params::EverholmInteractionComponent_HasInteractor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmInteractionComponent::IsPickupInteraction() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "IsPickupInteraction");

	Params::EverholmInteractionComponent_IsPickupInteraction Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmInteractionComponent::RequiresEmptyHands() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "RequiresEmptyHands");

	Params::EverholmInteractionComponent_RequiresEmptyHands Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UEverholmInteractionComponent::StashLighterDuringInteract() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractionComponent", "StashLighterDuringInteract");

	Params::EverholmInteractionComponent_StashLighterDuringInteract Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoopInteractionDraggableActor.EndDraggableInteraction
// (Final, Native, Protected, BlueprintCallable)

void ACoopInteractionDraggableActor::EndDraggableInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "EndDraggableInteraction");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.HandlePlayerIntent
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTwoPlayerDragging                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionDraggableActor::HandlePlayerIntent(const struct FVector& Intent, bool bTwoPlayerDragging)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "HandlePlayerIntent");

	Params::CoopInteractionDraggableActor_HandlePlayerIntent Parms{};

	Parms.Intent = std::move(Intent);
	Parms.bTwoPlayerDragging = bTwoPlayerDragging;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.OnPlayerEnterDrag
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionDraggableActor::OnPlayerEnterDrag(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "OnPlayerEnterDrag");

	Params::CoopInteractionDraggableActor_OnPlayerEnterDrag Parms{};

	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.OnPlayerExitDrag
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionDraggableActor::OnPlayerExitDrag(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "OnPlayerExitDrag");

	Params::CoopInteractionDraggableActor_OnPlayerExitDrag Parms{};

	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.OnRep_DragTargetOffset
// (Final, Native, Protected)

void ACoopInteractionDraggableActor::OnRep_DragTargetOffset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "OnRep_DragTargetOffset");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.OnRep_GrabbingPawns
// (Final, Native, Protected)

void ACoopInteractionDraggableActor::OnRep_GrabbingPawns()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "OnRep_GrabbingPawns");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.OnRep_ReachedTarget
// (Final, Native, Protected)

void ACoopInteractionDraggableActor::OnRep_ReachedTarget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "OnRep_ReachedTarget");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.ProgressEndReached
// (Event, Protected, BlueprintEvent)

void ACoopInteractionDraggableActor::ProgressEndReached()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "ProgressEndReached");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.CoopInteractionDraggableActor.ResetProgress
// (Final, Native, Protected, BlueprintCallable)

void ACoopInteractionDraggableActor::ResetProgress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "ResetProgress");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.SetDragTargetLocation
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   NewTargetLocation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionDraggableActor::SetDragTargetLocation(const struct FVector& NewTargetLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "SetDragTargetLocation");

	Params::CoopInteractionDraggableActor_SetDragTargetLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionDraggableActor.UpdateDraggableProgress
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   Alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionDraggableActor::UpdateDraggableProgress(float Alpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "UpdateDraggableProgress");

	Params::CoopInteractionDraggableActor_UpdateDraggableProgress Parms{};

	Parms.Alpha = Alpha;

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


// Function Everholm.CoopInteractionDraggableActor.UpdatePlayersDraggingCount
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   OldCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewCount                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionDraggableActor::UpdatePlayersDraggingCount(int32 OldCount, int32 NewCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionDraggableActor", "UpdatePlayersDraggingCount");

	Params::CoopInteractionDraggableActor_UpdatePlayersDraggingCount Parms{};

	Parms.OldCount = OldCount;
	Parms.NewCount = NewCount;

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


// Function Everholm.AISplineWallClimbingComponent.CalculateAlignment
// (Final, Native, Public)

void UAISplineWallClimbingComponent::CalculateAlignment()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISplineWallClimbingComponent", "CalculateAlignment");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AISplineWallClimbingComponent.ForceAlignmentRecalculation
// (Final, Native, Public, BlueprintCallable)

void UAISplineWallClimbingComponent::ForceAlignmentRecalculation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISplineWallClimbingComponent", "ForceAlignmentRecalculation");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


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

bool UAISplineWallClimbingComponent::DrawDebugPath() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISplineWallClimbingComponent", "DrawDebugPath");

	Params::AISplineWallClimbingComponent_DrawDebugPath Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AISplineWallClimbingComponent.GetInfoAtDistanceAlongSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             travelledDistanceAlongSpline                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              travellingOppositeDirection                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             CapsuleHalfHeight                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInfoAtSplineDistance            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FInfoAtSplineDistance UAISplineWallClimbingComponent::GetInfoAtDistanceAlongSpline(const class AActor* Actor, const float travelledDistanceAlongSpline, const bool travellingOppositeDirection, const float CapsuleHalfHeight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISplineWallClimbingComponent", "GetInfoAtDistanceAlongSpline");

	Params::AISplineWallClimbingComponent_GetInfoAtDistanceAlongSpline Parms{};

	Parms.Actor = Actor;
	Parms.travelledDistanceAlongSpline = travelledDistanceAlongSpline;
	Parms.travellingOppositeDirection = travellingOppositeDirection;
	Parms.CapsuleHalfHeight = CapsuleHalfHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AISplineWallClimbingComponent.GetSplineSurfaceNormalAtDistanceAlongSpline
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             travelledDistanceAlongSpline                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UAISplineWallClimbingComponent::GetSplineSurfaceNormalAtDistanceAlongSpline(const float travelledDistanceAlongSpline) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISplineWallClimbingComponent", "GetSplineSurfaceNormalAtDistanceAlongSpline");

	Params::AISplineWallClimbingComponent_GetSplineSurfaceNormalAtDistanceAlongSpline Parms{};

	Parms.travelledDistanceAlongSpline = travelledDistanceAlongSpline;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CollectibleComponent.Collect
// (Final, Native, Public, BlueprintCallable)

void UCollectibleComponent::Collect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CollectibleComponent", "Collect");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CollectibleComponent.HasBeenCollectedByPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class APawn*                      targetPlayer                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCollectibleComponent::HasBeenCollectedByPlayer(const class APawn* targetPlayer) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CollectibleComponent", "HasBeenCollectedByPlayer");

	Params::CollectibleComponent_HasBeenCollectedByPlayer Parms{};

	Parms.targetPlayer = targetPlayer;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AISurroundComponent.RemoveSurroundActorFromSlotByActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAISurroundComponent::RemoveSurroundActorFromSlotByActor(const class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISurroundComponent", "RemoveSurroundActorFromSlotByActor");

	Params::AISurroundComponent_RemoveSurroundActorFromSlotByActor Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AISurroundComponent.RequestSurroundSlot
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           requestingActor                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   CurrentPosition                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             desiredRadius                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FSurroundSlot                    ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FSurroundSlot UAISurroundComponent::RequestSurroundSlot(class AActor* requestingActor, const struct FVector& CurrentPosition, const float desiredRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISurroundComponent", "RequestSurroundSlot");

	Params::AISurroundComponent_RequestSurroundSlot Parms{};

	Parms.requestingActor = requestingActor;
	Parms.CurrentPosition = std::move(CurrentPosition);
	Parms.desiredRadius = desiredRadius;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAISurroundComponent::CanBeSurrounded() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISurroundComponent", "CanBeSurrounded");

	Params::AISurroundComponent_CanBeSurrounded Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UAISurroundTargetAction::IsAtGoalLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AISurroundTargetAction", "IsAtGoalLocation");

	Params::AISurroundTargetAction_IsAtGoalLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CrouchComponent.RequestCrouchAmount
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// float                                   CrouchAmount                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*&                   requester                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCrouchComponent::RequestCrouchAmount(float CrouchAmount, const class UObject*& requester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CrouchComponent", "RequestCrouchAmount");

	Params::CrouchComponent_RequestCrouchAmount Parms{};

	Parms.CrouchAmount = CrouchAmount;
	Parms.requester = requester;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CrouchComponent.SetEnableEncroachmentCheck
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResetCrouch                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCrouchComponent::SetEnableEncroachmentCheck(bool bEnabled, bool bResetCrouch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CrouchComponent", "SetEnableEncroachmentCheck");

	Params::CrouchComponent_SetEnableEncroachmentCheck Parms{};

	Parms.bEnabled = bEnabled;
	Parms.bResetCrouch = bResetCrouch;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CrouchComponent.UnrequestCrouchAmount
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   requester                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCrouchComponent::UnrequestCrouchAmount(const class UObject*& requester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CrouchComponent", "UnrequestCrouchAmount");

	Params::CrouchComponent_UnrequestCrouchAmount Parms{};

	Parms.requester = requester;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CrouchComponent.UpdateOwnerAnimInstance
// (Final, Native, Protected)

void UCrouchComponent::UpdateOwnerAnimInstance()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CrouchComponent", "UpdateOwnerAnimInstance");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


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

float UCrouchComponent::GetCurrentCrouchAmount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CrouchComponent", "GetCurrentCrouchAmount");

	Params::CrouchComponent_GetCurrentCrouchAmount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

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

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

	Params::CrouchComponent_IsCrouching Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AligningMovementMode.OnAnimMontageBlendOut
// (Final, Native, Public)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAligningMovementMode::OnAnimMontageBlendOut(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AligningMovementMode", "OnAnimMontageBlendOut");

	Params::AligningMovementMode_OnAnimMontageBlendOut Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AligningMovementMode.OnAnimMontageEnded
// (Final, Native, Public)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAligningMovementMode::OnAnimMontageEnded(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AligningMovementMode", "OnAnimMontageEnded");

	Params::AligningMovementMode_OnAnimMontageEnded Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AligningMovementMode.OnAnimMontageStarted
// (Final, Native, Public)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAligningMovementMode::OnAnimMontageStarted(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AligningMovementMode", "OnAnimMontageStarted");

	Params::AligningMovementMode_OnAnimMontageStarted Parms{};

	Parms.Montage = Montage;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionMontagePlay.CheckForExecuteConditionMet
// (Final, Native, Protected)

void ACoopInteractionMontagePlay::CheckForExecuteConditionMet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "CheckForExecuteConditionMet");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionMontagePlay.ExecuteTimerDone
// (Final, Native, Protected)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionMontagePlay::ExecuteTimerDone(class UEverholmInteractionComponent* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "ExecuteTimerDone");

	Params::CoopInteractionMontagePlay_ExecuteTimerDone Parms{};

	Parms.Interaction = Interaction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionMontagePlay.GetInteractorTransformOffset
// (Event, Protected, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform ACoopInteractionMontagePlay::GetInteractorTransformOffset(class UEverholmInteractionComponent* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "GetInteractorTransformOffset");

	Params::CoopInteractionMontagePlay_GetInteractorTransformOffset Parms{};

	Parms.Interaction = Interaction;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.CoopInteractionMontagePlay.InteractExecuteMontageEnd
// (Event, Public, BlueprintEvent)

void ACoopInteractionMontagePlay::InteractExecuteMontageEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "InteractExecuteMontageEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.CoopInteractionMontagePlay.InteractPlayerExit
// (Event, Public, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionMontagePlay::InteractPlayerExit(class UEverholmInteractionComponent* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "InteractPlayerExit");

	Params::CoopInteractionMontagePlay_InteractPlayerExit Parms{};

	Parms.Interaction = Interaction;

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


// Function Everholm.CoopInteractionMontagePlay.InteractPlayersExecute
// (Event, Public, BlueprintEvent)

void ACoopInteractionMontagePlay::InteractPlayersExecute()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "InteractPlayersExecute");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.CoopInteractionMontagePlay.InteractPlayerWaiting
// (Event, Public, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionMontagePlay::InteractPlayerWaiting(class UEverholmInteractionComponent* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "InteractPlayerWaiting");

	Params::CoopInteractionMontagePlay_InteractPlayerWaiting Parms{};

	Parms.Interaction = Interaction;

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


// Function Everholm.CoopInteractionMontagePlay.RequestCompanionInteractStart
// (Native, Event, Protected, BlueprintEvent)

void ACoopInteractionMontagePlay::RequestCompanionInteractStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "RequestCompanionInteractStart");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionMontagePlay.SetPlayOverrideEndSection
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOverride                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACoopInteractionMontagePlay::SetPlayOverrideEndSection(class UEverholmInteractionComponent* Interaction, bool bOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "SetPlayOverrideEndSection");

	Params::CoopInteractionMontagePlay_SetPlayOverrideEndSection Parms{};

	Parms.Interaction = Interaction;
	Parms.bOverride = bOverride;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionMontagePlay.StartCheckForExecuteConditionsMet
// (Final, Native, Protected)

void ACoopInteractionMontagePlay::StartCheckForExecuteConditionsMet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "StartCheckForExecuteConditionsMet");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CoopInteractionMontagePlay.GetCurrentInteractorsCount
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ACoopInteractionMontagePlay::GetCurrentInteractorsCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "GetCurrentInteractorsCount");

	Params::CoopInteractionMontagePlay_GetCurrentInteractorsCount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoopInteractionMontagePlay.IsExecuteConditionMet
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ACoopInteractionMontagePlay::IsExecuteConditionMet() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "IsExecuteConditionMet");

	Params::CoopInteractionMontagePlay_IsExecuteConditionMet Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoopInteractionMontagePlay.RequestCompanionInteractEnd
// (Event, Protected, BlueprintEvent, Const)

void ACoopInteractionMontagePlay::RequestCompanionInteractEnd() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CoopInteractionMontagePlay", "RequestCompanionInteractEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.DemoEndScreenWidget.ClearAllSaveDataForDemo
// (Final, Native, Public, BlueprintCallable)

void UDemoEndScreenWidget::ClearAllSaveDataForDemo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DemoEndScreenWidget", "ClearAllSaveDataForDemo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.OverlappingLightComponent.SetLightEnabled
// (Native, Public, BlueprintCallable)
// Parameters:
// const bool                              IsEnabled                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOverlappingLightComponent::SetLightEnabled(const bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OverlappingLightComponent", "SetLightEnabled");

	Params::OverlappingLightComponent_SetLightEnabled Parms{};

	Parms.IsEnabled = IsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.OverlappingLightComponent.GetLightLocation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector UOverlappingLightComponent::GetLightLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OverlappingLightComponent", "GetLightLocation");

	Params::OverlappingLightComponent_GetLightLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.OverlappingLightComponent.IsOverlappingLight
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UOverlappingLightComponent::IsOverlappingLight(const class AActor* Actor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OverlappingLightComponent", "IsOverlappingLight");

	Params::OverlappingLightComponent_IsOverlappingLight Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AnimNotifyState_Pickup.GetNotifyNames
// (Final, Native, Static, Public, Const)
// Parameters:
// const TArray<class FName>               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class FName> UAnimNotifyState_Pickup::GetNotifyNames()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimNotifyState_Pickup", "GetNotifyNames");

	Params::AnimNotifyState_Pickup_GetNotifyNames Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSaveSlotMetadataLibrary.GetChapter
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FSaveSlotMetadata&         MetaData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FChapterSelectRow                ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FChapterSelectRow UEverholmSaveSlotMetadataLibrary::GetChapter(const struct FSaveSlotMetadata& MetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmSaveSlotMetadataLibrary", "GetChapter");

	Params::EverholmSaveSlotMetadataLibrary_GetChapter Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.ActOnPlayerIntent
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<struct FDraggableIntentPacket>&intentPackets                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const bool                              bAreAtLeastTwoPlayersDragging                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             DeltaTime                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::ActOnPlayerIntent(const TArray<struct FDraggableIntentPacket>& intentPackets, const bool bAreAtLeastTwoPlayersDragging, const float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "ActOnPlayerIntent");

	Params::DraggableComponent_ActOnPlayerIntent Parms{};

	Parms.intentPackets = std::move(intentPackets);
	Parms.bAreAtLeastTwoPlayersDragging = bAreAtLeastTwoPlayersDragging;
	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.DestroyDraggable
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UDraggableComponent::DestroyDraggable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "DestroyDraggable");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.GetIsComingToRest
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggableComponent::GetIsComingToRest()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetIsComingToRest");

	Params::DraggableComponent_GetIsComingToRest Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetIsMoving
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggableComponent::GetIsMoving()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetIsMoving");

	Params::DraggableComponent_GetIsMoving Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetIsStill
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggableComponent::GetIsStill()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetIsStill");

	Params::DraggableComponent_GetIsStill Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.HandleImpactEvent
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   velocityBeforeImpact                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::HandleImpactEvent(const struct FVector& velocityBeforeImpact)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "HandleImpactEvent");

	Params::DraggableComponent_HandleImpactEvent Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.MoveUsingResultingIntent
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   resultingTranslation_0                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  resultingRotation_0                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const float                             DeltaTime                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::MoveUsingResultingIntent(const struct FVector& resultingTranslation_0, const struct FRotator& resultingRotation_0, const float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "MoveUsingResultingIntent");

	Params::DraggableComponent_MoveUsingResultingIntent Parms{};

	Parms.resultingTranslation_0 = std::move(resultingTranslation_0);
	Parms.resultingRotation_0 = std::move(resultingRotation_0);
	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.NetMulticast_ReleaseDragger
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const class APawn*                      dragger                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::NetMulticast_ReleaseDragger(const class APawn* dragger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "NetMulticast_ReleaseDragger");

	Params::DraggableComponent_NetMulticast_ReleaseDragger Parms{};

	Parms.dragger = dragger;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.NetMulticast_ServerFrame
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FSmoothDraggableReplicatedState&State                                                  (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UDraggableComponent::NetMulticast_ServerFrame(const struct FSmoothDraggableReplicatedState& State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "NetMulticast_ServerFrame");

	Params::DraggableComponent_NetMulticast_ServerFrame Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.ReleaseDragger
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class APawn*                      dragger                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::ReleaseDragger(const class APawn* dragger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "ReleaseDragger");

	Params::DraggableComponent_ReleaseDragger Parms{};

	Parms.dragger = dragger;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.ReleaseDraggers
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UDraggableComponent::ReleaseDraggers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "ReleaseDraggers");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.ResetVelocities
// (Final, Native, Protected, BlueprintCallable)

void UDraggableComponent::ResetVelocities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "ResetVelocities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.SanitizeIntent
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<struct FDraggableIntentPacket>&intentPackets                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const bool                              bAreAtLeastTwoPlayersDragging                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             DeltaTime                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::SanitizeIntent(const TArray<struct FDraggableIntentPacket>& intentPackets, const bool bAreAtLeastTwoPlayersDragging, const float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "SanitizeIntent");

	Params::DraggableComponent_SanitizeIntent Parms{};

	Parms.intentPackets = std::move(intentPackets);
	Parms.bAreAtLeastTwoPlayersDragging = bAreAtLeastTwoPlayersDragging;
	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.SetDraggableEnabled
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::SetDraggableEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "SetDraggableEnabled");

	Params::DraggableComponent_SetDraggableEnabled Parms{};

	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.SetIntentDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class AActor*                     draggingActor                                          (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   intentDirection                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableComponent::SetIntentDirection(const class AActor* draggingActor, const struct FVector& intentDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "SetIntentDirection");

	Params::DraggableComponent_SetIntentDirection Parms{};

	Parms.draggingActor = draggingActor;
	Parms.intentDirection = std::move(intentDirection);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.ShouldTick
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggableComponent::ShouldTick()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "ShouldTick");

	Params::DraggableComponent_ShouldTick Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.ShouldUpdateIntent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggableComponent::ShouldUpdateIntent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "ShouldUpdateIntent");

	Params::DraggableComponent_ShouldUpdateIntent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.UpdateAIGoalLocation
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FAILocationUnion&          newAILocationUnion                                     (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UDraggableComponent::UpdateAIGoalLocation(const struct FAILocationUnion& newAILocationUnion)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "UpdateAIGoalLocation");

	Params::DraggableComponent_UpdateAIGoalLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableComponent.CalculateStaticFrictionMultiplier
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             CurrentSpeed                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDraggableStaticFrictionSettings&frictionSettings                                       (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UDraggableComponent::CalculateStaticFrictionMultiplier(const float CurrentSpeed, const struct FDraggableStaticFrictionSettings& frictionSettings) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "CalculateStaticFrictionMultiplier");

	Params::DraggableComponent_CalculateStaticFrictionMultiplier Parms{};

	Parms.CurrentSpeed = CurrentSpeed;
	Parms.frictionSettings = std::move(frictionSettings);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetAIGoalLocation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FAILocationUnion                 ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FAILocationUnion UDraggableComponent::GetAIGoalLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetAIGoalLocation");

	Params::DraggableComponent_GetAIGoalLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetAIGoalLocationVector
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UDraggableComponent::GetAIGoalLocationVector() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetAIGoalLocationVector");

	Params::DraggableComponent_GetAIGoalLocationVector Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetCurrentDragVelocity
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector UDraggableComponent::GetCurrentDragVelocity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetCurrentDragVelocity");

	Params::DraggableComponent_GetCurrentDragVelocity Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetDraggers
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class APawn*>                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class APawn*> UDraggableComponent::GetDraggers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetDraggers");

	Params::DraggableComponent_GetDraggers Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetGrabHelpers
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UGrabHelperComponent*>     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UGrabHelperComponent*> UDraggableComponent::GetGrabHelpers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetGrabHelpers");

	Params::DraggableComponent_GetGrabHelpers Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetIntentDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     draggingActor                                          (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector UDraggableComponent::GetIntentDirection(const class AActor* draggingActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetIntentDirection");

	Params::DraggableComponent_GetIntentDirection Parms{};

	Parms.draggingActor = draggingActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.GetLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UDraggableComponent::GetLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "GetLocation");

	Params::DraggableComponent_GetLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UDraggableComponent::HasZeroIntentCurrently() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "HasZeroIntentCurrently");

	Params::DraggableComponent_HasZeroIntentCurrently Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableComponent.IsDraggableInteractionEnabled
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggableComponent::IsDraggableInteractionEnabled(class APawn* Initiator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableComponent", "IsDraggableInteractionEnabled");

	Params::DraggableComponent_IsDraggableInteractionEnabled Parms{};

	Parms.Initiator = Initiator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggableFreeFormComponent.GetRadialVector
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     dragger                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UDraggableFreeFormComponent::GetRadialVector(const class AActor* dragger) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableFreeFormComponent", "GetRadialVector");

	Params::DraggableFreeFormComponent_GetRadialVector Parms{};

	Parms.dragger = dragger;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VisualHandholdingComponent.OnAASBegunPlay
// (Native, Public)

void UVisualHandholdingComponent::OnAASBegunPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VisualHandholdingComponent", "OnAASBegunPlay");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VisualHandholdingComponent.StartHandholding
// (Native, Public)
// Parameters:
// class AEverholmCharacter*               partner                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVisualHandholdingComponent::StartHandholding(class AEverholmCharacter* partner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VisualHandholdingComponent", "StartHandholding");

	Params::VisualHandholdingComponent_StartHandholding Parms{};

	Parms.partner = partner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VisualHandholdingComponent.StopHandholding
// (Native, Public)
// Parameters:
// class AEverholmCharacter*               partner                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVisualHandholdingComponent::StopHandholding(class AEverholmCharacter* partner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VisualHandholdingComponent", "StopHandholding");

	Params::VisualHandholdingComponent_StopHandholding Parms{};

	Parms.partner = partner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VisualHandholdingComponent.GetListOfBones
// (Final, Native, Public, Const)
// Parameters:
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UVisualHandholdingComponent::GetListOfBones() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VisualHandholdingComponent", "GetListOfBones");

	Params::VisualHandholdingComponent_GetListOfBones Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AsyncTaskGameplayTagAddedRemoved.ListenForGameplayTagAddedOrRemoved
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAbilitySystemComponent*          AbilitySystemComponent                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InTags                                                 (Parm, NativeAccessSpecifierPublic)
// class UAsyncTaskGameplayTagAddedRemoved*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAsyncTaskGameplayTagAddedRemoved* UAsyncTaskGameplayTagAddedRemoved::ListenForGameplayTagAddedOrRemoved(class UAbilitySystemComponent* AbilitySystemComponent, const struct FGameplayTagContainer& InTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AsyncTaskGameplayTagAddedRemoved", "ListenForGameplayTagAddedOrRemoved");

	Params::AsyncTaskGameplayTagAddedRemoved_ListenForGameplayTagAddedOrRemoved Parms{};

	Parms.AbilitySystemComponent = AbilitySystemComponent;
	Parms.InTags = std::move(InTags);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AsyncTaskGameplayTagAddedRemoved.EndTask
// (Final, Native, Public, BlueprintCallable)

void UAsyncTaskGameplayTagAddedRemoved::EndTask()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AsyncTaskGameplayTagAddedRemoved", "EndTask");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PinDownAttackComponent.AbortPindown
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bSkipPostPindownAnimationsOnVictim                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPinDownAttackComponent::AbortPindown(const bool bSkipPostPindownAnimationsOnVictim)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PinDownAttackComponent", "AbortPindown");

	Params::PinDownAttackComponent_AbortPindown Parms{};

	Parms.bSkipPostPindownAnimationsOnVictim = bSkipPostPindownAnimationsOnVictim;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PinDownAttackComponent.OnFakeAttackDone
// (Final, Native, Protected)

void UPinDownAttackComponent::OnFakeAttackDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PinDownAttackComponent", "OnFakeAttackDone");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineVehicle.DraisineInputInvalid
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UEverholmPumpInteraction*         Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineVehicle::DraisineInputInvalid(class UEverholmPumpInteraction* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "DraisineInputInvalid");

	Params::DraisineVehicle_DraisineInputInvalid Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineVehicle.DraisineInputValid
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UEverholmPumpInteraction*         Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineVehicle::DraisineInputValid(class UEverholmPumpInteraction* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "DraisineInputValid");

	Params::DraisineVehicle_DraisineInputValid Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineVehicle.InputProcessed
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineVehicle::InputProcessed(class UEverholmInteractionComponent* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "InputProcessed");

	Params::DraisineVehicle_InputProcessed Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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


// Function Everholm.DraisineVehicle.InputProcessedFail
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineVehicle::InputProcessedFail(class UEverholmInteractionComponent* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "InputProcessedFail");

	Params::DraisineVehicle_InputProcessedFail Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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


// Function Everholm.DraisineVehicle.OnRep_ProcessInput
// (Final, Native, Protected)

void ADraisineVehicle::OnRep_ProcessInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "OnRep_ProcessInput");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineVehicle.SetHandleInPlace
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bHandleInPlace                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineVehicle::SetHandleInPlace(bool bHandleInPlace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "SetHandleInPlace");

	Params::DraisineVehicle_SetHandleInPlace Parms{};

	Parms.bHandleInPlace = bHandleInPlace;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineVehicle.SetProcessInput
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bProcess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineVehicle::SetProcessInput(bool bProcess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "SetProcessInput");

	Params::DraisineVehicle_SetProcessInput Parms{};

	Parms.bProcess = bProcess;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineVehicle.CanDriveDraisine
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ADraisineVehicle::CanDriveDraisine() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "CanDriveDraisine");

	Params::DraisineVehicle_CanDriveDraisine Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraisineVehicle.GetDraisineInputDataForCharacter
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPumpInputData                   ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPumpInputData ADraisineVehicle::GetDraisineInputDataForCharacter(class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "GetDraisineInputDataForCharacter");

	Params::DraisineVehicle_GetDraisineInputDataForCharacter Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraisineVehicle.GetDraisineInputDataForInteraction
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPumpInputData                   ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPumpInputData ADraisineVehicle::GetDraisineInputDataForInteraction(class UEverholmInteractionComponent* Interaction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineVehicle", "GetDraisineInputDataForInteraction");

	Params::DraisineVehicle_GetDraisineInputDataForInteraction Parms{};

	Parms.Interaction = Interaction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAtmoLanternParamsEvaluator.RegisterLanternLight
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULightComponent*                  Light                                                  (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ELanternAtmoLightType                   Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ELanternAtmoContext                     Context                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAtmoLanternParamsEvaluator::RegisterLanternLight(class UObject* World, class ULightComponent* Light, ELanternAtmoLightType Type, ELanternAtmoContext Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAtmoLanternParamsEvaluator", "RegisterLanternLight");

	Params::EverholmAtmoLanternParamsEvaluator_RegisterLanternLight Parms{};

	Parms.World = World;
	Parms.Light = Light;
	Parms.Type = Type;
	Parms.Context = Context;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAtmoLanternParamsEvaluator.RegisterLanternLightWithEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULightComponent*                  Light                                                  (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TDelegate<void(const struct FEverholmAtmoLanternSettings& Settings)>updateEvent                                            (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FEverholmAtmoLanternDefaults&lanternDefaults                                        (Parm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// ELanternAtmoLightType                   Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ELanternAtmoContext                     Context                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAtmoLanternParamsEvaluator::RegisterLanternLightWithEvent(class UObject* World, class ULightComponent* Light, TDelegate<void(const struct FEverholmAtmoLanternSettings& Settings)> updateEvent, const struct FEverholmAtmoLanternDefaults& lanternDefaults, ELanternAtmoLightType Type, ELanternAtmoContext Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAtmoLanternParamsEvaluator", "RegisterLanternLightWithEvent");

	Params::EverholmAtmoLanternParamsEvaluator_RegisterLanternLightWithEvent Parms{};

	Parms.World = World;
	Parms.Light = Light;
	Parms.updateEvent = updateEvent;
	Parms.lanternDefaults = std::move(lanternDefaults);
	Parms.Type = Type;
	Parms.Context = Context;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAtmoLanternParamsEvaluator.UnregisterLanternLight
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULightComponent*                  Light                                                  (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAtmoLanternParamsEvaluator::UnregisterLanternLight(class UObject* World, class ULightComponent* Light)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAtmoLanternParamsEvaluator", "UnregisterLanternLight");

	Params::EverholmAtmoLanternParamsEvaluator_UnregisterLanternLight Parms{};

	Parms.World = World;
	Parms.Light = Light;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableVehicleBaseComponent.ExitVehicleAtTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                exitTransform                                          (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableVehicleBaseComponent::ExitVehicleAtTransform(const struct FTransform& exitTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableVehicleBaseComponent", "ExitVehicleAtTransform");

	Params::DraggableVehicleBaseComponent_ExitVehicleAtTransform Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableVehicleBaseComponent.OverrideVehicleTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                overrideTransform                                      (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableVehicleBaseComponent::OverrideVehicleTransform(const struct FTransform& overrideTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableVehicleBaseComponent", "OverrideVehicleTransform");

	Params::DraggableVehicleBaseComponent_OverrideVehicleTransform Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggableVehicleBaseComponent.SetControlledByPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bPlayerControlled                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggableVehicleBaseComponent::SetControlledByPlayer(bool bPlayerControlled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggableVehicleBaseComponent", "SetControlledByPlayer");

	Params::DraggableVehicleBaseComponent_SetControlledByPlayer Parms{};

	Parms.bPlayerControlled = bPlayerControlled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.ApplySpeedModifierOverride
// (Native, Public, BlueprintCallable)
// Parameters:
// EVehicleSpeedMofidierPreset             preset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceInstantApplication                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::ApplySpeedModifierOverride(EVehicleSpeedMofidierPreset preset, bool bForceInstantApplication)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "ApplySpeedModifierOverride");

	Params::VehicleMovementComponent_ApplySpeedModifierOverride Parms{};

	Parms.preset = preset;
	Parms.bForceInstantApplication = bForceInstantApplication;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.CalculateForwardSpeed
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UVehicleMovementComponent::CalculateForwardSpeed(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "CalculateForwardSpeed");

	Params::VehicleMovementComponent_CalculateForwardSpeed Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.CalculateRotationSpeed
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UVehicleMovementComponent::CalculateRotationSpeed(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "CalculateRotationSpeed");

	Params::VehicleMovementComponent_CalculateRotationSpeed Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.CalculateTargetLocation
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UVehicleMovementComponent::CalculateTargetLocation(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "CalculateTargetLocation");

	Params::VehicleMovementComponent_CalculateTargetLocation Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.CalculateTargetRotation
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UVehicleMovementComponent::CalculateTargetRotation(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "CalculateTargetRotation");

	Params::VehicleMovementComponent_CalculateTargetRotation Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.FindGroundZ
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  overrideGroundTraceComponent                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UVehicleMovementComponent::FindGroundZ(float DeltaTime, class USceneComponent* overrideGroundTraceComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "FindGroundZ");

	Params::VehicleMovementComponent_FindGroundZ Parms{};

	Parms.DeltaTime = DeltaTime;
	Parms.overrideGroundTraceComponent = overrideGroundTraceComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.GetMovementParams
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVehicleMovementParams           ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FVehicleMovementParams UVehicleMovementComponent::GetMovementParams()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "GetMovementParams");

	Params::VehicleMovementComponent_GetMovementParams Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.GetVisualParentComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* UVehicleMovementComponent::GetVisualParentComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "GetVisualParentComponent");

	Params::VehicleMovementComponent_GetVisualParentComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.MoveVehicle
// (Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     NewRotation                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSweep                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// ETeleportType                           Teleport                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::MoveVehicle(const struct FVector& Delta, const struct FQuat& NewRotation, bool bSweep, struct FHitResult* OutHit, ETeleportType Teleport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "MoveVehicle");

	Params::VehicleMovementComponent_MoveVehicle Parms{};

	Parms.Delta = std::move(Delta);
	Parms.NewRotation = std::move(NewRotation);
	Parms.bSweep = bSweep;
	Parms.Teleport = Teleport;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Everholm.VehicleMovementComponent.OverrideTargetLocationAndRotation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   overrideTargetLocation                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  overrideTargetRotation                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::OverrideTargetLocationAndRotation(const struct FVector& overrideTargetLocation, const struct FRotator& overrideTargetRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "OverrideTargetLocationAndRotation");

	Params::VehicleMovementComponent_OverrideTargetLocationAndRotation Parms{};

	Parms.overrideTargetLocation = std::move(overrideTargetLocation);
	Parms.overrideTargetRotation = std::move(overrideTargetRotation);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.PostSlideAlongSurface
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// struct FHitResult*                      HitResult                                              (Parm, OutParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   ActualMovement                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::PostSlideAlongSurface(struct FHitResult* HitResult, float ActualMovement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "PostSlideAlongSurface");

	Params::VehicleMovementComponent_PostSlideAlongSurface Parms{};

	Parms.ActualMovement = ActualMovement;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Everholm.VehicleMovementComponent.ResetOverrideForwardSpeed
// (Final, Native, Public, BlueprintCallable)

void UVehicleMovementComponent::ResetOverrideForwardSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "ResetOverrideForwardSpeed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.ResetOverrideMovementParams
// (Final, Native, Public, BlueprintCallable)

void UVehicleMovementComponent::ResetOverrideMovementParams()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "ResetOverrideMovementParams");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.ResetOverrideRotationSpeed
// (Final, Native, Public, BlueprintCallable)

void UVehicleMovementComponent::ResetOverrideRotationSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "ResetOverrideRotationSpeed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetControlledByPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    controlledByPlayer                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetControlledByPlayer(bool controlledByPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetControlledByPlayer");

	Params::VehicleMovementComponent_SetControlledByPlayer Parms{};

	Parms.controlledByPlayer = controlledByPlayer;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetControlledByPlayerEvent
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    IsControlledByPlayer                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetControlledByPlayerEvent(bool IsControlledByPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetControlledByPlayerEvent");

	Params::VehicleMovementComponent_SetControlledByPlayerEvent Parms{};

	Parms.IsControlledByPlayer = IsControlledByPlayer;

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


// Function Everholm.VehicleMovementComponent.SetOverrideForwardSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetOverrideForwardSpeed(float Speed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetOverrideForwardSpeed");

	Params::VehicleMovementComponent_SetOverrideForwardSpeed Parms{};

	Parms.Speed = Speed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetOverrideRotationSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetOverrideRotationSpeed(float Speed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetOverrideRotationSpeed");

	Params::VehicleMovementComponent_SetOverrideRotationSpeed Parms{};

	Parms.Speed = Speed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetVehicleBoostSpeedOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   newBoostSpeed                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetVehicleBoostSpeedOverride(float newBoostSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetVehicleBoostSpeedOverride");

	Params::VehicleMovementComponent_SetVehicleBoostSpeedOverride Parms{};

	Parms.newBoostSpeed = newBoostSpeed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetVehicleForwardSpeedOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   newForwardSpeed                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetVehicleForwardSpeedOverride(float newForwardSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetVehicleForwardSpeedOverride");

	Params::VehicleMovementComponent_SetVehicleForwardSpeedOverride Parms{};

	Parms.newForwardSpeed = newForwardSpeed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetVehicleReverseSpeedOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   newReverseSpeed                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetVehicleReverseSpeedOverride(float newReverseSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetVehicleReverseSpeedOverride");

	Params::VehicleMovementComponent_SetVehicleReverseSpeedOverride Parms{};

	Parms.newReverseSpeed = newReverseSpeed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetVehicleRotationSpeedOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   newRotationSpeed                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetVehicleRotationSpeedOverride(float newRotationSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetVehicleRotationSpeedOverride");

	Params::VehicleMovementComponent_SetVehicleRotationSpeedOverride Parms{};

	Parms.newRotationSpeed = newRotationSpeed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.SetVisualParent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  visualParentComponent                                  (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::SetVisualParent(class USceneComponent* visualParentComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "SetVisualParent");

	Params::VehicleMovementComponent_SetVisualParent Parms{};

	Parms.visualParentComponent = visualParentComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.TrySlideAlongSurfaceIfHit
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FHitResult&                      HitResult                                              (Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FVector&                         deltaMove                                              (Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::TrySlideAlongSurfaceIfHit(struct FHitResult& HitResult, struct FVector& deltaMove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "TrySlideAlongSurfaceIfHit");

	Params::VehicleMovementComponent_TrySlideAlongSurfaceIfHit Parms{};

	Parms.HitResult = std::move(HitResult);
	Parms.deltaMove = std::move(deltaMove);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	HitResult = std::move(Parms.HitResult);
	deltaMove = std::move(Parms.deltaMove);
}


// Function Everholm.VehicleMovementComponent.UpdateCalculatedRotationBasedOnSurface
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  overrideGroundTraceComponent                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::UpdateCalculatedRotationBasedOnSurface(float DeltaTime, class USceneComponent* overrideGroundTraceComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "UpdateCalculatedRotationBasedOnSurface");

	Params::VehicleMovementComponent_UpdateCalculatedRotationBasedOnSurface Parms{};

	Parms.DeltaTime = DeltaTime;
	Parms.overrideGroundTraceComponent = overrideGroundTraceComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.UpdateMoveOnClient
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   clientTargetLocation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  clientTargetRotation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::UpdateMoveOnClient(float DeltaTime, const struct FVector& clientTargetLocation, const struct FRotator& clientTargetRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "UpdateMoveOnClient");

	Params::VehicleMovementComponent_UpdateMoveOnClient Parms{};

	Parms.DeltaTime = DeltaTime;
	Parms.clientTargetLocation = std::move(clientTargetLocation);
	Parms.clientTargetRotation = std::move(clientTargetRotation);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.UpdateMoveOnServer
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::UpdateMoveOnServer(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "UpdateMoveOnServer");

	Params::VehicleMovementComponent_UpdateMoveOnServer Parms{};

	Parms.DeltaTime = DeltaTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.VehicleMoveDone
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   deltaMove                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMovementComponent::VehicleMoveDone(const struct FVector& deltaMove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "VehicleMoveDone");

	Params::VehicleMovementComponent_VehicleMoveDone Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMovementComponent.GetActiveSpeedModifierPreset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EVehicleSpeedMofidierPreset             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EVehicleSpeedMofidierPreset UVehicleMovementComponent::GetActiveSpeedModifierPreset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "GetActiveSpeedModifierPreset");

	Params::VehicleMovementComponent_GetActiveSpeedModifierPreset Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.GetDefaultMovementParams
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVehicleMovementParams           ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FVehicleMovementParams UVehicleMovementComponent::GetDefaultMovementParams() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "GetDefaultMovementParams");

	Params::VehicleMovementComponent_GetDefaultMovementParams Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMovementComponent.GetLimitedSpeed
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UVehicleMovementComponent::GetLimitedSpeed(float Speed) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "GetLimitedSpeed");

	Params::VehicleMovementComponent_GetLimitedSpeed Parms{};

	Parms.Speed = Speed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UVehicleMovementComponent::IsBoostDisabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "IsBoostDisabled");

	Params::VehicleMovementComponent_IsBoostDisabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UVehicleMovementComponent::IsControlledByPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMovementComponent", "IsControlledByPlayer");

	Params::VehicleMovementComponent_IsControlledByPlayer Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMoveOnSplineComponent.MoveTillSplineIndexAtSpeed
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const struct FVehicleSplineFollowData&  SplineFollowData                                       (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleMoveOnSplineComponent::MoveTillSplineIndexAtSpeed(const struct FVehicleSplineFollowData& SplineFollowData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveOnSplineComponent", "MoveTillSplineIndexAtSpeed");

	Params::VehicleMoveOnSplineComponent_MoveTillSplineIndexAtSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveOnSplineComponent.SnapVehicleToSplineDistance
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMoveOnSplineComponent::SnapVehicleToSplineDistance(float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveOnSplineComponent", "SnapVehicleToSplineDistance");

	Params::VehicleMoveOnSplineComponent_SnapVehicleToSplineDistance Parms{};

	Parms.Distance = Distance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveOnSplineComponent.StartMovingOnSpline
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class USplineComponent*                 SplineComponent                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMoveOnSplineComponent::StartMovingOnSpline(class USplineComponent* SplineComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveOnSplineComponent", "StartMovingOnSpline");

	Params::VehicleMoveOnSplineComponent_StartMovingOnSpline Parms{};

	Parms.SplineComponent = SplineComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


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

float UVehicleMoveOnSplineComponent::GetCurrentDistanceAlongSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveOnSplineComponent", "GetCurrentDistanceAlongSpline");

	Params::VehicleMoveOnSplineComponent_GetCurrentDistanceAlongSpline Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UVehicleMoveOnSplineComponent::HasSplineToMoveOn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveOnSplineComponent", "HasSplineToMoveOn");

	Params::VehicleMoveOnSplineComponent_HasSplineToMoveOn Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PigVehicleMovementComponent.OnRep_MoveInDirection
// (Final, Native, Protected)

void UPigVehicleMovementComponent::OnRep_MoveInDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigVehicleMovementComponent", "OnRep_MoveInDirection");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PigVehicleMovementComponent.SetMovementAlpha
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPigVehicleMovementComponent::SetMovementAlpha(float Alpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigVehicleMovementComponent", "SetMovementAlpha");

	Params::PigVehicleMovementComponent_SetMovementAlpha Parms{};

	Parms.Alpha = Alpha;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PigVehicleMovementComponent.SetMovementDirection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPigMoveInDirection                     MoveDirection                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPigVehicleMovementComponent::SetMovementDirection(EPigMoveInDirection MoveDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigVehicleMovementComponent", "SetMovementDirection");

	Params::PigVehicleMovementComponent_SetMovementDirection Parms{};

	Parms.MoveDirection = MoveDirection;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttachmentAnchorComponent.FindAnchor
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName&                      SocketName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAttachmentAnchor*               outAnchor                                              (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAttachmentAnchorComponent::FindAnchor(const class FName& SocketName, struct FAttachmentAnchor* outAnchor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttachmentAnchorComponent", "FindAnchor");

	Params::AttachmentAnchorComponent_FindAnchor Parms{};

	Parms.SocketName = SocketName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Everholm.AttackProjectile.Multicast_LaunchProjectile
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   launchTargetLocation                                   (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAttackProjectile::Multicast_LaunchProjectile(const struct FVector& launchTargetLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackProjectile", "Multicast_LaunchProjectile");

	Params::AttackProjectile_Multicast_LaunchProjectile Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackProjectile.OnProjectileHit
// (Native, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AAttackProjectile::OnProjectileHit(const struct FHitResult& ImpactResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackProjectile", "OnProjectileHit");

	Params::AttackProjectile_OnProjectileHit Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackProjectile.SetAttackTargetLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAttackProjectile::SetAttackTargetLocation(const struct FVector& targetLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackProjectile", "SetAttackTargetLocation");

	Params::AttackProjectile_SetAttackTargetLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackProjectile.SetProjectileDeathHandler
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class ADeathHandlerSkeletal>DeathHandlerClass                                      (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAttackProjectile::SetProjectileDeathHandler(TSubclassOf<class ADeathHandlerSkeletal> DeathHandlerClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackProjectile", "SetProjectileDeathHandler");

	Params::AttackProjectile_SetProjectileDeathHandler Parms{};

	Parms.DeathHandlerClass = DeathHandlerClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackProjectile.SetProjectileDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   launchDirection                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAttackProjectile::SetProjectileDirection(const struct FVector& launchDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackProjectile", "SetProjectileDirection");

	Params::AttackProjectile_SetProjectileDirection Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackProjectile.GetAttackTargetLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AAttackProjectile::GetAttackTargetLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackProjectile", "GetAttackTargetLocation");

	Params::AttackProjectile_GetAttackTargetLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EncircleTargetAction.SetFinalTargetDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEncircleTargetAction::SetFinalTargetDirection(const struct FVector& Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EncircleTargetAction", "SetFinalTargetDirection");

	Params::EncircleTargetAction_SetFinalTargetDirection Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EncircleTargetAction.UpdateTargetActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           newTargetActor                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEncircleTargetAction::UpdateTargetActor(class AActor* newTargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EncircleTargetAction", "UpdateTargetActor");

	Params::EncircleTargetAction_UpdateTargetActor Parms{};

	Parms.newTargetActor = newTargetActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EncircleTargetAction.GetEncircleWorldLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector UEncircleTargetAction::GetEncircleWorldLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EncircleTargetAction", "GetEncircleWorldLocation");

	Params::EncircleTargetAction_GetEncircleWorldLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AttackTargetAction.OnActionPointEvent
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UActionPoint*                     Point                                                  (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            usingActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EActionPointEventType                   EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   actionIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackTargetAction::OnActionPointEvent(class UActionPoint* Point, class APawn* usingActor, EActionPointEventType EventType, const class FName& NotifyName, int32 actionIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackTargetAction", "OnActionPointEvent");

	Params::AttackTargetAction_OnActionPointEvent Parms{};

	Parms.Point = Point;
	Parms.usingActor = usingActor;
	Parms.EventType = EventType;
	Parms.NotifyName = NotifyName;
	Parms.actionIndex = actionIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackTargetAction.OnAttackMontageEnded
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     attackMontage                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackTargetAction::OnAttackMontageEnded(class UAnimMontage* attackMontage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackTargetAction", "OnAttackMontageEnded");

	Params::AttackTargetAction_OnAttackMontageEnded Parms{};

	Parms.attackMontage = attackMontage;
	Parms.bInterrupted = bInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackTargetAction.OnAttackResolvedEvent
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FAttackData&               AttackData                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UAttackTargetAction::OnAttackResolvedEvent(const struct FAttackData& AttackData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackTargetAction", "OnAttackResolvedEvent");

	Params::AttackTargetAction_OnAttackResolvedEvent Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackTargetAction.OnAttackSuccessEvent
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FAttackData&               AttackData                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UAttackTargetAction::OnAttackSuccessEvent(const struct FAttackData& AttackData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackTargetAction", "OnAttackSuccessEvent");

	Params::AttackTargetAction_OnAttackSuccessEvent Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AttackTargetAction.OnTriggeredContextualKill
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AActionPointActor*                contextualKillActionPoint                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Target                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     targetAttachedAnimMontage                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAttackTargetAction::OnTriggeredContextualKill(class AActionPointActor* contextualKillActionPoint, class AActor* Target, class UAnimMontage* targetAttachedAnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AttackTargetAction", "OnTriggeredContextualKill");

	Params::AttackTargetAction_OnTriggeredContextualKill Parms{};

	Parms.contextualKillActionPoint = contextualKillActionPoint;
	Parms.Target = Target;
	Parms.targetAttachedAnimMontage = targetAttachedAnimMontage;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.JumpCondition.Evaluate
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCapsuleComponent*                From                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCapsuleComponent*                To                                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UJumpCondition::Evaluate(class AEverholmCharacter* Initiator, class UCapsuleComponent* From, class UCapsuleComponent* To) const
{
	static class UFunction* Func = nullptr;

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

	Params::JumpCondition_Evaluate Parms{};

	Parms.Initiator = Initiator;
	Parms.From = From;
	Parms.To = To;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraisineActor.AccelerationTimelineUpdate
// (Final, Native, Protected)
// Parameters:
// float                                   Alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::AccelerationTimelineUpdate(float Alpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "AccelerationTimelineUpdate");

	Params::DraisineActor_AccelerationTimelineUpdate Parms{};

	Parms.Alpha = Alpha;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.AccelerationUpdate
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   NewAcceleration                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::AccelerationUpdate(float NewAcceleration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "AccelerationUpdate");

	Params::DraisineActor_AccelerationUpdate Parms{};

	Parms.NewAcceleration = NewAcceleration;

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


// Function Everholm.DraisineActor.DecelerationTimelineUpdate
// (Final, Native, Protected)
// Parameters:
// float                                   Alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::DecelerationTimelineUpdate(float Alpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "DecelerationTimelineUpdate");

	Params::DraisineActor_DecelerationTimelineUpdate Parms{};

	Parms.Alpha = Alpha;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.DraisineInputInvalid
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UEverholmPumpInteraction*         Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::DraisineInputInvalid(class UEverholmPumpInteraction* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "DraisineInputInvalid");

	Params::DraisineActor_DraisineInputInvalid Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.DraisineInputValid
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UEverholmPumpInteraction*         Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::DraisineInputValid(class UEverholmPumpInteraction* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "DraisineInputValid");

	Params::DraisineActor_DraisineInputValid Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.InputProcessed
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::InputProcessed(class UEverholmInteractionComponent* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "InputProcessed");

	Params::DraisineActor_InputProcessed Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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


// Function Everholm.DraisineActor.InputProcessedFail
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Intent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::InputProcessedFail(class UEverholmInteractionComponent* Interaction, int32 Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "InputProcessedFail");

	Params::DraisineActor_InputProcessedFail Parms{};

	Parms.Interaction = Interaction;
	Parms.Intent = Intent;

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


// Function Everholm.DraisineActor.OnRep_ProcessInput
// (Final, Native, Protected)

void ADraisineActor::OnRep_ProcessInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "OnRep_ProcessInput");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.OnRep_ServerDistanceAlongSpline
// (Final, Native, Protected)

void ADraisineActor::OnRep_ServerDistanceAlongSpline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "OnRep_ServerDistanceAlongSpline");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.OtherPlayerInPlace
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::OtherPlayerInPlace(class UEverholmInteractionComponent* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "OtherPlayerInPlace");

	Params::DraisineActor_OtherPlayerInPlace Parms{};

	Parms.Interaction = Interaction;

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


// Function Everholm.DraisineActor.PlayerInitiatorInPlace
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::PlayerInitiatorInPlace(class UEverholmInteractionComponent* Interaction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "PlayerInitiatorInPlace");

	Params::DraisineActor_PlayerInitiatorInPlace Parms{};

	Parms.Interaction = Interaction;

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


// Function Everholm.DraisineActor.SetHandleInPlace
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bHandleInPlace                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::SetHandleInPlace(bool bHandleInPlace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "SetHandleInPlace");

	Params::DraisineActor_SetHandleInPlace Parms{};

	Parms.bHandleInPlace = bHandleInPlace;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.SetProcessInput
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bProcess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADraisineActor::SetProcessInput(bool bProcess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "SetProcessInput");

	Params::DraisineActor_SetProcessInput Parms{};

	Parms.bProcess = bProcess;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.WaitForInputTimerDone
// (Final, Native, Private)

void ADraisineActor::WaitForInputTimerDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "WaitForInputTimerDone");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraisineActor.CanDriveDraisine
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ADraisineActor::CanDriveDraisine() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "CanDriveDraisine");

	Params::DraisineActor_CanDriveDraisine Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraisineActor.GetDraisineInputDataForInteraction
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPumpInputData                   ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPumpInputData ADraisineActor::GetDraisineInputDataForInteraction(class UEverholmInteractionComponent* Interaction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineActor", "GetDraisineInputDataForInteraction");

	Params::DraisineActor_GetDraisineInputDataForInteraction Parms{};

	Parms.Interaction = Interaction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AutoJump.OnDestinationAreaBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AAutoJump::OnDestinationAreaBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoJump", "OnDestinationAreaBeginOverlap");

	Params::AutoJump_OnDestinationAreaBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AutoJump.OnDestinationAreaEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAutoJump::OnDestinationAreaEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoJump", "OnDestinationAreaEndOverlap");

	Params::AutoJump_OnDestinationAreaEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AutoJump.OnStartAreaBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AAutoJump::OnStartAreaBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoJump", "OnStartAreaBeginOverlap");

	Params::AutoJump_OnStartAreaBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AutoJump.OnStartAreaEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAutoJump::OnStartAreaEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoJump", "OnStartAreaEndOverlap");

	Params::AutoJump_OnStartAreaEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AutoJump.CalculateJumpDestination
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCapsuleComponent*                From                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCapsuleComponent*                To                                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FJumpDestinationData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FJumpDestinationData AAutoJump::CalculateJumpDestination(class AEverholmCharacter* Initiator, class UCapsuleComponent* From, class UCapsuleComponent* To) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoJump", "CalculateJumpDestination");

	Params::AutoJump_CalculateJumpDestination Parms{};

	Parms.Initiator = Initiator;
	Parms.From = From;
	Parms.To = To;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AutoJump.GetPreviewArcsToDraw
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// struct FJumpArcPreviewData              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FJumpArcPreviewData AAutoJump::GetPreviewArcsToDraw() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AutoJump", "GetPreviewArcsToDraw");

	Params::AutoJump_GetPreviewArcsToDraw Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.AutoJumpBlueprintFunctionLibrary.PackJumpParams
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FJumpParams&               paramsToPack                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform UAutoJumpBlueprintFunctionLibrary::PackJumpParams(const struct FJumpParams& paramsToPack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AutoJumpBlueprintFunctionLibrary", "PackJumpParams");

	Params::AutoJumpBlueprintFunctionLibrary_PackJumpParams Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AutoJumpBlueprintFunctionLibrary.UnpackJumpParams
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FTransform&                transformToUnpack                                      (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FJumpParams                      ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FJumpParams UAutoJumpBlueprintFunctionLibrary::UnpackJumpParams(const struct FTransform& transformToUnpack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AutoJumpBlueprintFunctionLibrary", "UnpackJumpParams");

	Params::AutoJumpBlueprintFunctionLibrary_UnpackJumpParams Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AvoidLightComponent.AddOverlappingLight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UOverlappingLightComponent*       overlappingLight                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAvoidLightComponent::AddOverlappingLight(class UOverlappingLightComponent* overlappingLight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AvoidLightComponent", "AddOverlappingLight");

	Params::AvoidLightComponent_AddOverlappingLight Parms{};

	Parms.overlappingLight = overlappingLight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AvoidLightComponent.RemoveOverlappingLight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UOverlappingLightComponent*       overlappingLight                                       (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAvoidLightComponent::RemoveOverlappingLight(class UOverlappingLightComponent* overlappingLight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AvoidLightComponent", "RemoveOverlappingLight");

	Params::AvoidLightComponent_RemoveOverlappingLight Parms{};

	Parms.overlappingLight = overlappingLight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.AvoidLightComponent.GetAmountOfOverlappingLightsToConsider
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UAvoidLightComponent::GetAmountOfOverlappingLightsToConsider() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AvoidLightComponent", "GetAmountOfOverlappingLightsToConsider");

	Params::AvoidLightComponent_GetAmountOfOverlappingLightsToConsider Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AvoidLightComponent.GetAvoidanceDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UAvoidLightComponent::GetAvoidanceDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AvoidLightComponent", "GetAvoidanceDirection");

	Params::AvoidLightComponent_GetAvoidanceDirection Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AvoidLightComponent.GetCurrentlyOverlappingLights
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class UOverlappingLightComponent*>ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

const TArray<class UOverlappingLightComponent*> UAvoidLightComponent::GetCurrentlyOverlappingLights() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AvoidLightComponent", "GetCurrentlyOverlappingLights");

	Params::AvoidLightComponent_GetCurrentlyOverlappingLights Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AvoidLightComponent.GetCurrentlyOverlappingLightsExcludingPenumbra
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class UOverlappingLightComponent*>ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

const TArray<class UOverlappingLightComponent*> UAvoidLightComponent::GetCurrentlyOverlappingLightsExcludingPenumbra() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AvoidLightComponent", "GetCurrentlyOverlappingLightsExcludingPenumbra");

	Params::AvoidLightComponent_GetCurrentlyOverlappingLightsExcludingPenumbra Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.AvoidLightComponent.IsOverlappedByLight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              excludePenumbra                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAvoidLightComponent::IsOverlappedByLight(const bool excludePenumbra) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AvoidLightComponent", "IsOverlappedByLight");

	Params::AvoidLightComponent_IsOverlappedByLight Parms{};

	Parms.excludePenumbra = excludePenumbra;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BalanceBeamActor.GetBalanceLocationData
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class AEverholmCharacter*         balancingInstigator                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   worldSpaceInput                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBalanceLocationData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FBalanceLocationData ABalanceBeamActor::GetBalanceLocationData(const class AEverholmCharacter* balancingInstigator, const struct FVector& worldSpaceInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BalanceBeamActor", "GetBalanceLocationData");

	Params::BalanceBeamActor_GetBalanceLocationData Parms{};

	Parms.balancingInstigator = balancingInstigator;
	Parms.worldSpaceInput = std::move(worldSpaceInput);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BalanceBeamActor.GetBalanceLocationFromLocation
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   WorldLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bProjectToGround                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ABalanceBeamActor::GetBalanceLocationFromLocation(const struct FVector& WorldLocation, const bool bProjectToGround)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BalanceBeamActor", "GetBalanceLocationFromLocation");

	Params::BalanceBeamActor_GetBalanceLocationFromLocation Parms{};

	Parms.WorldLocation = std::move(WorldLocation);
	Parms.bProjectToGround = bProjectToGround;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterAnimInstance.GetMinAngleDifference180
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   A                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   B                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmCharacterAnimInstance::GetMinAngleDifference180(float A, float B)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmCharacterAnimInstance", "GetMinAngleDifference180");

	Params::EverholmCharacterAnimInstance_GetMinAngleDifference180 Parms{};

	Parms.A = A;
	Parms.B = B;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterAnimInstance.OnAnimInstanceEvent
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  FloatParam                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   IntParam                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    boolParam                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterAnimInstance::OnAnimInstanceEvent(class FName EventName, double FloatParam, int32 IntParam, bool boolParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAnimInstance", "OnAnimInstanceEvent");

	Params::EverholmCharacterAnimInstance_OnAnimInstanceEvent Parms{};

	Parms.EventName = EventName;
	Parms.FloatParam = FloatParam;
	Parms.IntParam = IntParam;
	Parms.boolParam = boolParam;

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


// Function Everholm.EverholmCharacterAnimInstance.OnIdleStrafeTurn
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    isTurningRight                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterAnimInstance::OnIdleStrafeTurn(bool isTurningRight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAnimInstance", "OnIdleStrafeTurn");

	Params::EverholmCharacterAnimInstance_OnIdleStrafeTurn Parms{};

	Parms.isTurningRight = isTurningRight;

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


// Function Everholm.EverholmCharacterAnimInstance.OnInputAbuseChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bIsInputAllowed                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterAnimInstance::OnInputAbuseChanged(bool bIsInputAllowed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAnimInstance", "OnInputAbuseChanged");

	Params::EverholmCharacterAnimInstance_OnInputAbuseChanged Parms{};

	Parms.bIsInputAllowed = bIsInputAllowed;

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


// Function Everholm.EverholmCharacterAnimInstance.CalculateWallPushBackPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double                                  pushBackDistance                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterAnimInstance::CalculateWallPushBackPoint(double pushBackDistance) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAnimInstance", "CalculateWallPushBackPoint");

	Params::EverholmCharacterAnimInstance_CalculateWallPushBackPoint Parms{};

	Parms.pushBackDistance = pushBackDistance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterAnimInstance.GetFavoredSmoothTurningAngle
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FTransform&                WorldTransform                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ForwardVector                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InputForward                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// ESmoothTurningFavoredDirection          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESmoothTurningFavoredDirection UEverholmCharacterAnimInstance::GetFavoredSmoothTurningAngle(const struct FTransform& WorldTransform, const struct FVector& ForwardVector, const struct FVector& InputForward, struct FRotator* Rotation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAnimInstance", "GetFavoredSmoothTurningAngle");

	Params::EverholmCharacterAnimInstance_GetFavoredSmoothTurningAngle Parms{};

	Parms.WorldTransform = std::move(WorldTransform);
	Parms.ForwardVector = std::move(ForwardVector);
	Parms.InputForward = std::move(InputForward);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


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

bool UEverholmCharacterAnimInstance::IsPlayingRootMotionMontage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAnimInstance", "IsPlayingRootMotionMontage");

	Params::EverholmCharacterAnimInstance_IsPlayingRootMotionMontage Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIAnimInstance.CalculatePredictedAttackLocation
// (Native, Public, BlueprintCallable)

void UEverholmAIAnimInstance::CalculatePredictedAttackLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimInstance", "CalculatePredictedAttackLocation");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIAnimInstance.GetAttackAnimation
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const EAILocomotionType                 locomotionType                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttackType                             attackType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Angle                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Distance                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UEverholmAIAnimInstance::GetAttackAnimation(const EAILocomotionType locomotionType, EAttackType attackType, float Angle, const float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimInstance", "GetAttackAnimation");

	Params::EverholmAIAnimInstance_GetAttackAnimation Parms{};

	Parms.locomotionType = locomotionType;
	Parms.attackType = attackType;
	Parms.Angle = Angle;
	Parms.Distance = Distance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIAnimInstance.GetMontageByTurnAngle
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const EAILocomotionType                 locomotionType                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIAnimMontageType                      animType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   animAngle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UEverholmAIAnimInstance::GetMontageByTurnAngle(const EAILocomotionType locomotionType, EAIAnimMontageType animType, float animAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimInstance", "GetMontageByTurnAngle");

	Params::EverholmAIAnimInstance_GetMontageByTurnAngle Parms{};

	Parms.locomotionType = locomotionType;
	Parms.animType = animType;
	Parms.animAngle = animAngle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIAnimInstance.GetOverrideAnimationSet
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const EAILocomotionType                 locomotionType                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimationSet*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimationSet* UEverholmAIAnimInstance::GetOverrideAnimationSet(const EAILocomotionType locomotionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimInstance", "GetOverrideAnimationSet");

	Params::EverholmAIAnimInstance_GetOverrideAnimationSet Parms{};

	Parms.locomotionType = locomotionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIAnimInstance.OnAnimNotify
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UEverholmAIAnimInstance::OnAnimNotify(class AActor* Actor, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimInstance", "OnAnimNotify");

	Params::EverholmAIAnimInstance_OnAnimNotify Parms{};

	Parms.Actor = Actor;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIAnimInstance.SetOverrideAnimationSet
// (Native, Public, BlueprintCallable)
// Parameters:
// EAILocomotionType                       locomotionType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimationSet*                    AnimationSet                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIAnimInstance::SetOverrideAnimationSet(EAILocomotionType locomotionType, class UAnimationSet* AnimationSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimInstance", "SetOverrideAnimationSet");

	Params::EverholmAIAnimInstance_SetOverrideAnimationSet Parms{};

	Parms.locomotionType = locomotionType;
	Parms.AnimationSet = AnimationSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIAnimInstance.GetAttackComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAttackComponentBase*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAttackComponentBase* UEverholmAIAnimInstance::GetAttackComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAIAnimInstance", "GetAttackComponent");

	Params::EverholmAIAnimInstance_GetAttackComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BalanceInterface.CanHopOff
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 Input                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IBalanceInterface::CanHopOff(class AEverholmCharacter* Instigator, const struct FVector2D& Input)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "CanHopOff");

	Params::BalanceInterface_CanHopOff Parms{};

	Parms.Instigator = Instigator;
	Parms.Input = std::move(Input);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BalanceInterface.GetBalanceLocation
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 Input                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      WorldTransform                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         DirectionToMove                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  DistanceFromWantedMove                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bAtBoundary                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  MaxInputScale                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IBalanceInterface::GetBalanceLocation(class AEverholmCharacter* Instigator, const struct FVector2D& Input, struct FTransform* WorldTransform, struct FVector* DirectionToMove, float* DistanceFromWantedMove, bool* bAtBoundary, float* MaxInputScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "GetBalanceLocation");

	Params::BalanceInterface_GetBalanceLocation Parms{};

	Parms.Instigator = Instigator;
	Parms.Input = std::move(Input);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (WorldTransform != nullptr)
		*WorldTransform = std::move(Parms.WorldTransform);

	if (DirectionToMove != nullptr)
		*DirectionToMove = std::move(Parms.DirectionToMove);

	if (DistanceFromWantedMove != nullptr)
		*DistanceFromWantedMove = Parms.DistanceFromWantedMove;

	if (bAtBoundary != nullptr)
		*bAtBoundary = Parms.bAtBoundary;

	if (MaxInputScale != nullptr)
		*MaxInputScale = Parms.MaxInputScale;
}


// Function Everholm.BalanceInterface.GetBalanceLocationFromLocation
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   WorldLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bProjectToGround                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector IBalanceInterface::GetBalanceLocationFromLocation(const struct FVector& WorldLocation, bool bProjectToGround)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "GetBalanceLocationFromLocation");

	Params::BalanceInterface_GetBalanceLocationFromLocation Parms{};

	Parms.WorldLocation = std::move(WorldLocation);
	Parms.bProjectToGround = bProjectToGround;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BalanceInterface.OnEndUsing
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IBalanceInterface::OnEndUsing(class AEverholmCharacter* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "OnEndUsing");

	Params::BalanceInterface_OnEndUsing Parms{};

	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BalanceInterface.OnStartUsing
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IBalanceInterface::OnStartUsing(class AEverholmCharacter* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "OnStartUsing");

	Params::BalanceInterface_OnStartUsing Parms{};

	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BalanceInterface.SetReservation
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bReserve                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IBalanceInterface::SetReservation(class AEverholmCharacter* Instigator, bool bReserve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "SetReservation");

	Params::BalanceInterface_SetReservation Parms{};

	Parms.Instigator = Instigator;
	Parms.bReserve = bReserve;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BalanceInterface.GetBalanceType
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// EBalanceType                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EBalanceType IBalanceInterface::GetBalanceType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "GetBalanceType");

	Params::BalanceInterface_GetBalanceType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BalanceInterface.IsAvailable
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// class AEverholmCharacter*               Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IBalanceInterface::IsAvailable(class AEverholmCharacter* Instigator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("BalanceInterface", "IsAvailable");

	Params::BalanceInterface_IsAvailable Parms{};

	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVCombatManager.GetAlertedEnemies
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AEVCombatManager::GetAlertedEnemies()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "GetAlertedEnemies");

	Params::EVCombatManager_GetAlertedEnemies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVCombatManager.HIP_AlertCluster
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   clusterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVCombatManager::HIP_AlertCluster(int32 clusterIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HIP_AlertCluster");

	Params::EVCombatManager_HIP_AlertCluster Parms{};

	Parms.clusterIndex = clusterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HIP_AlertNextEntity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   clusterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVCombatManager::HIP_AlertNextEntity(int32 clusterIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HIP_AlertNextEntity");

	Params::EVCombatManager_HIP_AlertNextEntity Parms{};

	Parms.clusterIndex = clusterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HIP_StartCombat
// (Final, Native, Public, BlueprintCallable)

void AEVCombatManager::HIP_StartCombat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HIP_StartCombat");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HIP_StopCombat
// (Final, Native, Public, BlueprintCallable)

void AEVCombatManager::HIP_StopCombat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HIP_StopCombat");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HIP_UnAlertCluster
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   clusterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVCombatManager::HIP_UnAlertCluster(int32 clusterIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HIP_UnAlertCluster");

	Params::EVCombatManager_HIP_UnAlertCluster Parms{};

	Parms.clusterIndex = clusterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.OnAIAcquiredTarget
// (Final, Native, Private)
// Parameters:
// const class APawn*                      aiPawnThatHasAcquiredTarget                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     Target                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVCombatManager::OnAIAcquiredTarget(const class APawn* aiPawnThatHasAcquiredTarget, const class AActor* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "OnAIAcquiredTarget");

	Params::EVCombatManager_OnAIAcquiredTarget Parms{};

	Parms.aiPawnThatHasAcquiredTarget = aiPawnThatHasAcquiredTarget;
	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.OnAIDespawned
// (Final, Native, Private)
// Parameters:
// const class APawn*                      aiPawnThatDespawned                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVCombatManager::OnAIDespawned(const class APawn* aiPawnThatDespawned)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "OnAIDespawned");

	Params::EVCombatManager_OnAIDespawned Parms{};

	Parms.aiPawnThatDespawned = aiPawnThatDespawned;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.StartCombat
// (Final, Native, Public, BlueprintCallable)

void AEVCombatManager::StartCombat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "StartCombat");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.StopCombat
// (Final, Native, Public, BlueprintCallable)

void AEVCombatManager::StopCombat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "StopCombat");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HOP_OnAllEntitiesDeadInCluster
// (Final, Native, Protected, BlueprintCallable, Const)
// Parameters:
// const int32                             clusterIndex                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVCombatManager::HOP_OnAllEntitiesDeadInCluster(const int32 clusterIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HOP_OnAllEntitiesDeadInCluster");

	Params::EVCombatManager_HOP_OnAllEntitiesDeadInCluster Parms{};

	Parms.clusterIndex = clusterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HOP_OnClusterAlerted
// (Final, Native, Protected, BlueprintCallable, Const)
// Parameters:
// const int32                             clusterIndex                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVCombatManager::HOP_OnClusterAlerted(const int32 clusterIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HOP_OnClusterAlerted");

	Params::EVCombatManager_HOP_OnClusterAlerted Parms{};

	Parms.clusterIndex = clusterIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HOP_OnCombatEnded
// (Final, Native, Protected, BlueprintCallable, Const)

void AEVCombatManager::HOP_OnCombatEnded() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HOP_OnCombatEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVCombatManager.HOP_OnCombatStarted
// (Final, Native, Protected, BlueprintCallable, Const)

void AEVCombatManager::HOP_OnCombatStarted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVCombatManager", "HOP_OnCombatStarted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BlendedBoxHint.GetFocalPointInExtent
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FCameraHintInParameters&   cameraHintIn                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class UBoxComponent*                    InBox                                                  (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BlendRadius_0                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EVolumeBlendType                        BlendType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ABlendedBoxHint::GetFocalPointInExtent(const struct FCameraHintInParameters& cameraHintIn, class UBoxComponent* InBox, const struct FVector& BlendRadius_0, EVolumeBlendType BlendType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BlendedBoxHint", "GetFocalPointInExtent");

	Params::BlendedBoxHint_GetFocalPointInExtent Parms{};

	Parms.cameraHintIn = std::move(cameraHintIn);
	Parms.InBox = InBox;
	Parms.BlendRadius_0 = std::move(BlendRadius_0);
	Parms.BlendType = BlendType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BlendedBoxHint.GetWeightTarget
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FVector&                   focalPointInExtent                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BlendRadius_0                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABlendedBoxHint::GetWeightTarget(const struct FVector& focalPointInExtent, const struct FVector& BlendRadius_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BlendedBoxHint", "GetWeightTarget");

	Params::BlendedBoxHint_GetWeightTarget Parms{};

	Parms.focalPointInExtent = std::move(focalPointInExtent);
	Parms.BlendRadius_0 = std::move(BlendRadius_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BlendedBoxHint.GetActivationBox
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// class UBoxComponent*                    ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBoxComponent* ABlendedBoxHint::GetActivationBox() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BlendedBoxHint", "GetActivationBox");

	Params::BlendedBoxHint_GetActivationBox Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BlendedBoxHint.GetVolumeBlendType
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// EVolumeBlendType                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EVolumeBlendType ABlendedBoxHint::GetVolumeBlendType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BlendedBoxHint", "GetVolumeBlendType");

	Params::BlendedBoxHint_GetVolumeBlendType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BlueprintHintProcessor.ClearBP
// (Event, Public, BlueprintEvent)

void UBlueprintHintProcessor::ClearBP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BlueprintHintProcessor", "ClearBP");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.BlueprintHintProcessor.ComputeResultBP
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UBlueprintHintProcessor::ComputeResultBP(const struct FCameraHintInParameters& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BlueprintHintProcessor", "ComputeResultBP");

	Params::BlueprintHintProcessor_ComputeResultBP Parms{};

	Parms.Params_0 = std::move(Params_0);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BlueprintHintProcessor.ProcessHintBP
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class ADirectedCameraHint_Base*         hint                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UBlueprintHintProcessor::ProcessHintBP(class ADirectedCameraHint_Base* hint, const struct FCameraHintInParameters& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BlueprintHintProcessor", "ProcessHintBP");

	Params::BlueprintHintProcessor_ProcessHintBP Parms{};

	Parms.hint = hint;
	Parms.Params_0 = std::move(Params_0);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmPlayerStart.HOP_ProgressionApplied
// (Final, Native, Public)

void AEverholmPlayerStart::HOP_ProgressionApplied()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "HOP_ProgressionApplied");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerStart.OnRep_PlayersStartData
// (Final, Native, Protected, HasOutParams)
// Parameters:
// TArray<struct FEverholmPlayerStartData>*prevList                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AEverholmPlayerStart::OnRep_PlayersStartData(TArray<struct FEverholmPlayerStartData>* prevList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "OnRep_PlayersStartData");

	Params::EverholmPlayerStart_OnRep_PlayersStartData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (prevList != nullptr)
		*prevList = std::move(Parms.prevList);
}


// Function Everholm.EverholmPlayerStart.PlayerAwakeAtIndex
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bAwake                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerStart::PlayerAwakeAtIndex(bool bAwake, int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "PlayerAwakeAtIndex");

	Params::EverholmPlayerStart_PlayerAwakeAtIndex Parms{};

	Parms.bAwake = bAwake;
	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerStart.PlayerSpawnedAtIndex
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class AEverholmPlayerCharacter*         Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerStart::PlayerSpawnedAtIndex(class AEverholmPlayerCharacter* Character, int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "PlayerSpawnedAtIndex");

	Params::EverholmPlayerStart_PlayerSpawnedAtIndex Parms{};

	Parms.Character = Character;
	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerStart.SetPlayerAwakeAtIndex
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bInAwake                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerStart::SetPlayerAwakeAtIndex(bool bInAwake, int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "SetPlayerAwakeAtIndex");

	Params::EverholmPlayerStart_SetPlayerAwakeAtIndex Parms{};

	Parms.bInAwake = bInAwake;
	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerStart.SetPlayerCharacterAtIndex
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerStart::SetPlayerCharacterAtIndex(class AEverholmPlayerCharacter* Character, int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "SetPlayerCharacterAtIndex");

	Params::EverholmPlayerStart_SetPlayerCharacterAtIndex Parms{};

	Parms.Character = Character;
	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerStart.GetPlayerAwakeAtIndex
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmPlayerStart::GetPlayerAwakeAtIndex(int32 Index_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "GetPlayerAwakeAtIndex");

	Params::EverholmPlayerStart_GetPlayerAwakeAtIndex Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerStart.GetPlayerCharacterAtIndex
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* AEverholmPlayerStart::GetPlayerCharacterAtIndex(int32 Index_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "GetPlayerCharacterAtIndex");

	Params::EverholmPlayerStart_GetPlayerCharacterAtIndex Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerStart.IsDescendantOf
// (Final, Native, Public, HasOutParams, BlueprintCallable, Const)
// Parameters:
// const class AEverholmPlayerStart*&      ancestorPlayerStart                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmPlayerStart::IsDescendantOf(const class AEverholmPlayerStart*& ancestorPlayerStart) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStart", "IsDescendantOf");

	Params::EverholmPlayerStart_IsDescendantOf Parms{};

	Parms.ancestorPlayerStart = ancestorPlayerStart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerStartInBoatBase.HandlePlayersSpawned
// (Event, Public, BlueprintEvent)

void AEverholmPlayerStartInBoatBase::HandlePlayersSpawned()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStartInBoatBase", "HandlePlayersSpawned");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmPlayerStartInBoatBase.GetTargetBoatVehicle
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// class ABoatVehicle*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABoatVehicle* AEverholmPlayerStartInBoatBase::GetTargetBoatVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerStartInBoatBase", "GetTargetBoatVehicle");

	Params::EverholmPlayerStartInBoatBase_GetTargetBoatVehicle Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.BoatBoardLedgeActorGenerator.GetBoatLedgeSegmentData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ledgeIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBoatLedgeSegmentData            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FBoatLedgeSegmentData ABoatBoardLedgeActorGenerator::GetBoatLedgeSegmentData(int32 ledgeIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatBoardLedgeActorGenerator", "GetBoatLedgeSegmentData");

	Params::BoatBoardLedgeActorGenerator_GetBoatLedgeSegmentData Parms{};

	Parms.ledgeIndex = ledgeIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupSpawner.DestroyPickup
// (Event, Public, BlueprintEvent)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupSpawner::DestroyPickup(class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupSpawner", "DestroyPickup");

	Params::PickupSpawner_DestroyPickup Parms{};

	Parms.pickup = pickup;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PickupSpawner.UpdateDestroyTimers
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APickupSpawner::UpdateDestroyTimers(float DeltaSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupSpawner", "UpdateDestroyTimers");

	Params::PickupSpawner_UpdateDestroyTimers Parms{};

	Parms.DeltaSeconds = DeltaSeconds;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.CorrectBoatOffsetOnClient
// (Final, Native, Public, BlueprintCallable)

void UBoatMovementComponent::CorrectBoatOffsetOnClient()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "CorrectBoatOffsetOnClient");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.OnMovementImpact
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   impactSpeed                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatMovementComponent::OnMovementImpact(float impactSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "OnMovementImpact");

	Params::BoatMovementComponent_OnMovementImpact Parms{};

	Parms.impactSpeed = impactSpeed;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatMovementComponent.OnRep_BoatImpactData
// (Final, Native, Protected)

void UBoatMovementComponent::OnRep_BoatImpactData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "OnRep_BoatImpactData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.OnStartingPushOut
// (Final, Native, Public, BlueprintCallable)

void UBoatMovementComponent::OnStartingPushOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "OnStartingPushOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.ResetBoatMovementDirection
// (Final, Native, Public, BlueprintCallable)

void UBoatMovementComponent::ResetBoatMovementDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "ResetBoatMovementDirection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.ResetCollisionAnimDone
// (Final, Native, Protected)

void UBoatMovementComponent::ResetCollisionAnimDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "ResetCollisionAnimDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.SetBoatMovementDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   dir                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatMovementComponent::SetBoatMovementDirection(const struct FVector& dir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "SetBoatMovementDirection");

	Params::BoatMovementComponent_SetBoatMovementDirection Parms{};

	Parms.dir = std::move(dir);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.SetBoostEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatMovementComponent::SetBoostEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "SetBoostEnabled");

	Params::BoatMovementComponent_SetBoostEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.TerminateBoatSimulation
// (Final, Native, Public)

void UBoatMovementComponent::TerminateBoatSimulation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "TerminateBoatSimulation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatMovementComponent.GetBoatMovementDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UBoatMovementComponent::GetBoatMovementDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "GetBoatMovementDirection");

	Params::BoatMovementComponent_GetBoatMovementDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatMovementComponent.GetCurrentWaterBody
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWaterBody*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWaterBody* UBoatMovementComponent::GetCurrentWaterBody() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "GetCurrentWaterBody");

	Params::BoatMovementComponent_GetCurrentWaterBody Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatMovementComponent.IsBoatOnWater
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatMovementComponent::IsBoatOnWater() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "IsBoatOnWater");

	Params::BoatMovementComponent_IsBoatOnWater Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatMovementComponent.IsLandscapeCollisionEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatMovementComponent::IsLandscapeCollisionEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatMovementComponent", "IsLandscapeCollisionEnabled");

	Params::BoatMovementComponent_IsLandscapeCollisionEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatTrackingSubsystem.SetLastInteractedBoat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABoatVehicle*                     boat                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatTrackingSubsystem::SetLastInteractedBoat(class ABoatVehicle* boat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatTrackingSubsystem", "SetLastInteractedBoat");

	Params::BoatTrackingSubsystem_SetLastInteractedBoat Parms{};

	Parms.boat = boat;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatTrackingSubsystem.GetBoatVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABoatVehicle*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABoatVehicle* UBoatTrackingSubsystem::GetBoatVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatTrackingSubsystem", "GetBoatVehicle");

	Params::BoatTrackingSubsystem_GetBoatVehicle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatTrackingSubsystem.GetCurrentBoatVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABoatVehicle*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABoatVehicle* UBoatTrackingSubsystem::GetCurrentBoatVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatTrackingSubsystem", "GetCurrentBoatVehicle");

	Params::BoatTrackingSubsystem_GetCurrentBoatVehicle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatTrackingSubsystem.GetLastInteractedBoatVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABoatVehicle*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABoatVehicle* UBoatTrackingSubsystem::GetLastInteractedBoatVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatTrackingSubsystem", "GetLastInteractedBoatVehicle");

	Params::BoatTrackingSubsystem_GetLastInteractedBoatVehicle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatTrackingSubsystem.GetPreviousBoardedBoatVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABoatVehicle*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABoatVehicle* UBoatTrackingSubsystem::GetPreviousBoardedBoatVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatTrackingSubsystem", "GetPreviousBoardedBoatVehicle");

	Params::BoatTrackingSubsystem_GetPreviousBoardedBoatVehicle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterAlignmentCallbackProxy.AlignCharacter
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   relativeTargetLocation                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  relativeTargetRotation                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EAlignmentMode                          alignmentMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   alignmentSpeedOverride                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    skipRootMotionMontage                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    hardAbortExistingAlignment                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  targetSceneComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmCharacterAlignmentCallbackProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmCharacterAlignmentCallbackProxy* UEverholmCharacterAlignmentCallbackProxy::AlignCharacter(class AEverholmCharacter* Character, const struct FVector& relativeTargetLocation, const struct FRotator& relativeTargetRotation, EAlignmentMode alignmentMode, float alignmentSpeedOverride, bool skipRootMotionMontage, bool hardAbortExistingAlignment, class USceneComponent* targetSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmCharacterAlignmentCallbackProxy", "AlignCharacter");

	Params::EverholmCharacterAlignmentCallbackProxy_AlignCharacter Parms{};

	Parms.Character = Character;
	Parms.relativeTargetLocation = std::move(relativeTargetLocation);
	Parms.relativeTargetRotation = std::move(relativeTargetRotation);
	Parms.alignmentMode = alignmentMode;
	Parms.alignmentSpeedOverride = alignmentSpeedOverride;
	Parms.skipRootMotionMontage = skipRootMotionMontage;
	Parms.hardAbortExistingAlignment = hardAbortExistingAlignment;
	Parms.targetSceneComponent = targetSceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterAlignmentCallbackProxy.OnEnded
// (Final, Native, Private)
// Parameters:
// EEndAlignmentResult                     endResult                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterAlignmentCallbackProxy::OnEnded(EEndAlignmentResult endResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAlignmentCallbackProxy", "OnEnded");

	Params::EverholmCharacterAlignmentCallbackProxy_OnEnded Parms{};

	Parms.endResult = endResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.ApplyAnimIKAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bGrab                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             IKpoint                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEasingFunc                             EasingFunction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::ApplyAnimIKAction(class AEverholmPlayerCharacter* Character, bool bGrab, class FName IKpoint, float BlendTime, EEasingFunc EasingFunction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ApplyAnimIKAction");

	Params::BoatVehicle_ApplyAnimIKAction Parms{};

	Parms.Character = Character;
	Parms.bGrab = bGrab;
	Parms.IKpoint = IKpoint;
	Parms.BlendTime = BlendTime;
	Parms.EasingFunction = EasingFunction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.DeferredClientTeleport
// (Final, Native, Protected)

void ABoatVehicle::DeferredClientTeleport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "DeferredClientTeleport");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.DetectWaterBodyBelow
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bDetectWater                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::DetectWaterBodyBelow(bool bDetectWater)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "DetectWaterBodyBelow");

	Params::BoatVehicle_DetectWaterBodyBelow Parms{};

	Parms.bDetectWater = bDetectWater;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.DockBoardingStateUpdate
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::DockBoardingStateUpdate(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "DockBoardingStateUpdate");

	Params::BoatVehicle_DockBoardingStateUpdate Parms{};

	Parms.bEnabled = bEnabled;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatVehicle.GetBoatImpactData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVehicleImpactData               ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FVehicleImpactData ABoatVehicle::GetBoatImpactData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetBoatImpactData");

	Params::BoatVehicle_GetBoatImpactData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.GetBoatThrowData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FBoatThrowData                   ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FBoatThrowData ABoatVehicle::GetBoatThrowData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetBoatThrowData");

	Params::BoatVehicle_GetBoatThrowData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.GetBoatWaveData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FBoatWaveData                    ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FBoatWaveData ABoatVehicle::GetBoatWaveData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetBoatWaveData");

	Params::BoatVehicle_GetBoatWaveData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.HandleClientCollisionEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FClientBoatCollisionEvent& Event                                                  (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void ABoatVehicle::HandleClientCollisionEvent(const struct FClientBoatCollisionEvent& Event)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "HandleClientCollisionEvent");

	Params::BoatVehicle_HandleClientCollisionEvent Parms{};

	Parms.Event = std::move(Event);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatVehicle.HarpoonThrowDone
// (Final, Native, Protected)

void ABoatVehicle::HarpoonThrowDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "HarpoonThrowDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.Multicast_ClientTeleportBoatAndFindLedge
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults)
// Parameters:
// const struct FTransform&                teleportTo                                             (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::Multicast_ClientTeleportBoatAndFindLedge(const struct FTransform& teleportTo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "Multicast_ClientTeleportBoatAndFindLedge");

	Params::BoatVehicle_Multicast_ClientTeleportBoatAndFindLedge Parms{};

	Parms.teleportTo = std::move(teleportTo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.Multicast_SetPlayerInWater
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         PlayerCharacter                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::Multicast_SetPlayerInWater(class AEverholmPlayerCharacter* PlayerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "Multicast_SetPlayerInWater");

	Params::BoatVehicle_Multicast_SetPlayerInWater Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.Multicast_TeleportBoatAndFindLedge
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// const struct FTransform&                teleportTo                                             (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTeleportingToLand                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::Multicast_TeleportBoatAndFindLedge(const struct FTransform& teleportTo, bool bTeleportingToLand)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "Multicast_TeleportBoatAndFindLedge");

	Params::BoatVehicle_Multicast_TeleportBoatAndFindLedge Parms{};

	Parms.teleportTo = std::move(teleportTo);
	Parms.bTeleportingToLand = bTeleportingToLand;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.OnRep_CurrentWaterBody
// (Final, Native, Protected)

void ABoatVehicle::OnRep_CurrentWaterBody()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "OnRep_CurrentWaterBody");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.PlayerEnterTriggerRegion
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                teleportTo                                             (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTeleportingToLand                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           triggerRegionActor                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::PlayerEnterTriggerRegion(const struct FTransform& teleportTo, bool bTeleportingToLand, class AActor* triggerRegionActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "PlayerEnterTriggerRegion");

	Params::BoatVehicle_PlayerEnterTriggerRegion Parms{};

	Parms.teleportTo = std::move(teleportTo);
	Parms.bTeleportingToLand = bTeleportingToLand;
	Parms.triggerRegionActor = triggerRegionActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.ReleaseAllIK
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   BlendTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEasingFunc                             EasingFunction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::ReleaseAllIK(float BlendTime, EEasingFunc EasingFunction, class AEverholmPlayerCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ReleaseAllIK");

	Params::BoatVehicle_ReleaseAllIK Parms{};

	Parms.BlendTime = BlendTime;
	Parms.EasingFunction = EasingFunction;
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.ReplicateClientBraceEvent
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void ABoatVehicle::ReplicateClientBraceEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ReplicateClientBraceEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.ReplicateClientSurfaceCollisionEvent
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EPhysicalSurface                        SurfaceType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Strength                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSubsurface                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::ReplicateClientSurfaceCollisionEvent(EPhysicalSurface SurfaceType, float Strength, bool bSubsurface)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ReplicateClientSurfaceCollisionEvent");

	Params::BoatVehicle_ReplicateClientSurfaceCollisionEvent Parms{};

	Parms.SurfaceType = SurfaceType;
	Parms.Strength = Strength;
	Parms.bSubsurface = bSubsurface;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.ResetOverrideBoatMovementParams
// (Final, Native, Public, BlueprintCallable)

void ABoatVehicle::ResetOverrideBoatMovementParams()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ResetOverrideBoatMovementParams");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.SetOverrideBoatMovementParams
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ForwardSpeed                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RotationSpeed                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReverseSpeed                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BoostSpeed                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::SetOverrideBoatMovementParams(float ForwardSpeed, float RotationSpeed, float ReverseSpeed, float BoostSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "SetOverrideBoatMovementParams");

	Params::BoatVehicle_SetOverrideBoatMovementParams Parms{};

	Parms.ForwardSpeed = ForwardSpeed;
	Parms.RotationSpeed = RotationSpeed;
	Parms.ReverseSpeed = ReverseSpeed;
	Parms.BoostSpeed = BoostSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.TerminateBoatSimulation
// (Final, Native, Public, BlueprintCallable)

void ABoatVehicle::TerminateBoatSimulation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "TerminateBoatSimulation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.ThrowHarpoonFromBoat
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   velocityDir                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::ThrowHarpoonFromBoat(const struct FVector& velocityDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ThrowHarpoonFromBoat");

	Params::BoatVehicle_ThrowHarpoonFromBoat Parms{};

	Parms.velocityDir = std::move(velocityDir);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.ToggleBoatEngineSound
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::ToggleBoatEngineSound(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ToggleBoatEngineSound");

	Params::BoatVehicle_ToggleBoatEngineSound Parms{};

	Parms.bEnabled = bEnabled;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatVehicle.ToggleBoatLights
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::ToggleBoatLights(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "ToggleBoatLights");

	Params::BoatVehicle_ToggleBoatLights Parms{};

	Parms.bEnabled = bEnabled;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatVehicle.WaterBodyOceanLoaded
// (Final, Native, Protected)
// Parameters:
// class UWaterBodyComponent*              oceanWaterBodyComponent                                (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoatVehicle::WaterBodyOceanLoaded(class UWaterBodyComponent* oceanWaterBodyComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "WaterBodyOceanLoaded");

	Params::BoatVehicle_WaterBodyOceanLoaded Parms{};

	Parms.oceanWaterBodyComponent = oceanWaterBodyComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicle.GetBoatBoardComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UBoatVehicleBoardComponent*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBoatVehicleBoardComponent* ABoatVehicle::GetBoatBoardComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetBoatBoardComponent");

	Params::BoatVehicle_GetBoatBoardComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.GetBoatMovementComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UBoatMovementComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBoatMovementComponent* ABoatVehicle::GetBoatMovementComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetBoatMovementComponent");

	Params::BoatVehicle_GetBoatMovementComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.GetBoatPointVelocity
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   PointIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ABoatVehicle::GetBoatPointVelocity(int32 PointIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetBoatPointVelocity");

	Params::BoatVehicle_GetBoatPointVelocity Parms{};

	Parms.PointIndex = PointIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.GetPassengerMoveAroundComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPassengerMoveAroundComponent*    ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPassengerMoveAroundComponent* ABoatVehicle::GetPassengerMoveAroundComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetPassengerMoveAroundComponent");

	Params::BoatVehicle_GetPassengerMoveAroundComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.GetRawPassengerActorAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABoatVehicle::GetRawPassengerActorAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetRawPassengerActorAngle");

	Params::BoatVehicle_GetRawPassengerActorAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.GetRawPassengerAimAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABoatVehicle::GetRawPassengerAimAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "GetRawPassengerAimAngle");

	Params::BoatVehicle_GetRawPassengerAimAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.IsExiting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABoatVehicle::IsExiting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "IsExiting");

	Params::BoatVehicle_IsExiting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.IsSinglePlayerControlled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABoatVehicle::IsSinglePlayerControlled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "IsSinglePlayerControlled");

	Params::BoatVehicle_IsSinglePlayerControlled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.IsWaterDetected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABoatVehicle::IsWaterDetected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "IsWaterDetected");

	Params::BoatVehicle_IsWaterDetected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicle.PassengerShouldUseLanterStashSocketOnBoat
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABoatVehicle::PassengerShouldUseLanterStashSocketOnBoat() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicle", "PassengerShouldUseLanterStashSocketOnBoat");

	Params::BoatVehicle_PassengerShouldUseLanterStashSocketOnBoat Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.ShadowPlayerSubsystem.GetActiveShadowCamera
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AShadowPlayerCamera*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AShadowPlayerCamera* UShadowPlayerSubsystem::GetActiveShadowCamera() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerSubsystem", "GetActiveShadowCamera");

	Params::ShadowPlayerSubsystem_GetActiveShadowCamera Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAudioSystems.AddMotionOutputToEmitterObject
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EMotionOutputTarget                     Output                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkGameObject*                    Object                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::AddMotionOutputToEmitterObject(EMotionOutputTarget Output, class UAkGameObject* Object)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "AddMotionOutputToEmitterObject");

	Params::EverholmAudioSystems_AddMotionOutputToEmitterObject Parms{};

	Parms.Output = Output;
	Parms.Object = Object;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.AttachMusicPlaybackComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  AttachParent                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::AttachMusicPlaybackComponent(class USceneComponent* AttachParent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "AttachMusicPlaybackComponent");

	Params::EverholmAudioSystems_AttachMusicPlaybackComponent Parms{};

	Parms.AttachParent = AttachParent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.GetMusicPlaybackComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMusicPlaybackComponent*          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMusicPlaybackComponent* UEverholmAudioSystems::GetMusicPlaybackComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "GetMusicPlaybackComponent");

	Params::EverholmAudioSystems_GetMusicPlaybackComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAudioSystems.MusicCallback
// (Final, Native, Private)
// Parameters:
// EAkCallbackType                         CallbackType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  CallbackInfo                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::MusicCallback(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "MusicCallback");

	Params::EverholmAudioSystems_MusicCallback Parms{};

	Parms.CallbackType = CallbackType;
	Parms.CallbackInfo = CallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.OnCharactersSwapped
// (Final, Native, Private)

void UEverholmAudioSystems::OnCharactersSwapped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "OnCharactersSwapped");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.OnPhysicalControllerConnectionChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bConnected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ControllerId                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            InputDevice                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::OnPhysicalControllerConnectionChanged(bool bConnected, int32 ControllerId, const struct FInputDeviceId& InputDevice, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "OnPhysicalControllerConnectionChanged");

	Params::EverholmAudioSystems_OnPhysicalControllerConnectionChanged Parms{};

	Parms.bConnected = bConnected;
	Parms.ControllerId = ControllerId;
	Parms.InputDevice = std::move(InputDevice);
	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.OnPlayerRespawn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkGameObject*                    AkGameObject                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::OnPlayerRespawn(class AEverholmCharacter* Character, class UAkGameObject* AkGameObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "OnPlayerRespawn");

	Params::EverholmAudioSystems_OnPlayerRespawn Parms{};

	Parms.Character = Character;
	Parms.AkGameObject = AkGameObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.OnUserInitializationComplete
// (Final, Native, Private)
// Parameters:
// ELocalUserType                          userType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Error                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::OnUserInitializationComplete(ELocalUserType userType, const class UCommonUserInfo* UserInfo, bool bSuccess, const class FString& Error)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "OnUserInitializationComplete");

	Params::EverholmAudioSystems_OnUserInitializationComplete Parms{};

	Parms.userType = userType;
	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.OnUserInputMethodChanged
// (Final, Native, Private)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonInputType                        inputType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::OnUserInputMethodChanged(ELocalUserType localUserType, ECommonInputType inputType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "OnUserInputMethodChanged");

	Params::EverholmAudioSystems_OnUserInputMethodChanged Parms{};

	Parms.localUserType = localUserType;
	Parms.inputType = inputType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.OnUserPrimaryInputDeviceChanged
// (Final, Native, Private)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            InputDeviceId                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            oldInputDeviceId                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::OnUserPrimaryInputDeviceChanged(ELocalUserType localUserType, const struct FInputDeviceId& InputDeviceId, const struct FInputDeviceId& oldInputDeviceId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "OnUserPrimaryInputDeviceChanged");

	Params::EverholmAudioSystems_OnUserPrimaryInputDeviceChanged Parms{};

	Parms.localUserType = localUserType;
	Parms.InputDeviceId = std::move(InputDeviceId);
	Parms.oldInputDeviceId = std::move(oldInputDeviceId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.RemoveMotionOutputFromEmitterObject
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EMotionOutputTarget                     Output                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkGameObject*                    Object                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::RemoveMotionOutputFromEmitterObject(EMotionOutputTarget Output, class UAkGameObject* Object)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "RemoveMotionOutputFromEmitterObject");

	Params::EverholmAudioSystems_RemoveMotionOutputFromEmitterObject Parms{};

	Parms.Output = Output;
	Parms.Object = Object;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.BlendListenerLocation
// (Final, Native, Private, Const)

void UEverholmAudioSystems::BlendListenerLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "BlendListenerLocation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAudioSystems.OnShouldBlendListenerLocationChanged
// (Final, Native, Private, Const)
// Parameters:
// bool                                    shouldBlendListenerLocation                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAudioSystems::OnShouldBlendListenerLocationChanged(bool shouldBlendListenerLocation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAudioSystems", "OnShouldBlendListenerLocationChanged");

	Params::EverholmAudioSystems_OnShouldBlendListenerLocationChanged Parms{};

	Parms.shouldBlendListenerLocation = shouldBlendListenerLocation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.AlignAndDeboardAtSetDockPoint
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatVehicleBoardComponent::AlignAndDeboardAtSetDockPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "AlignAndDeboardAtSetDockPoint");

	Params::BoatVehicleBoardComponent_AlignAndDeboardAtSetDockPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.AlignWithDockForward
// (Final, Native, Protected)

void UBoatVehicleBoardComponent::AlignWithDockForward()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "AlignWithDockForward");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.BoatBoardEnterStateUpdate
// (Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatEnterType                          enterType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatBoardState                         State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::BoatBoardEnterStateUpdate(class AEverholmCharacter* Character, EBoatEnterType enterType, EBoatBoardState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "BoatBoardEnterStateUpdate");

	Params::BoatVehicleBoardComponent_BoatBoardEnterStateUpdate Parms{};

	Parms.Character = Character;
	Parms.enterType = enterType;
	Parms.State = State;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatVehicleBoardComponent.BoatBoardExitStateUpdate
// (Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatExitType                           exitType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatBoardState                         State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::BoatBoardExitStateUpdate(class AEverholmCharacter* Character, EBoatExitType exitType, EBoatBoardState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "BoatBoardExitStateUpdate");

	Params::BoatVehicleBoardComponent_BoatBoardExitStateUpdate Parms{};

	Parms.Character = Character;
	Parms.exitType = exitType;
	Parms.State = State;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatVehicleBoardComponent.BoatExitOnLandUpdate
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bExitOnLand                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::BoatExitOnLandUpdate(bool bExitOnLand)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "BoatExitOnLandUpdate");

	Params::BoatVehicleBoardComponent_BoatExitOnLandUpdate Parms{};

	Parms.bExitOnLand = bExitOnLand;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.BoatVehicleBoardComponent.DockingAlignDone
// (Final, Native, Protected)

void UBoatVehicleBoardComponent::DockingAlignDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "DockingAlignDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.DoneAligning
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::DoneAligning(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "DoneAligning");

	Params::BoatVehicleBoardComponent_DoneAligning Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.DoneEntering
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::DoneEntering(const class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "DoneEntering");

	Params::BoatVehicleBoardComponent_DoneEntering Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.DoneExitAligning
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::DoneExitAligning(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "DoneExitAligning");

	Params::BoatVehicleBoardComponent_DoneExitAligning Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.DoneExiting
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::DoneExiting(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "DoneExiting");

	Params::BoatVehicleBoardComponent_DoneExiting Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.GetBoatEnterDataForCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBoatEnterHelperData             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FBoatEnterHelperData UBoatVehicleBoardComponent::GetBoatEnterDataForCharacter(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "GetBoatEnterDataForCharacter");

	Params::BoatVehicleBoardComponent_GetBoatEnterDataForCharacter Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.GetBoatExitDataForCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBoatExitHelperData              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FBoatExitHelperData UBoatVehicleBoardComponent::GetBoatExitDataForCharacter(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "GetBoatExitDataForCharacter");

	Params::BoatVehicleBoardComponent_GetBoatExitDataForCharacter Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.GetDeboardingCharacter
// (Final, Native, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    bIsRower                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmCharacter* UBoatVehicleBoardComponent::GetDeboardingCharacter(bool bIsRower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "GetDeboardingCharacter");

	Params::BoatVehicleBoardComponent_GetDeboardingCharacter Parms{};

	Parms.bIsRower = bIsRower;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.GetWarpTargetForCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* UBoatVehicleBoardComponent::GetWarpTargetForCharacter(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "GetWarpTargetForCharacter");

	Params::BoatVehicleBoardComponent_GetWarpTargetForCharacter Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.GetWarpTargetFromExitHelperData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FBoatExitHelperData&       helperData                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* UBoatVehicleBoardComponent::GetWarpTargetFromExitHelperData(const struct FBoatExitHelperData& helperData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "GetWarpTargetFromExitHelperData");

	Params::BoatVehicleBoardComponent_GetWarpTargetFromExitHelperData Parms{};

	Parms.helperData = std::move(helperData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.HandleDockingProcedureStarted
// (Event, Protected, BlueprintEvent)

void UBoatVehicleBoardComponent::HandleDockingProcedureStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "HandleDockingProcedureStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.BoatVehicleBoardComponent.HandleMatchStart
// (Final, Native, Protected)

void UBoatVehicleBoardComponent::HandleMatchStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "HandleMatchStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.IsEnteringWithPushBoat
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatVehicleBoardComponent::IsEnteringWithPushBoat(const class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "IsEnteringWithPushBoat");

	Params::BoatVehicleBoardComponent_IsEnteringWithPushBoat Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.MoveToDeboardSpotDone
// (Final, Native, Public, BlueprintCallable)

void UBoatVehicleBoardComponent::MoveToDeboardSpotDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "MoveToDeboardSpotDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.OnRep_BoatBoardDataEnterList
// (Final, Native, Protected, HasOutParams)
// Parameters:
// TArray<struct FBoatBoardDataEnter>*     previousEnterList                                      (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::OnRep_BoatBoardDataEnterList(TArray<struct FBoatBoardDataEnter>* previousEnterList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "OnRep_BoatBoardDataEnterList");

	Params::BoatVehicleBoardComponent_OnRep_BoatBoardDataEnterList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (previousEnterList != nullptr)
		*previousEnterList = std::move(Parms.previousEnterList);
}


// Function Everholm.BoatVehicleBoardComponent.OnRep_BoatBoardDataExitList
// (Final, Native, Protected, HasOutParams)
// Parameters:
// TArray<struct FBoatBoardDataExit>*      previousExitList                                       (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::OnRep_BoatBoardDataExitList(TArray<struct FBoatBoardDataExit>* previousExitList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "OnRep_BoatBoardDataExitList");

	Params::BoatVehicleBoardComponent_OnRep_BoatBoardDataExitList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (previousExitList != nullptr)
		*previousExitList = std::move(Parms.previousExitList);
}


// Function Everholm.BoatVehicleBoardComponent.PushBoatInteractionEvent
// (Final, Native, Protected)
// Parameters:
// bool                                    bValidInput                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::PushBoatInteractionEvent(bool bValidInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "PushBoatInteractionEvent");

	Params::BoatVehicleBoardComponent_PushBoatInteractionEvent Parms{};

	Parms.bValidInput = bValidInput;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.PushInteractionEnterDoneForCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::PushInteractionEnterDoneForCharacter(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "PushInteractionEnterDoneForCharacter");

	Params::BoatVehicleBoardComponent_PushInteractionEnterDoneForCharacter Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.ResetDockPoint
// (Final, Native, Public, BlueprintCallable)

void UBoatVehicleBoardComponent::ResetDockPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "ResetDockPoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.SetDockPointActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ADockBoatActor*                   dockActor                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::SetDockPointActor(class ADockBoatActor* dockActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "SetDockPointActor");

	Params::BoatVehicleBoardComponent_SetDockPointActor Parms{};

	Parms.dockActor = dockActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.SpawnDecalAtBoatLocation
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UBoatVehicleBoardComponent::SpawnDecalAtBoatLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "SpawnDecalAtBoatLocation");

	Params::BoatVehicleBoardComponent_SpawnDecalAtBoatLocation Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.StartEnteringBoat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatEnterType                          enterType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatBoardState                         boardState                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::StartEnteringBoat(class AEverholmCharacter* Character, EBoatEnterType enterType, EBoatBoardState boardState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "StartEnteringBoat");

	Params::BoatVehicleBoardComponent_StartEnteringBoat Parms{};

	Parms.Character = Character;
	Parms.enterType = enterType;
	Parms.boardState = boardState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.StartExitingBoat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatExitType                           enterType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EBoatBoardState                         boardState                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoatVehicleBoardComponent::StartExitingBoat(class AEverholmCharacter* Character, EBoatExitType enterType, EBoatBoardState boardState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "StartExitingBoat");

	Params::BoatVehicleBoardComponent_StartExitingBoat Parms{};

	Parms.Character = Character;
	Parms.enterType = enterType;
	Parms.boardState = boardState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.TraceForwardForDriverWhileExiting
// (Final, Native, Protected)

void UBoatVehicleBoardComponent::TraceForwardForDriverWhileExiting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "TraceForwardForDriverWhileExiting");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.TraceForwardForPassengerWhileExiting
// (Final, Native, Protected)

void UBoatVehicleBoardComponent::TraceForwardForPassengerWhileExiting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "TraceForwardForPassengerWhileExiting");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoatVehicleBoardComponent.GetExitingDistanceToCover
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UBoatVehicleBoardComponent::GetExitingDistanceToCover() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "GetExitingDistanceToCover");

	Params::BoatVehicleBoardComponent_GetExitingDistanceToCover Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.GetOwnerBoatVehicle
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABoatVehicle*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABoatVehicle* UBoatVehicleBoardComponent::GetOwnerBoatVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "GetOwnerBoatVehicle");

	Params::BoatVehicleBoardComponent_GetOwnerBoatVehicle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.IsAllowedToDeboard
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatVehicleBoardComponent::IsAllowedToDeboard(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "IsAllowedToDeboard");

	Params::BoatVehicleBoardComponent_IsAllowedToDeboard Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.IsExiting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatVehicleBoardComponent::IsExiting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "IsExiting");

	Params::BoatVehicleBoardComponent_IsExiting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.IsPairedEntry
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatVehicleBoardComponent::IsPairedEntry() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "IsPairedEntry");

	Params::BoatVehicleBoardComponent_IsPairedEntry Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.IsPotentialPassenger
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatVehicleBoardComponent::IsPotentialPassenger(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "IsPotentialPassenger");

	Params::BoatVehicleBoardComponent_IsPotentialPassenger Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoatVehicleBoardComponent.IsPotentialRower
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmCharacter*         Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UBoatVehicleBoardComponent::IsPotentialRower(const class AEverholmCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoatVehicleBoardComponent", "IsPotentialRower");

	Params::BoatVehicleBoardComponent_IsPotentialRower Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Boomer.EnableThrowTarget
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABoomer::EnableThrowTarget(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Boomer", "EnableThrowTarget");

	Params::Boomer_EnableThrowTarget Parms{};

	Parms.bEnable = bEnable;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.Boomer.CanAttachHarpoon
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ABoomer::CanAttachHarpoon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Boomer", "CanAttachHarpoon");

	Params::Boomer_CanAttachHarpoon Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.TarsierUIMessageQueueSubsystem.EnqueueMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      Text                                                   (Parm, NativeAccessSpecifierPublic)
// EUIMessageType                          MessageType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTarsierUIMessageQueueSubsystem::EnqueueMessage(const class FText& Text, EUIMessageType MessageType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TarsierUIMessageQueueSubsystem", "EnqueueMessage");

	Params::TarsierUIMessageQueueSubsystem_EnqueueMessage Parms{};

	Parms.Text = std::move(Text);
	Parms.MessageType = MessageType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoomerManagerSubsystem.HandleBoomerChasingStateChange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABoomer*                          Boomer                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsChasing                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoomerManagerSubsystem::HandleBoomerChasingStateChange(class ABoomer* Boomer, bool bIsChasing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoomerManagerSubsystem", "HandleBoomerChasingStateChange");

	Params::BoomerManagerSubsystem_HandleBoomerChasingStateChange Parms{};

	Parms.Boomer = Boomer;
	Parms.bIsChasing = bIsChasing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoomerManagerSubsystem.RegisterBoomer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABoomer*                          Boomer                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoomerManagerSubsystem::RegisterBoomer(class ABoomer* Boomer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoomerManagerSubsystem", "RegisterBoomer");

	Params::BoomerManagerSubsystem_RegisterBoomer Parms{};

	Parms.Boomer = Boomer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoomerManagerSubsystem.UnregisterBoomer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABoomer*                          Boomer                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBoomerManagerSubsystem::UnregisterBoomer(class ABoomer* Boomer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoomerManagerSubsystem", "UnregisterBoomer");

	Params::BoomerManagerSubsystem_UnregisterBoomer Parms{};

	Parms.Boomer = Boomer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.BoomerManagerSubsystem.GetBoomers
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class ABoomer*>            ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<class ABoomer*> UBoomerManagerSubsystem::GetBoomers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoomerManagerSubsystem", "GetBoomers");

	Params::BoomerManagerSubsystem_GetBoomers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.BoomerManagerSubsystem.GetBoomersInRange
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class ABoomer*                          Boomer                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ABoomer*>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ABoomer*> UBoomerManagerSubsystem::GetBoomersInRange(class ABoomer* Boomer, float Radius) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BoomerManagerSubsystem", "GetBoomersInRange");

	Params::BoomerManagerSubsystem_GetBoomersInRange Parms{};

	Parms.Boomer = Boomer;
	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CallAbility.CallCooldownDone
// (Final, Native, Protected)

void UCallAbility::CallCooldownDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CallAbility", "CallCooldownDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCameraManager.AddManualHint
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCameraManager::AddManualHint(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCameraManager", "AddManualHint");

	Params::EverholmCameraManager_AddManualHint Parms{};

	Parms.Actor = Actor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmCameraManager.OnOwnerPossessionChanged
// (Native, Protected)
// Parameters:
// class APawn*                            OldPawn                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            NewPawn                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCameraManager::OnOwnerPossessionChanged(class APawn* OldPawn, class APawn* NewPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCameraManager", "OnOwnerPossessionChanged");

	Params::EverholmCameraManager_OnOwnerPossessionChanged Parms{};

	Parms.OldPawn = OldPawn;
	Parms.NewPawn = NewPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCameraManager.GetFocalPointLocation
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEverholmCameraManager::GetFocalPointLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCameraManager", "GetFocalPointLocation");

	Params::EverholmCameraManager_GetFocalPointLocation Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCameraManager.GetLookAround
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector2D                  ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector2D AEverholmCameraManager::GetLookAround() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCameraManager", "GetLookAround");

	Params::EverholmCameraManager_GetLookAround Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CameraFocalPointComponent.CalculatePlayerFocalPoints
// (Final, Native, Public, BlueprintCallable)

void UCameraFocalPointComponent::CalculatePlayerFocalPoints()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraFocalPointComponent", "CalculatePlayerFocalPoints");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CameraFocalPointComponent.GetAlivePlayerPawns
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// TArray<class APawn*>                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class APawn*> UCameraFocalPointComponent::GetAlivePlayerPawns() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraFocalPointComponent", "GetAlivePlayerPawns");

	Params::CameraFocalPointComponent_GetAlivePlayerPawns Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CameraFocalPointComponent.GetPawnOne
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APawn* UCameraFocalPointComponent::GetPawnOne() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraFocalPointComponent", "GetPawnOne");

	Params::CameraFocalPointComponent_GetPawnOne Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CameraFocalPointComponent.GetPawnTwo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APawn* UCameraFocalPointComponent::GetPawnTwo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraFocalPointComponent", "GetPawnTwo");

	Params::CameraFocalPointComponent_GetPawnTwo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CameraFocalPointComponent.GetRelevantPlayers
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPawnRelevance                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPawnRelevance UCameraFocalPointComponent::GetRelevantPlayers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraFocalPointComponent", "GetRelevantPlayers");

	Params::CameraFocalPointComponent_GetRelevantPlayers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CameraFocalPointComponent.IsRelevant_Override
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// const class APawn*                      Pawn                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCameraFocalPointComponent::IsRelevant_Override(const class APawn* Pawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraFocalPointComponent", "IsRelevant_Override");

	Params::CameraFocalPointComponent_IsRelevant_Override Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CameraHintComponent.ComputeResults
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UCameraHintComponent::ComputeResults(const struct FCameraHintInParameters& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "ComputeResults");

	Params::CameraHintComponent_ComputeResults Parms{};

	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CameraHintComponent.ProcessHints
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class ADirectedCameraHint_Base*>&gatheredHints                                          (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UCameraHintComponent::ProcessHints(const TArray<class ADirectedCameraHint_Base*>& gatheredHints, const struct FCameraHintInParameters& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "ProcessHints");

	Params::CameraHintComponent_ProcessHints Parms{};

	Parms.gatheredHints = std::move(gatheredHints);
	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CameraHintComponent.GetAimOffsetHint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator*                        Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetAimOffsetHint(struct FRotator* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetAimOffsetHint");

	Params::CameraHintComponent_GetAimOffsetHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = std::move(Parms.Value);

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetAimOffsetLeadMultiplierHint
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetAimOffsetLeadMultiplierHint(float* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetAimOffsetLeadMultiplierHint");

	Params::CameraHintComponent_GetAimOffsetLeadMultiplierHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = Parms.Value;

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetArmLengthMultiplierHint
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetArmLengthMultiplierHint(float* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetArmLengthMultiplierHint");

	Params::CameraHintComponent_GetArmLengthMultiplierHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = Parms.Value;

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetAvoidanceDisabledHint
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCameraHintComponent::GetAvoidanceDisabledHint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetAvoidanceDisabledHint");

	Params::CameraHintComponent_GetAvoidanceDisabledHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CameraHintComponent.GetDOFFocusRegionHint
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetDOFFocusRegionHint(float* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetDOFFocusRegionHint");

	Params::CameraHintComponent_GetDOFFocusRegionHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = Parms.Value;

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetFocalPointOffsetHint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector*                         Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetFocalPointOffsetHint(struct FVector* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetFocalPointOffsetHint");

	Params::CameraHintComponent_GetFocalPointOffsetHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = std::move(Parms.Value);

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetFOVHint
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetFOVHint(float* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetFOVHint");

	Params::CameraHintComponent_GetFOVHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = Parms.Value;

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetLookAroundLimitsHint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator*                        Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetLookAroundLimitsHint(struct FRotator* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetLookAroundLimitsHint");

	Params::CameraHintComponent_GetLookAroundLimitsHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = std::move(Parms.Value);

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetOverrideRInterpSpeedHint
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetOverrideRInterpSpeedHint(float* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetOverrideRInterpSpeedHint");

	Params::CameraHintComponent_GetOverrideRInterpSpeedHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = Parms.Value;

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraHintComponent.GetRotationHint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator*                        Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float*                                  rollWeight                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  pitchWeight                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  yawWeight                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetRotationHint(struct FRotator* Value, float* rollWeight, float* pitchWeight, float* yawWeight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetRotationHint");

	Params::CameraHintComponent_GetRotationHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = std::move(Parms.Value);

	if (rollWeight != nullptr)
		*rollWeight = Parms.rollWeight;

	if (pitchWeight != nullptr)
		*pitchWeight = Parms.pitchWeight;

	if (yawWeight != nullptr)
		*yawWeight = Parms.yawWeight;
}


// Function Everholm.CameraHintComponent.GetTransformHint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      Value                                                  (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Weight                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCameraHintComponent::GetTransformHint(struct FTransform* Value, float* Weight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraHintComponent", "GetTransformHint");

	Params::CameraHintComponent_GetTransformHint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = std::move(Parms.Value);

	if (Weight != nullptr)
		*Weight = Parms.Weight;
}


// Function Everholm.CameraWhiskersComponent.GetHorizontalWhiskerHitInfos
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FWhiskerHitInfo>    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FWhiskerHitInfo> UCameraWhiskersComponent::GetHorizontalWhiskerHitInfos() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CameraWhiskersComponent", "GetHorizontalWhiskerHitInfos");

	Params::CameraWhiskersComponent_GetHorizontalWhiskerHitInfos Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Camp.BP_OnBeginTriggerOverlap
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACamp::BP_OnBeginTriggerOverlap(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Camp", "BP_OnBeginTriggerOverlap");

	Params::Camp_BP_OnBeginTriggerOverlap Parms{};

	Parms.InActor = InActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.Camp.BP_OnEndTriggerOverlap
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACamp::BP_OnEndTriggerOverlap(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Camp", "BP_OnEndTriggerOverlap");

	Params::Camp_BP_OnEndTriggerOverlap Parms{};

	Parms.InActor = InActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.Camp.OnBeginTriggerOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACamp::OnBeginTriggerOverlap(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Camp", "OnBeginTriggerOverlap");

	Params::Camp_OnBeginTriggerOverlap Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.Camp.OnEndTriggerOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACamp::OnEndTriggerOverlap(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("Camp", "OnEndTriggerOverlap");

	Params::Camp_OnEndTriggerOverlap Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CampFire.BP_SetCampActive
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    InIsActive                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACampFire::BP_SetCampActive(bool InIsActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CampFire", "BP_SetCampActive");

	Params::CampFire_BP_SetCampActive Parms{};

	Parms.InIsActive = InIsActive;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.CampFire.OnRep_IsCampActive
// (Final, Native, Protected)

void ACampFire::OnRep_IsCampActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CampFire", "OnRep_IsCampActive");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CampFire.SetCampActive
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    InIsActive                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ACampFire::SetCampActive(bool InIsActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CampFire", "SetCampActive");

	Params::CampFire_SetCampActive Parms{};

	Parms.InIsActive = InIsActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ChaosVehicleActor.IsDriverInputCameraRelative
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AChaosVehicleActor::IsDriverInputCameraRelative() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosVehicleActor", "IsDriverInputCameraRelative");

	Params::ChaosVehicleActor_IsDriverInputCameraRelative Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChaosVehicleActor.IsPassengerInputCameraRelative
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AChaosVehicleActor::IsPassengerInputCameraRelative() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosVehicleActor", "IsPassengerInputCameraRelative");

	Params::ChaosVehicleActor_IsPassengerInputCameraRelative Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.ApplyReplicatedDamage
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   hitFromDirection                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               eventInstigator                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UDamageType>          damageTypeClass                                        (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::ApplyReplicatedDamage(class AActor* DamagedActor, const struct FVector& hitFromDirection, const struct FHitResult& HitInfo, class AEverholmCharacter* eventInstigator, class AActor* DamageCauser, TSubclassOf<class UDamageType> damageTypeClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmCharacter", "ApplyReplicatedDamage");

	Params::EverholmCharacter_ApplyReplicatedDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.hitFromDirection = std::move(hitFromDirection);
	Parms.HitInfo = std::move(HitInfo);
	Parms.eventInstigator = eventInstigator;
	Parms.DamageCauser = DamageCauser;
	Parms.damageTypeClass = damageTypeClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AbortAlignment
// (Final, Native, Public, BlueprintCallable)

void AEverholmCharacter::AbortAlignment()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AbortAlignment");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AbortTeleport_Client
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void AEverholmCharacter::AbortTeleport_Client()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AbortTeleport_Client");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AddLooseGameplayActivationTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*&                   instigatorObject                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::AddLooseGameplayActivationTag(const struct FGameplayTag& Tag, const class UObject*& instigatorObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AddLooseGameplayActivationTag");

	Params::EverholmCharacter_AddLooseGameplayActivationTag Parms{};

	Parms.Tag = std::move(Tag);
	Parms.instigatorObject = instigatorObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AddLooseGameplayActivationTags
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     looseTags                                              (ConstParm, Parm, NativeAccessSpecifierPublic)
// const class UObject*&                   instigatorObject                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::AddLooseGameplayActivationTags(const struct FGameplayTagContainer& looseTags, const class UObject*& instigatorObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AddLooseGameplayActivationTags");

	Params::EverholmCharacter_AddLooseGameplayActivationTags Parms{};

	Parms.looseTags = std::move(looseTags);
	Parms.instigatorObject = instigatorObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AlignWithDuration
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  targetRotation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EAlignmentMode                          alignmentMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    skipRootMotionMontage                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    hardAbortExistingAlignment                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  targetSceneComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::AlignWithDuration(const struct FVector& targetLocation, const struct FRotator& targetRotation, EAlignmentMode alignmentMode, float Duration, bool skipRootMotionMontage, bool hardAbortExistingAlignment, class USceneComponent* targetSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AlignWithDuration");

	Params::EverholmCharacter_AlignWithDuration Parms{};

	Parms.targetLocation = std::move(targetLocation);
	Parms.targetRotation = std::move(targetRotation);
	Parms.alignmentMode = alignmentMode;
	Parms.Duration = Duration;
	Parms.skipRootMotionMontage = skipRootMotionMontage;
	Parms.hardAbortExistingAlignment = hardAbortExistingAlignment;
	Parms.targetSceneComponent = targetSceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.AlignWithDuration_Replicated
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  targetRotation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EAlignmentMode                          alignmentMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    skipRootMotionMontage                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    hardAbortExistingAlignment                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  targetSceneComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::AlignWithDuration_Replicated(const struct FVector& targetLocation, const struct FRotator& targetRotation, EAlignmentMode alignmentMode, float Duration, bool skipRootMotionMontage, bool hardAbortExistingAlignment, class USceneComponent* targetSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AlignWithDuration_Replicated");

	Params::EverholmCharacter_AlignWithDuration_Replicated Parms{};

	Parms.targetLocation = std::move(targetLocation);
	Parms.targetRotation = std::move(targetRotation);
	Parms.alignmentMode = alignmentMode;
	Parms.Duration = Duration;
	Parms.skipRootMotionMontage = skipRootMotionMontage;
	Parms.hardAbortExistingAlignment = hardAbortExistingAlignment;
	Parms.targetSceneComponent = targetSceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AlignWithSpeed
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  targetRotation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EAlignmentMode                          alignmentMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    skipRootMotionMontage                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    hardAbortExistingAlignment                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  targetSceneComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::AlignWithSpeed(const struct FVector& targetLocation, const struct FRotator& targetRotation, EAlignmentMode alignmentMode, float Speed, bool skipRootMotionMontage, bool hardAbortExistingAlignment, class USceneComponent* targetSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AlignWithSpeed");

	Params::EverholmCharacter_AlignWithSpeed Parms{};

	Parms.targetLocation = std::move(targetLocation);
	Parms.targetRotation = std::move(targetRotation);
	Parms.alignmentMode = alignmentMode;
	Parms.Speed = Speed;
	Parms.skipRootMotionMontage = skipRootMotionMontage;
	Parms.hardAbortExistingAlignment = hardAbortExistingAlignment;
	Parms.targetSceneComponent = targetSceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.AlignWithSpeed_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  targetRotation                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EAlignmentMode                          alignmentMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    skipRootMotionMontage                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    hardAbortExistingAlignment                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  targetSceneComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::AlignWithSpeed_Multicast(const struct FVector& targetLocation, const struct FRotator& targetRotation, EAlignmentMode alignmentMode, float Speed, bool skipRootMotionMontage, bool hardAbortExistingAlignment, class USceneComponent* targetSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AlignWithSpeed_Multicast");

	Params::EverholmCharacter_AlignWithSpeed_Multicast Parms{};

	Parms.targetLocation = std::move(targetLocation);
	Parms.targetRotation = std::move(targetRotation);
	Parms.alignmentMode = alignmentMode;
	Parms.Speed = Speed;
	Parms.skipRootMotionMontage = skipRootMotionMontage;
	Parms.hardAbortExistingAlignment = hardAbortExistingAlignment;
	Parms.targetSceneComponent = targetSceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AlignWithSpeed_Replicated
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  targetRotation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EAlignmentMode                          alignmentMode                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Speed                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    skipRootMotionMontage                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    hardAbortExistingAlignment                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  targetSceneComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::AlignWithSpeed_Replicated(const struct FVector& targetLocation, const struct FRotator& targetRotation, EAlignmentMode alignmentMode, float Speed, bool skipRootMotionMontage, bool hardAbortExistingAlignment, class USceneComponent* targetSceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AlignWithSpeed_Replicated");

	Params::EverholmCharacter_AlignWithSpeed_Replicated Parms{};

	Parms.targetLocation = std::move(targetLocation);
	Parms.targetRotation = std::move(targetRotation);
	Parms.alignmentMode = alignmentMode;
	Parms.Speed = Speed;
	Parms.skipRootMotionMontage = skipRootMotionMontage;
	Parms.hardAbortExistingAlignment = hardAbortExistingAlignment;
	Parms.targetSceneComponent = targetSceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AlignWithSpeed_Server
// (Net, NetReliable, Native, Event, Public, NetServer)

void AEverholmCharacter::AlignWithSpeed_Server()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AlignWithSpeed_Server");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.ApplyLocomotionProfile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    profileInstigator                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class ULocomotionProfileAsset*    locomotionProfile                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseTransition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAbstractEnum&             TransitionSlot                                         (ConstParm, Parm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             transitionPlayRate                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             transitionStartingPosition                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       transitionStartingSection                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::ApplyLocomotionProfile(const class UObject* profileInstigator, const class ULocomotionProfileAsset* locomotionProfile, bool bUseTransition, const struct FAbstractEnum& TransitionSlot, const float transitionPlayRate, const float transitionStartingPosition, const class FName transitionStartingSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "ApplyLocomotionProfile");

	Params::EverholmCharacter_ApplyLocomotionProfile Parms{};

	Parms.profileInstigator = profileInstigator;
	Parms.locomotionProfile = locomotionProfile;
	Parms.bUseTransition = bUseTransition;
	Parms.TransitionSlot = std::move(TransitionSlot);
	Parms.transitionPlayRate = transitionPlayRate;
	Parms.transitionStartingPosition = transitionStartingPosition;
	Parms.transitionStartingSection = transitionStartingSection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.ApplyLocomotionProfileForDuration
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    profileInstigator                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class ULocomotionProfileAsset*    locomotionProfile                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseInTransition                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAbstractEnum&             inTransitionSlot                                       (ConstParm, Parm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             inTransitionPlayRate                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             inTransitionStartingPosition                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       inTransitionStartingSection                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseOutTransition                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAbstractEnum&             outTransitionSlot                                      (ConstParm, Parm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             outTransitionPlayRate                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             outTransitionStartingPosition                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       outTransitionStartingSection                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::ApplyLocomotionProfileForDuration(const class UObject* profileInstigator, const class ULocomotionProfileAsset* locomotionProfile, float Duration, bool bUseInTransition, const struct FAbstractEnum& inTransitionSlot, const float inTransitionPlayRate, const float inTransitionStartingPosition, const class FName inTransitionStartingSection, bool bUseOutTransition, const struct FAbstractEnum& outTransitionSlot, const float outTransitionPlayRate, const float outTransitionStartingPosition, const class FName outTransitionStartingSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "ApplyLocomotionProfileForDuration");

	Params::EverholmCharacter_ApplyLocomotionProfileForDuration Parms{};

	Parms.profileInstigator = profileInstigator;
	Parms.locomotionProfile = locomotionProfile;
	Parms.Duration = Duration;
	Parms.bUseInTransition = bUseInTransition;
	Parms.inTransitionSlot = std::move(inTransitionSlot);
	Parms.inTransitionPlayRate = inTransitionPlayRate;
	Parms.inTransitionStartingPosition = inTransitionStartingPosition;
	Parms.inTransitionStartingSection = inTransitionStartingSection;
	Parms.bUseOutTransition = bUseOutTransition;
	Parms.outTransitionSlot = std::move(outTransitionSlot);
	Parms.outTransitionPlayRate = outTransitionPlayRate;
	Parms.outTransitionStartingPosition = outTransitionStartingPosition;
	Parms.outTransitionStartingSection = outTransitionStartingSection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AttachToActor_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// const class AActor*                     ParentActor                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      SocketName                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantize100&    attachLocationOffset                                   (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  attachRotatorOffset                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              bImpartVelocity                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDisableCharacterInstructions                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDisableInstructionsRequest&DisableInstructionsRequest                             (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::AttachToActor_Multicast(const class AActor* ParentActor, const class FName& SocketName, const struct FVector_NetQuantize100& attachLocationOffset, const struct FRotator& attachRotatorOffset, const bool bImpartVelocity, const bool bDisableCharacterInstructions, const struct FDisableInstructionsRequest& DisableInstructionsRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AttachToActor_Multicast");

	Params::EverholmCharacter_AttachToActor_Multicast Parms{};

	Parms.ParentActor = ParentActor;
	Parms.SocketName = SocketName;
	Parms.attachLocationOffset = std::move(attachLocationOffset);
	Parms.attachRotatorOffset = std::move(attachRotatorOffset);
	Parms.bImpartVelocity = bImpartVelocity;
	Parms.bDisableCharacterInstructions = bDisableCharacterInstructions;
	Parms.DisableInstructionsRequest = std::move(DisableInstructionsRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AttachToActor_Replicated
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           ParentActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       SocketName                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   attachLocationOffset                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  attachRotatorOffset                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              bImpartVelocity                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDisableCharacterInstructions                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDisableInstructionsRequest&DisableInstructionsRequest                             (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::AttachToActor_Replicated(class AActor* ParentActor, const class FName SocketName, const struct FVector& attachLocationOffset, const struct FRotator& attachRotatorOffset, const bool bImpartVelocity, const bool bDisableCharacterInstructions, const struct FDisableInstructionsRequest& DisableInstructionsRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AttachToActor_Replicated");

	Params::EverholmCharacter_AttachToActor_Replicated Parms{};

	Parms.ParentActor = ParentActor;
	Parms.SocketName = SocketName;
	Parms.attachLocationOffset = std::move(attachLocationOffset);
	Parms.attachRotatorOffset = std::move(attachRotatorOffset);
	Parms.bImpartVelocity = bImpartVelocity;
	Parms.bDisableCharacterInstructions = bDisableCharacterInstructions;
	Parms.DisableInstructionsRequest = std::move(DisableInstructionsRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AttachToActor_Server
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults)
// Parameters:
// class AActor*                           ParentActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      SocketName                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantize100&    attachLocationOffset                                   (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  attachRotatorOffset                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              bImpartVelocity                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDisableCharacterInstructions                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDisableInstructionsRequest&DisableInstructionsRequest                             (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::AttachToActor_Server(class AActor* ParentActor, const class FName& SocketName, const struct FVector_NetQuantize100& attachLocationOffset, const struct FRotator& attachRotatorOffset, const bool bImpartVelocity, const bool bDisableCharacterInstructions, const struct FDisableInstructionsRequest& DisableInstructionsRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AttachToActor_Server");

	Params::EverholmCharacter_AttachToActor_Server Parms{};

	Parms.ParentActor = ParentActor;
	Parms.SocketName = SocketName;
	Parms.attachLocationOffset = std::move(attachLocationOffset);
	Parms.attachRotatorOffset = std::move(attachRotatorOffset);
	Parms.bImpartVelocity = bImpartVelocity;
	Parms.bDisableCharacterInstructions = bDisableCharacterInstructions;
	Parms.DisableInstructionsRequest = std::move(DisableInstructionsRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AttachToComponent_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              AttachComponent                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      SocketName                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationOffset                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  RotationOffset                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              bImpartVelocity                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDisableCharacterInstructions                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDisableInstructionsRequest&DisableInstructionsRequest                             (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::AttachToComponent_Multicast(class UPrimitiveComponent* AttachComponent, const class FName& SocketName, const struct FVector& LocationOffset, const struct FRotator& RotationOffset, const bool bImpartVelocity, const bool bDisableCharacterInstructions, const struct FDisableInstructionsRequest& DisableInstructionsRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AttachToComponent_Multicast");

	Params::EverholmCharacter_AttachToComponent_Multicast Parms{};

	Parms.AttachComponent = AttachComponent;
	Parms.SocketName = SocketName;
	Parms.LocationOffset = std::move(LocationOffset);
	Parms.RotationOffset = std::move(RotationOffset);
	Parms.bImpartVelocity = bImpartVelocity;
	Parms.bDisableCharacterInstructions = bDisableCharacterInstructions;
	Parms.DisableInstructionsRequest = std::move(DisableInstructionsRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AttachToComponent_Replicated
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              AttachComponent                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       SocketName                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationOffset                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  RotationOffset                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              bImpartVelocity                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDisableCharacterInstructions                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDisableInstructionsRequest&DisableInstructionsRequest                             (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::AttachToComponent_Replicated(class UPrimitiveComponent* AttachComponent, const class FName SocketName, const struct FVector& LocationOffset, const struct FRotator& RotationOffset, const bool bImpartVelocity, const bool bDisableCharacterInstructions, const struct FDisableInstructionsRequest& DisableInstructionsRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AttachToComponent_Replicated");

	Params::EverholmCharacter_AttachToComponent_Replicated Parms{};

	Parms.AttachComponent = AttachComponent;
	Parms.SocketName = SocketName;
	Parms.LocationOffset = std::move(LocationOffset);
	Parms.RotationOffset = std::move(RotationOffset);
	Parms.bImpartVelocity = bImpartVelocity;
	Parms.bDisableCharacterInstructions = bDisableCharacterInstructions;
	Parms.DisableInstructionsRequest = std::move(DisableInstructionsRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.AttachToComponent_Server
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              AttachComponent                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      SocketName                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationOffset                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  RotationOffset                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              bImpartVelocity                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDisableCharacterInstructions                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDisableInstructionsRequest&DisableInstructionsRequest                             (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::AttachToComponent_Server(class UPrimitiveComponent* AttachComponent, const class FName& SocketName, const struct FVector& LocationOffset, const struct FRotator& RotationOffset, const bool bImpartVelocity, const bool bDisableCharacterInstructions, const struct FDisableInstructionsRequest& DisableInstructionsRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "AttachToComponent_Server");

	Params::EverholmCharacter_AttachToComponent_Server Parms{};

	Parms.AttachComponent = AttachComponent;
	Parms.SocketName = SocketName;
	Parms.LocationOffset = std::move(LocationOffset);
	Parms.RotationOffset = std::move(RotationOffset);
	Parms.bImpartVelocity = bImpartVelocity;
	Parms.bDisableCharacterInstructions = bDisableCharacterInstructions;
	Parms.DisableInstructionsRequest = std::move(DisableInstructionsRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.BP_KeepCharacterUpright
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::BP_KeepCharacterUpright(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "BP_KeepCharacterUpright");

	Params::EverholmCharacter_BP_KeepCharacterUpright Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.BP_ProcessDesiredMovement
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   desiredMovement                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEverholmCharacter::BP_ProcessDesiredMovement(const struct FVector& desiredMovement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "BP_ProcessDesiredMovement");

	Params::EverholmCharacter_BP_ProcessDesiredMovement Parms{};

	Parms.desiredMovement = std::move(desiredMovement);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.BP_SpawnCoopPlayer
// (Event, Protected, BlueprintEvent)

void AEverholmCharacter::BP_SpawnCoopPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "BP_SpawnCoopPlayer");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmCharacter.ClearPindown_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const class AActor*                     attacker                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UAbilityObject>       pindownAbility                                         (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::ClearPindown_Multicast(const class AActor* attacker, TSubclassOf<class UAbilityObject> pindownAbility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "ClearPindown_Multicast");

	Params::EverholmCharacter_ClearPindown_Multicast Parms{};

	Parms.attacker = attacker;
	Parms.pindownAbility = pindownAbility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.ClearPindown_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const class AActor*                     attacker                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UAbilityObject>       pindownAbility                                         (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::ClearPindown_Server(const class AActor* attacker, TSubclassOf<class UAbilityObject> pindownAbility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "ClearPindown_Server");

	Params::EverholmCharacter_ClearPindown_Server Parms{};

	Parms.attacker = attacker;
	Parms.pindownAbility = pindownAbility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.Client_CollectMask
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const class FString&                    maskName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::Client_CollectMask(const class FString& maskName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "Client_CollectMask");

	Params::EverholmCharacter_Client_CollectMask Parms{};

	Parms.maskName = std::move(maskName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.DetachFromBase_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void AEverholmCharacter::DetachFromBase_Multicast()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "DetachFromBase_Multicast");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.DetachFromBase_Replicated
// (Final, Native, Public, BlueprintCallable)

void AEverholmCharacter::DetachFromBase_Replicated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "DetachFromBase_Replicated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.DetachFromBase_Server
// (Net, NetReliable, Native, Event, Public, NetServer)

void AEverholmCharacter::DetachFromBase_Server()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "DetachFromBase_Server");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageJumpToSection_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageJumpToSection_Multicast(class FName SectionName, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageJumpToSection_Multicast");

	Params::EverholmCharacter_MontageJumpToSection_Multicast Parms{};

	Parms.SectionName = SectionName;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageJumpToSection_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageJumpToSection_Replicated(class FName SectionName, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageJumpToSection_Replicated");

	Params::EverholmCharacter_MontageJumpToSection_Replicated Parms{};

	Parms.SectionName = SectionName;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageJumpToSection_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageJumpToSection_Server(class FName SectionName, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageJumpToSection_Server");

	Params::EverholmCharacter_MontageJumpToSection_Server Parms{};

	Parms.SectionName = SectionName;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageJumpToSectionsEnd_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageJumpToSectionsEnd_Multicast(class FName SectionName, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageJumpToSectionsEnd_Multicast");

	Params::EverholmCharacter_MontageJumpToSectionsEnd_Multicast Parms{};

	Parms.SectionName = SectionName;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageJumpToSectionsEnd_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageJumpToSectionsEnd_Replicated(class FName SectionName, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageJumpToSectionsEnd_Replicated");

	Params::EverholmCharacter_MontageJumpToSectionsEnd_Replicated Parms{};

	Parms.SectionName = SectionName;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageJumpToSectionsEnd_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageJumpToSectionsEnd_Server(class FName SectionName, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageJumpToSectionsEnd_Server");

	Params::EverholmCharacter_MontageJumpToSectionsEnd_Server Parms{};

	Parms.SectionName = SectionName;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageSetNextSection_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class FName                             SectionNameToChange                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NextSection                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageSetNextSection_Multicast(class FName SectionNameToChange, class FName NextSection, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageSetNextSection_Multicast");

	Params::EverholmCharacter_MontageSetNextSection_Multicast Parms{};

	Parms.SectionNameToChange = SectionNameToChange;
	Parms.NextSection = NextSection;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageSetNextSection_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SectionNameToChange                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NextSection                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageSetNextSection_Replicated(class FName SectionNameToChange, class FName NextSection, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageSetNextSection_Replicated");

	Params::EverholmCharacter_MontageSetNextSection_Replicated Parms{};

	Parms.SectionNameToChange = SectionNameToChange;
	Parms.NextSection = NextSection;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageSetNextSection_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// class FName                             SectionNameToChange                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NextSection                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageSetNextSection_Server(class FName SectionNameToChange, class FName NextSection, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageSetNextSection_Server");

	Params::EverholmCharacter_MontageSetNextSection_Server Parms{};

	Parms.SectionNameToChange = SectionNameToChange;
	Parms.NextSection = NextSection;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageSetPosition_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// float                                   montageTimePosition                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageSetPosition_Multicast(float montageTimePosition, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageSetPosition_Multicast");

	Params::EverholmCharacter_MontageSetPosition_Multicast Parms{};

	Parms.montageTimePosition = montageTimePosition;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageSetPosition_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   montageTimePosition                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageSetPosition_Replicated(float montageTimePosition, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageSetPosition_Replicated");

	Params::EverholmCharacter_MontageSetPosition_Replicated Parms{};

	Parms.montageTimePosition = montageTimePosition;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.MontageSetPosition_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// float                                   montageTimePosition                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAnimMontage*               AnimMontage                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::MontageSetPosition_Server(float montageTimePosition, const class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "MontageSetPosition_Server");

	Params::EverholmCharacter_MontageSetPosition_Server Parms{};

	Parms.montageTimePosition = montageTimePosition;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.Multicast_ApplyReplicatedDamage
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const struct FPointDamageEvent&         DamageEvent                                            (ConstParm, Parm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::Multicast_ApplyReplicatedDamage(const struct FPointDamageEvent& DamageEvent, class AActor* DamagedActor, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "Multicast_ApplyReplicatedDamage");

	Params::EverholmCharacter_Multicast_ApplyReplicatedDamage Parms{};

	Parms.DamageEvent = std::move(DamageEvent);
	Parms.DamagedActor = DamagedActor;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnHibernationChanged
// (Native, Event, Protected, BlueprintEvent)

void AEverholmCharacter::OnHibernationChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnHibernationChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnPlayerSwapped
// (Native, Event, Public, BlueprintEvent)

void AEverholmCharacter::OnPlayerSwapped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnPlayerSwapped");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnRep_AIRubberBandingMontageData
// (Final, Native, Protected)

void AEverholmCharacter::OnRep_AIRubberBandingMontageData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnRep_AIRubberBandingMontageData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnRep_CollisionEnabled
// (Native, Protected)

void AEverholmCharacter::OnRep_CollisionEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnRep_CollisionEnabled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnRep_Hibernating
// (Final, Native, Protected)

void AEverholmCharacter::OnRep_Hibernating()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnRep_Hibernating");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnRep_Sprinting
// (Native, Protected)

void AEverholmCharacter::OnRep_Sprinting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnRep_Sprinting");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnTargetLevelsStreamedIn_Client
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void AEverholmCharacter::OnTargetLevelsStreamedIn_Client()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnTargetLevelsStreamedIn_Client");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.OnTeleportSuccess_Client
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class AEverholmCharacter*               teleportedCharacter                                    (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::OnTeleportSuccess_Client(class AEverholmCharacter* teleportedCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "OnTeleportSuccess_Client");

	Params::EverholmCharacter_OnTeleportSuccess_Client Parms{};

	Parms.teleportedCharacter = teleportedCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.PlayAnimMontage_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InPlayRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartSectionName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::PlayAnimMontage_Multicast(class UAnimMontage* AnimMontage, float InPlayRate, class FName StartSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "PlayAnimMontage_Multicast");

	Params::EverholmCharacter_PlayAnimMontage_Multicast Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.InPlayRate = InPlayRate;
	Parms.StartSectionName = StartSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.PlayAnimMontage_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InPlayRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartSectionName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::PlayAnimMontage_Replicated(class UAnimMontage* AnimMontage, float InPlayRate, class FName StartSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "PlayAnimMontage_Replicated");

	Params::EverholmCharacter_PlayAnimMontage_Replicated Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.InPlayRate = InPlayRate;
	Parms.StartSectionName = StartSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.PlayAnimMontage_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InPlayRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartSectionName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::PlayAnimMontage_Server(class UAnimMontage* AnimMontage, float InPlayRate, class FName StartSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "PlayAnimMontage_Server");

	Params::EverholmCharacter_PlayAnimMontage_Server Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.InPlayRate = InPlayRate;
	Parms.StartSectionName = StartSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.RemoveAllLocomotionProfiles
// (Final, Native, Public, BlueprintCallable)

void AEverholmCharacter::RemoveAllLocomotionProfiles()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "RemoveAllLocomotionProfiles");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.RemoveLocomotionProfile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    profileInstigator                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseTransition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAbstractEnum&             TransitionSlot                                         (ConstParm, Parm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             transitionPlayRate                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             transitionStartingPosition                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       transitionStartingSection                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::RemoveLocomotionProfile(const class UObject* profileInstigator, bool bUseTransition, const struct FAbstractEnum& TransitionSlot, const float transitionPlayRate, const float transitionStartingPosition, const class FName transitionStartingSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "RemoveLocomotionProfile");

	Params::EverholmCharacter_RemoveLocomotionProfile Parms{};

	Parms.profileInstigator = profileInstigator;
	Parms.bUseTransition = bUseTransition;
	Parms.TransitionSlot = std::move(TransitionSlot);
	Parms.transitionPlayRate = transitionPlayRate;
	Parms.transitionStartingPosition = transitionStartingPosition;
	Parms.transitionStartingSection = transitionStartingSection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.RemoveLocomotionProfiles
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class ULocomotionProfileAsset*    locomotionProfile                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::RemoveLocomotionProfiles(const class ULocomotionProfileAsset* locomotionProfile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "RemoveLocomotionProfiles");

	Params::EverholmCharacter_RemoveLocomotionProfiles Parms{};

	Parms.locomotionProfile = locomotionProfile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.RemoveLooseGameplayActivationTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   instigatorObject                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              tagToRemove                                            (ConstParm, Parm, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::RemoveLooseGameplayActivationTag(const class UObject*& instigatorObject, const struct FGameplayTag& tagToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "RemoveLooseGameplayActivationTag");

	Params::EverholmCharacter_RemoveLooseGameplayActivationTag Parms{};

	Parms.instigatorObject = instigatorObject;
	Parms.tagToRemove = std::move(tagToRemove);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.RemoveLooseGameplayActivationTags
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   instigatorObject                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     tagsToRemove                                           (ConstParm, Parm, AdvancedDisplay, NativeAccessSpecifierPublic)

void AEverholmCharacter::RemoveLooseGameplayActivationTags(const class UObject*& instigatorObject, const struct FGameplayTagContainer& tagsToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "RemoveLooseGameplayActivationTags");

	Params::EverholmCharacter_RemoveLooseGameplayActivationTags Parms{};

	Parms.instigatorObject = instigatorObject;
	Parms.tagsToRemove = std::move(tagsToRemove);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.ResolveAttack_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FAttackData&               AttackData                                             (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::ResolveAttack_Server(const struct FAttackData& AttackData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "ResolveAttack_Server");

	Params::EverholmCharacter_ResolveAttack_Server Parms{};

	Parms.AttackData = std::move(AttackData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.ResolvePindown_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const struct FAttackData&               AttackData                                             (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class UAbilityObject>       pinnedDownAbility                                      (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              pinnedDownGameplayTag                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::ResolvePindown_Multicast(const struct FAttackData& AttackData, TSubclassOf<class UAbilityObject> pinnedDownAbility, const struct FGameplayTag& pinnedDownGameplayTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "ResolvePindown_Multicast");

	Params::EverholmCharacter_ResolvePindown_Multicast Parms{};

	Parms.AttackData = std::move(AttackData);
	Parms.pinnedDownAbility = pinnedDownAbility;
	Parms.pinnedDownGameplayTag = std::move(pinnedDownGameplayTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.ResolvePindown_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FAttackData&               AttackData                                             (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class UAbilityObject>       pinnedDownAbility                                      (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              pinnedDownGameplayTag                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::ResolvePindown_Server(const struct FAttackData& AttackData, TSubclassOf<class UAbilityObject> pinnedDownAbility, const struct FGameplayTag& pinnedDownGameplayTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "ResolvePindown_Server");

	Params::EverholmCharacter_ResolvePindown_Server Parms{};

	Parms.AttackData = std::move(AttackData);
	Parms.pinnedDownAbility = pinnedDownAbility;
	Parms.pinnedDownGameplayTag = std::move(pinnedDownGameplayTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.Server_ApplyReplicatedDamage
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FPointDamageEvent&         DamageEvent                                            (ConstParm, Parm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::Server_ApplyReplicatedDamage(const struct FPointDamageEvent& DamageEvent, class AActor* DamagedActor, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "Server_ApplyReplicatedDamage");

	Params::EverholmCharacter_Server_ApplyReplicatedDamage Parms{};

	Parms.DamageEvent = std::move(DamageEvent);
	Parms.DamagedActor = DamagedActor;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.SetCollisionEnabled_Server
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::SetCollisionEnabled_Server(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "SetCollisionEnabled_Server");

	Params::EverholmCharacter_SetCollisionEnabled_Server Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.SetCrouchIntent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ShouldHaveCrouchIntent                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::SetCrouchIntent(bool ShouldHaveCrouchIntent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "SetCrouchIntent");

	Params::EverholmCharacter_SetCrouchIntent Parms{};

	Parms.ShouldHaveCrouchIntent = ShouldHaveCrouchIntent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.SetHibernating
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    hibernating                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::SetHibernating(bool hibernating)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "SetHibernating");

	Params::EverholmCharacter_SetHibernating Parms{};

	Parms.hibernating = hibernating;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.SetMovementInputSpace
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EMovementInputSpace                     newMovementInputSpace                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::SetMovementInputSpace(EMovementInputSpace newMovementInputSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "SetMovementInputSpace");

	Params::EverholmCharacter_SetMovementInputSpace Parms{};

	Parms.newMovementInputSpace = newMovementInputSpace;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.SetPlayerVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::SetPlayerVisibility(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "SetPlayerVisibility");

	Params::EverholmCharacter_SetPlayerVisibility Parms{};

	Parms.bVisible = bVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.SetSprinting
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ShouldSprint                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::SetSprinting(bool ShouldSprint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "SetSprinting");

	Params::EverholmCharacter_SetSprinting Parms{};

	Parms.ShouldSprint = ShouldSprint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.SetWalkIntent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ShouldHaveWalkIntent                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::SetWalkIntent(bool ShouldHaveWalkIntent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "SetWalkIntent");

	Params::EverholmCharacter_SetWalkIntent Parms{};

	Parms.ShouldHaveWalkIntent = ShouldHaveWalkIntent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.StopAnimMontage_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::StopAnimMontage_Multicast(class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "StopAnimMontage_Multicast");

	Params::EverholmCharacter_StopAnimMontage_Multicast Parms{};

	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.StopAnimMontage_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::StopAnimMontage_Replicated(class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "StopAnimMontage_Replicated");

	Params::EverholmCharacter_StopAnimMontage_Replicated Parms{};

	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.StopAnimMontage_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::StopAnimMontage_Server(class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "StopAnimMontage_Server");

	Params::EverholmCharacter_StopAnimMontage_Server Parms{};

	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.StopPindown_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const class AActor*                     attacker                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              pinnedDownGameplayTag                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::StopPindown_Multicast(const class AActor* attacker, const struct FGameplayTag& pinnedDownGameplayTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "StopPindown_Multicast");

	Params::EverholmCharacter_StopPindown_Multicast Parms{};

	Parms.attacker = attacker;
	Parms.pinnedDownGameplayTag = std::move(pinnedDownGameplayTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.StopPindown_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const class AActor*                     attacker                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              pinnedDownGameplayTag                                  (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::StopPindown_Server(const class AActor* attacker, const struct FGameplayTag& pinnedDownGameplayTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "StopPindown_Server");

	Params::EverholmCharacter_StopPindown_Server Parms{};

	Parms.attacker = attacker;
	Parms.pinnedDownGameplayTag = std::move(pinnedDownGameplayTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.TeleportTo_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FTransformNoScale&         Target                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter::TeleportTo_Server(const struct FTransformNoScale& Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "TeleportTo_Server");

	Params::EverholmCharacter_TeleportTo_Server Parms{};

	Parms.Target = std::move(Target);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.TriggerAnimInstanceEvent_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  FloatParam                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   IntParam                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    boolParam                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::TriggerAnimInstanceEvent_Multicast(class FName EventName, double FloatParam, int32 IntParam, bool boolParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "TriggerAnimInstanceEvent_Multicast");

	Params::EverholmCharacter_TriggerAnimInstanceEvent_Multicast Parms{};

	Parms.EventName = EventName;
	Parms.FloatParam = FloatParam;
	Parms.IntParam = IntParam;
	Parms.boolParam = boolParam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.TriggerAnimInstanceEvent_Replicated
// (Native, Public, BlueprintCallable)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  FloatParam                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   IntParam                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    boolParam                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::TriggerAnimInstanceEvent_Replicated(class FName EventName, double FloatParam, int32 IntParam, bool boolParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "TriggerAnimInstanceEvent_Replicated");

	Params::EverholmCharacter_TriggerAnimInstanceEvent_Replicated Parms{};

	Parms.EventName = EventName;
	Parms.FloatParam = FloatParam;
	Parms.IntParam = IntParam;
	Parms.boolParam = boolParam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.TriggerAnimInstanceEvent_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// double                                  FloatParam                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   IntParam                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    boolParam                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter::TriggerAnimInstanceEvent_Server(class FName EventName, double FloatParam, int32 IntParam, bool boolParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "TriggerAnimInstanceEvent_Server");

	Params::EverholmCharacter_TriggerAnimInstanceEvent_Server Parms{};

	Parms.EventName = EventName;
	Parms.FloatParam = FloatParam;
	Parms.IntParam = IntParam;
	Parms.boolParam = boolParam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter.GetAbilityActivationComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAbilityActivationComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityActivationComponent* AEverholmCharacter::GetAbilityActivationComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetAbilityActivationComponent");

	Params::EverholmCharacter_GetAbilityActivationComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetAnimationOverrideComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimationOverrideComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimationOverrideComponent* AEverholmCharacter::GetAnimationOverrideComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetAnimationOverrideComponent");

	Params::EverholmCharacter_GetAnimationOverrideComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetCallComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmCallComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmCallComponent* AEverholmCharacter::GetCallComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetCallComponent");

	Params::EverholmCharacter_GetCallComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetCameraOrientedCharacterForward
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEverholmCharacter::GetCameraOrientedCharacterForward() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetCameraOrientedCharacterForward");

	Params::EverholmCharacter_GetCameraOrientedCharacterForward Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetCameraOrientedCharacterRight
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AEverholmCharacter::GetCameraOrientedCharacterRight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetCameraOrientedCharacterRight");

	Params::EverholmCharacter_GetCameraOrientedCharacterRight Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetCharacterChalkboard
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UChalkboardWrapper*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UChalkboardWrapper* AEverholmCharacter::GetCharacterChalkboard() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetCharacterChalkboard");

	Params::EverholmCharacter_GetCharacterChalkboard Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetCharacterInstructions
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UCharacterInstructionsComponent*  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UCharacterInstructionsComponent* AEverholmCharacter::GetCharacterInstructions() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetCharacterInstructions");

	Params::EverholmCharacter_GetCharacterInstructions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetClimbingComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UClimbingComponent*               ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UClimbingComponent* AEverholmCharacter::GetClimbingComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetClimbingComponent");

	Params::EverholmCharacter_GetClimbingComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetEverholmCharacterMovement
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmCharacterMovementComponent*ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmCharacterMovementComponent* AEverholmCharacter::GetEverholmCharacterMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetEverholmCharacterMovement");

	Params::EverholmCharacter_GetEverholmCharacterMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetHasCrouchIntent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::GetHasCrouchIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetHasCrouchIntent");

	Params::EverholmCharacter_GetHasCrouchIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetHasWalkIntent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::GetHasWalkIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetHasWalkIntent");

	Params::EverholmCharacter_GetHasWalkIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetIsSprinting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::GetIsSprinting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetIsSprinting");

	Params::EverholmCharacter_GetIsSprinting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetMotionWarpingComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMotionWarpingComponent*          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMotionWarpingComponent* AEverholmCharacter::GetMotionWarpingComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetMotionWarpingComponent");

	Params::EverholmCharacter_GetMotionWarpingComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetMovementInputSpace
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EMovementInputSpace                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMovementInputSpace AEverholmCharacter::GetMovementInputSpace() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetMovementInputSpace");

	Params::EverholmCharacter_GetMovementInputSpace Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.GetVehicleControlComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UVehicleControlComponent*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UVehicleControlComponent* AEverholmCharacter::GetVehicleControlComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "GetVehicleControlComponent");

	Params::EverholmCharacter_GetVehicleControlComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.IsAIControlled
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::IsAIControlled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "IsAIControlled");

	Params::EverholmCharacter_IsAIControlled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.IsAlive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::IsAlive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "IsAlive");

	Params::EverholmCharacter_IsAlive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.IsBeingPinnedDown
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::IsBeingPinnedDown() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "IsBeingPinnedDown");

	Params::EverholmCharacter_IsBeingPinnedDown Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.IsHibernating
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::IsHibernating() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "IsHibernating");

	Params::EverholmCharacter_IsHibernating Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.IsInvulnerableToEnemyAttacks
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::IsInvulnerableToEnemyAttacks() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "IsInvulnerableToEnemyAttacks");

	Params::EverholmCharacter_IsInvulnerableToEnemyAttacks Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter.IsLocalCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter::IsLocalCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter", "IsLocalCharacter");

	Params::EverholmCharacter_IsLocalCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_BrookHorse.LerpToTarget
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               alignmentTarget                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Duration                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AlignmentLocationOffset                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  alignmentRotationOffset                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmCharacter_BrookHorse::LerpToTarget(class AEverholmCharacter* alignmentTarget, const float Duration, const struct FVector& AlignmentLocationOffset, const struct FRotator& alignmentRotationOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_BrookHorse", "LerpToTarget");

	Params::EverholmCharacter_BrookHorse_LerpToTarget Parms{};

	Parms.alignmentTarget = alignmentTarget;
	Parms.Duration = Duration;
	Parms.AlignmentLocationOffset = std::move(AlignmentLocationOffset);
	Parms.alignmentRotationOffset = std::move(alignmentRotationOffset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_BrookHorse.OnRep_CurrentState
// (Final, Native, Protected)

void AEverholmCharacter_BrookHorse::OnRep_CurrentState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_BrookHorse", "OnRep_CurrentState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_BrookHorse.OnStateEntered
// (Event, Public, BlueprintEvent)
// Parameters:
// const EBrookHorseStates                 previousState                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EBrookHorseStates                 NewState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_BrookHorse::OnStateEntered(const EBrookHorseStates previousState, const EBrookHorseStates NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_BrookHorse", "OnStateEntered");

	Params::EverholmCharacter_BrookHorse_OnStateEntered Parms{};

	Parms.previousState = previousState;
	Parms.NewState = NewState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmCharacter_BrookHorse.SetState
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const EBrookHorseStates                 NewState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_BrookHorse::SetState(const EBrookHorseStates NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_BrookHorse", "SetState");

	Params::EverholmCharacter_BrookHorse_SetState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.OverlappingPieChartLightComponent.SetPieChartAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             Angle                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UOverlappingPieChartLightComponent::SetPieChartAngle(const float Angle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OverlappingPieChartLightComponent", "SetPieChartAngle");

	Params::OverlappingPieChartLightComponent_SetPieChartAngle Parms{};

	Parms.Angle = Angle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ChaosProxyVehicleMovementComponent.GetCurrentSteeringAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   wheel                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChaosProxyVehicleMovementComponent::GetCurrentSteeringAngle(int32 wheel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosProxyVehicleMovementComponent", "GetCurrentSteeringAngle");

	Params::ChaosProxyVehicleMovementComponent_GetCurrentSteeringAngle Parms{};

	Parms.wheel = wheel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChaosProxyVehicleMovementComponent.GetMaxSteeringAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   wheel                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChaosProxyVehicleMovementComponent::GetMaxSteeringAngle(int32 wheel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosProxyVehicleMovementComponent", "GetMaxSteeringAngle");

	Params::ChaosProxyVehicleMovementComponent_GetMaxSteeringAngle Parms{};

	Parms.wheel = wheel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChaosProxyVehicleMovementComponent.GetSuspensionLimits
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   wheel                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFloatInterval                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FFloatInterval UChaosProxyVehicleMovementComponent::GetSuspensionLimits(int32 wheel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosProxyVehicleMovementComponent", "GetSuspensionLimits");

	Params::ChaosProxyVehicleMovementComponent_GetSuspensionLimits Parms{};

	Parms.wheel = wheel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SmoothRepSceneComponent.ClientSideShutdown
// (Final, Native, Public, BlueprintCallable)

void USmoothRepSceneComponent::ClientSideShutdown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothRepSceneComponent", "ClientSideShutdown");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothRepSceneComponent.MC_ServerFrame
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FSmoothRepSceneComponentState&State                                                  (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void USmoothRepSceneComponent::MC_ServerFrame(const struct FSmoothRepSceneComponentState& State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothRepSceneComponent", "MC_ServerFrame");

	Params::SmoothRepSceneComponent_MC_ServerFrame Parms{};

	Parms.State = std::move(State);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothRepSceneComponent.OnRestartReplication
// (Final, Native, Public, BlueprintCallable)

void USmoothRepSceneComponent::OnRestartReplication()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothRepSceneComponent", "OnRestartReplication");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothRepSceneComponent.OnStopReplication
// (Final, Native, Public, BlueprintCallable)

void USmoothRepSceneComponent::OnStopReplication()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothRepSceneComponent", "OnStopReplication");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothRepSceneComponent.SetUpdatedComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*                  Component                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USmoothRepSceneComponent::SetUpdatedComponent(class USceneComponent* Component)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothRepSceneComponent", "SetUpdatedComponent");

	Params::SmoothRepSceneComponent_SetUpdatedComponent Parms{};

	Parms.Component = Component;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothRepSceneComponent.GetServerHistoryInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  Size                                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  timeAvail                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USmoothRepSceneComponent::GetServerHistoryInfo(int32* Size, float* timeAvail) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothRepSceneComponent", "GetServerHistoryInfo");

	Params::SmoothRepSceneComponent_GetServerHistoryInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Size != nullptr)
		*Size = Parms.Size;

	if (timeAvail != nullptr)
		*timeAvail = Parms.timeAvail;
}


// Function Everholm.RadioTargetComponent.Disable
// (Final, Native, Public, BlueprintCallable)

void URadioTargetComponent::Disable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "Disable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.Enable
// (Final, Native, Public, BlueprintCallable)

void URadioTargetComponent::Enable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "Enable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.ForceRegister
// (Final, Native, Public, BlueprintCallable)

void URadioTargetComponent::ForceRegister()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "ForceRegister");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.ForceUnregister
// (Final, Native, Public, BlueprintCallable)

void URadioTargetComponent::ForceUnregister()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "ForceUnregister");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.GetSignalType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ERadioSignalType                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ERadioSignalType URadioTargetComponent::GetSignalType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "GetSignalType");

	Params::RadioTargetComponent_GetSignalType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioTargetComponent.HandleRadioAddedToInventory
// (Final, Native, Private)
// Parameters:
// EInventoryEventType                     Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInventoryItem&            Item                                                   (Parm, NoDestructor, NativeAccessSpecifierPublic)

void URadioTargetComponent::HandleRadioAddedToInventory(EInventoryEventType Type, const struct FInventoryItem& Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HandleRadioAddedToInventory");

	Params::RadioTargetComponent_HandleRadioAddedToInventory Parms{};

	Parms.Type = Type;
	Parms.Item = std::move(Item);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HIP_Disable
// (Final, Native, Public)

void URadioTargetComponent::HIP_Disable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HIP_Disable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HIP_Enable
// (Final, Native, Public)

void URadioTargetComponent::HIP_Enable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HIP_Enable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HIP_ForceRegister
// (Final, Native, Public)

void URadioTargetComponent::HIP_ForceRegister()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HIP_ForceRegister");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HIP_ForceUnregister
// (Final, Native, Public)

void URadioTargetComponent::HIP_ForceUnregister()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HIP_ForceUnregister");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_IntentionComplete
// (Final, Native, Public)

void URadioTargetComponent::HOP_IntentionComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_IntentionComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_IntentionReset
// (Final, Native, Public)

void URadioTargetComponent::HOP_IntentionReset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_IntentionReset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_OnAimedAtChanged
// (Final, Native, Public)
// Parameters:
// bool                                    bAimedAt                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URadioTargetComponent::HOP_OnAimedAtChanged(bool bAimedAt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_OnAimedAtChanged");

	Params::RadioTargetComponent_HOP_OnAimedAtChanged Parms{};

	Parms.bAimedAt = bAimedAt;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_ProgressUpdated
// (Final, Native, Public)
// Parameters:
// double                                  Progress                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URadioTargetComponent::HOP_ProgressUpdated(double Progress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_ProgressUpdated");

	Params::RadioTargetComponent_HOP_ProgressUpdated Parms{};

	Parms.Progress = Progress;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_RadioEnteredRange
// (Final, Native, Public)

void URadioTargetComponent::HOP_RadioEnteredRange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_RadioEnteredRange");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_RadioLeftRange
// (Final, Native, Public)

void URadioTargetComponent::HOP_RadioLeftRange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_RadioLeftRange");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_TuningComplete
// (Final, Native, Public)

void URadioTargetComponent::HOP_TuningComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_TuningComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.HOP_TuningReset
// (Final, Native, Public)

void URadioTargetComponent::HOP_TuningReset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "HOP_TuningReset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.OnOuterOverlapBegin
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void URadioTargetComponent::OnOuterOverlapBegin(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "OnOuterOverlapBegin");

	Params::RadioTargetComponent_OnOuterOverlapBegin Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.OnOuterOverlapEnd
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URadioTargetComponent::OnOuterOverlapEnd(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "OnOuterOverlapEnd");

	Params::RadioTargetComponent_OnOuterOverlapEnd Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.SetAudioEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    audioEvent_0                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URadioTargetComponent::SetAudioEvent(class UAkAudioEvent* audioEvent_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "SetAudioEvent");

	Params::RadioTargetComponent_SetAudioEvent Parms{};

	Parms.audioEvent_0 = audioEvent_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.SetFoundSignalEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*                    audioEvent_0                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URadioTargetComponent::SetFoundSignalEvent(class UAkAudioEvent* audioEvent_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "SetFoundSignalEvent");

	Params::RadioTargetComponent_SetFoundSignalEvent Parms{};

	Parms.audioEvent_0 = audioEvent_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioTargetComponent.GetFoundSignalEvent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAkAudioEvent*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkAudioEvent* URadioTargetComponent::GetFoundSignalEvent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "GetFoundSignalEvent");

	Params::RadioTargetComponent_GetFoundSignalEvent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioTargetComponent.GetProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float URadioTargetComponent::GetProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "GetProgress");

	Params::RadioTargetComponent_GetProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioTargetComponent.GetProximity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float URadioTargetComponent::GetProximity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "GetProximity");

	Params::RadioTargetComponent_GetProximity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioTargetComponent.ShouldUseProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float URadioTargetComponent::ShouldUseProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "ShouldUseProgress");

	Params::RadioTargetComponent_ShouldUseProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioTargetComponent.ShouldUseProximity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float URadioTargetComponent::ShouldUseProximity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioTargetComponent", "ShouldUseProximity");

	Params::RadioTargetComponent_ShouldUseProximity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChaosProxyVehicleRepComponent.MC_ServerFrameVehicle
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FSmoothRepSceneComponentState&State                                                  (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FChaosVehicleMoveRepState& vehicleState                                           (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UChaosProxyVehicleRepComponent::MC_ServerFrameVehicle(const struct FSmoothRepSceneComponentState& State, const struct FChaosVehicleMoveRepState& vehicleState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosProxyVehicleRepComponent", "MC_ServerFrameVehicle");

	Params::ChaosProxyVehicleRepComponent_MC_ServerFrameVehicle Parms{};

	Parms.State = std::move(State);
	Parms.vehicleState = std::move(vehicleState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PressToStartWidget.InitializePressToStart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bResetMapping                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPressToStartWidget::InitializePressToStart(bool bResetMapping)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "InitializePressToStart");

	Params::PressToStartWidget_InitializePressToStart Parms{};

	Parms.bResetMapping = bResetMapping;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PressToStartWidget.OnConfirmInputMapping
// (Event, Public, BlueprintEvent)

void UPressToStartWidget::OnConfirmInputMapping()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "OnConfirmInputMapping");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PressToStartWidget.OnEndPIE
// (Final, Native, Protected)
// Parameters:
// bool                                    bIsSimulating                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPressToStartWidget::OnEndPIE(bool bIsSimulating)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "OnEndPIE");

	Params::PressToStartWidget_OnEndPIE Parms{};

	Parms.bIsSimulating = bIsSimulating;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PressToStartWidget.OnLoginInputPressed
// (Event, Public, BlueprintEvent)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            InputDevice                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPressToStartWidget::OnLoginInputPressed(ELocalUserType localUserType, int32 LocalPlayerIndex, const struct FInputDeviceId& InputDevice)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "OnLoginInputPressed");

	Params::PressToStartWidget_OnLoginInputPressed Parms{};

	Parms.localUserType = localUserType;
	Parms.LocalPlayerIndex = LocalPlayerIndex;
	Parms.InputDevice = std::move(InputDevice);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PressToStartWidget.OnLogoutInputPressed
// (Event, Public, BlueprintEvent)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            InputDevice                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPressToStartWidget::OnLogoutInputPressed(ELocalUserType localUserType, int32 LocalPlayerIndex, const struct FInputDeviceId& InputDevice)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "OnLogoutInputPressed");

	Params::PressToStartWidget_OnLogoutInputPressed Parms{};

	Parms.localUserType = localUserType;
	Parms.LocalPlayerIndex = LocalPlayerIndex;
	Parms.InputDevice = std::move(InputDevice);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PressToStartWidget.StartProcessingInput
// (Final, Native, Public, BlueprintCallable)

void UPressToStartWidget::StartProcessingInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "StartProcessingInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PressToStartWidget.StopProcessingInput
// (Final, Native, Public, BlueprintCallable)

void UPressToStartWidget::StopProcessingInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "StopProcessingInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PressToStartWidget.GetControllerType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UPressToStartWidget::GetControllerType(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "GetControllerType");

	Params::PressToStartWidget_GetControllerType Parms{};

	Parms.localUserType = localUserType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PressToStartWidget.GetPlatformConfirmKeys
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TArray<struct FKey>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKey> UPressToStartWidget::GetPlatformConfirmKeys() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "GetPlatformConfirmKeys");

	Params::PressToStartWidget_GetPlatformConfirmKeys Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PressToStartWidget.GetPlatformLoginKeys
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TArray<struct FKey>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKey> UPressToStartWidget::GetPlatformLoginKeys() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "GetPlatformLoginKeys");

	Params::PressToStartWidget_GetPlatformLoginKeys Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PressToStartWidget.GetPlatformLogoutKeys
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TArray<struct FKey>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKey> UPressToStartWidget::GetPlatformLogoutKeys() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "GetPlatformLogoutKeys");

	Params::PressToStartWidget_GetPlatformLogoutKeys Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PressToStartWidget.ShouldShowControllerType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPressToStartWidget::ShouldShowControllerType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PressToStartWidget", "ShouldShowControllerType");

	Params::PressToStartWidget_ShouldShowControllerType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChaosProxyVehicleReplicator.StartVehicleReplication
// (Final, Native, Public, BlueprintCallable)

void AChaosProxyVehicleReplicator::StartVehicleReplication()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosProxyVehicleReplicator", "StartVehicleReplication");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ChaosProxyVehicleReplicator.StopVehicleReplication
// (Final, Native, Public, BlueprintCallable)

void AChaosProxyVehicleReplicator::StopVehicleReplication()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChaosProxyVehicleReplicator", "StopVehicleReplication");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Pelican.Despawn
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)

void AEverholmCharacter_Pelican::Despawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Pelican", "Despawn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Pelican.RequestRubberbanding
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const float                             MaxSpeed                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             MaxDistance                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      RubberbandCurve                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter_Pelican::RequestRubberbanding(const float MaxSpeed, const float MaxDistance, class UCurveFloat* RubberbandCurve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Pelican", "RequestRubberbanding");

	Params::EverholmCharacter_Pelican_RequestRubberbanding Parms{};

	Parms.MaxSpeed = MaxSpeed;
	Parms.MaxDistance = MaxDistance;
	Parms.RubberbandCurve = RubberbandCurve;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_Pelican.UnrequestRubberbanding
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter_Pelican::UnrequestRubberbanding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Pelican", "UnrequestRubberbanding");

	Params::EverholmCharacter_Pelican_UnrequestRubberbanding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChapterSelectInfoWidget.InitFromRow
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FChapterSelectRow&         chapterRow_0                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UChapterSelectInfoWidget::InitFromRow(const struct FChapterSelectRow& chapterRow_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChapterSelectInfoWidget", "InitFromRow");

	Params::ChapterSelectInfoWidget_InitFromRow Parms{};

	Parms.chapterRow_0 = std::move(chapterRow_0);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ChapterSelectInfoWidget.SetChapterRow
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       rowHandle                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UChapterSelectInfoWidget::SetChapterRow(const struct FDataTableRowHandle& rowHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChapterSelectInfoWidget", "SetChapterRow");

	Params::ChapterSelectInfoWidget_SetChapterRow Parms{};

	Parms.rowHandle = std::move(rowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ChapterSelectInfoWidget.GetChapterRow
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FDataTableRowHandle        ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FDataTableRowHandle UChapterSelectInfoWidget::GetChapterRow() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChapterSelectInfoWidget", "GetChapterRow");

	Params::ChapterSelectInfoWidget_GetChapterRow Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SoundInteractionInterface.GetSoundInteractionData
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FSoundInteractionData            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FSoundInteractionData ISoundInteractionInterface::GetSoundInteractionData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SoundInteractionInterface", "GetSoundInteractionData");

	Params::SoundInteractionInterface_GetSoundInteractionData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SoundInteractionInterface.IsSoundInteractionActivated
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ISoundInteractionInterface::IsSoundInteractionActivated() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("SoundInteractionInterface", "IsSoundInteractionActivated");

	Params::SoundInteractionInterface_IsSoundInteractionActivated Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChapterSelectWidget.AddChapterInfo
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FDataTableRowHandle&       chapterRowHandle                                       (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UChapterSelectWidget::AddChapterInfo(const struct FDataTableRowHandle& chapterRowHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChapterSelectWidget", "AddChapterInfo");

	Params::ChapterSelectWidget_AddChapterInfo Parms{};

	Parms.chapterRowHandle = std::move(chapterRowHandle);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ChapterSelectWidget.ClearChapterWidgets
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UChapterSelectWidget::ClearChapterWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChapterSelectWidget", "ClearChapterWidgets");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.ChapterSelectWidget.GoToLaunchGame
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UChapterSelectWidget::GoToLaunchGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChapterSelectWidget", "GoToLaunchGame");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.ChapterSelectWidget.LoadChapter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       chapterRowHandle                                       (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UChapterSelectWidget::LoadChapter(const struct FDataTableRowHandle& chapterRowHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChapterSelectWidget", "LoadChapter");

	Params::ChapterSelectWidget_LoadChapter Parms{};

	Parms.chapterRowHandle = std::move(chapterRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterInstructionPriorityDataAsset.RefreshInstructions
// (Final, Native, Public)

void UCharacterInstructionPriorityDataAsset::RefreshInstructions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionPriorityDataAsset", "RefreshInstructions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowWorldSettings.GetCurrentLevelType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EEverholmLevelType                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EEverholmLevelType UEverholmGameFlowWorldSettings::GetCurrentLevelType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameFlowWorldSettings", "GetCurrentLevelType");

	Params::EverholmGameFlowWorldSettings_GetCurrentLevelType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterInstructionsComponent.AddInstructionHandler
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TScriptInterface<class ICharacterInstructionHandler>handler                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterInstructionsComponent::AddInstructionHandler(TScriptInterface<class ICharacterInstructionHandler> handler)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "AddInstructionHandler");

	Params::CharacterInstructionsComponent_AddInstructionHandler Parms{};

	Parms.handler = handler;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterInstructionsComponent.DisableExecution
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDisableInstructionsRequest&Request                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)

void UCharacterInstructionsComponent::DisableExecution(const class UObject*& Instigator, const struct FDisableInstructionsRequest& Request)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "DisableExecution");

	Params::CharacterInstructionsComponent_DisableExecution Parms{};

	Parms.Instigator = Instigator;
	Parms.Request = std::move(Request);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterInstructionsComponent.DisableExecutionSingle
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECharacterInstruction                   instruction                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    Executor                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterInstructionsComponent::DisableExecutionSingle(const class UObject*& Instigator, ECharacterInstruction instruction, const class UObject* Executor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "DisableExecutionSingle");

	Params::CharacterInstructionsComponent_DisableExecutionSingle Parms{};

	Parms.Instigator = Instigator;
	Parms.instruction = instruction;
	Parms.Executor = Executor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterInstructionsComponent.EnableExecution
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterInstructionsComponent::EnableExecution(const class UObject*& Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "EnableExecution");

	Params::CharacterInstructionsComponent_EnableExecution Parms{};

	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterInstructionsComponent.RemoveInstructionHandler
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TScriptInterface<class ICharacterInstructionHandler>handler                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterInstructionsComponent::RemoveInstructionHandler(TScriptInterface<class ICharacterInstructionHandler> handler)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "RemoveInstructionHandler");

	Params::CharacterInstructionsComponent_RemoveInstructionHandler Parms{};

	Parms.handler = handler;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterInstructionsComponent.HasDisableRequest
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*&                   Instigator                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterInstructionsComponent::HasDisableRequest(const class UObject*& Instigator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "HasDisableRequest");

	Params::CharacterInstructionsComponent_HasDisableRequest Parms{};

	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterInstructionsComponent.IsCurrentlyExecutingInstruction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECharacterInstruction                   instruction                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterInstructionsComponent::IsCurrentlyExecutingInstruction(ECharacterInstruction instruction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "IsCurrentlyExecutingInstruction");

	Params::CharacterInstructionsComponent_IsCurrentlyExecutingInstruction Parms{};

	Parms.instruction = instruction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterInstructionsComponent.IsExecutionEnabled
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FDisableInstructionsRequest&Request                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterInstructionsComponent::IsExecutionEnabled(const struct FDisableInstructionsRequest& Request) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterInstructionsComponent", "IsExecutionEnabled");

	Params::CharacterInstructionsComponent_IsExecutionEnabled Parms{};

	Parms.Request = std::move(Request);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.ApplyCameraVolumeScaleDelta
// (Native, Event, Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   scaleDelta                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADollhouseCameraHint::ApplyCameraVolumeScaleDelta(const struct FVector& scaleDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "ApplyCameraVolumeScaleDelta");

	Params::DollhouseCameraHint_ApplyCameraVolumeScaleDelta Parms{};

	Parms.scaleDelta = std::move(scaleDelta);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DollhouseCameraHint.ApplyFocalVolumeScaleDelta
// (Native, Event, Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   scaleDelta                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADollhouseCameraHint::ApplyFocalVolumeScaleDelta(const struct FVector& scaleDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "ApplyFocalVolumeScaleDelta");

	Params::DollhouseCameraHint_ApplyFocalVolumeScaleDelta Parms{};

	Parms.scaleDelta = std::move(scaleDelta);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DollhouseCameraHint.ConstructPreview
// (Event, Public, BlueprintCallable, BlueprintEvent)

void ADollhouseCameraHint::ConstructPreview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "ConstructPreview");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.DollhouseCameraHint.GetActivationBoxCenter
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetActivationBoxCenter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetActivationBoxCenter");

	Params::DollhouseCameraHint_GetActivationBoxCenter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetActivationExtentsPlusBlendRadius
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetActivationExtentsPlusBlendRadius(float Scale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetActivationExtentsPlusBlendRadius");

	Params::DollhouseCameraHint_GetActivationExtentsPlusBlendRadius Parms{};

	Parms.Scale = Scale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetCameraLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// bool                                    bEditorPreview                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   FocalPoint                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetCameraLocation(bool bEditorPreview, const struct FVector& FocalPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetCameraLocation");

	Params::DollhouseCameraHint_GetCameraLocation Parms{};

	Parms.bEditorPreview = bEditorPreview;
	Parms.FocalPoint = std::move(FocalPoint);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetFocalPointVolumeExtents
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetFocalPointVolumeExtents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetFocalPointVolumeExtents");

	Params::DollhouseCameraHint_GetFocalPointVolumeExtents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetInnerBlendingVolumeExtents
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetInnerBlendingVolumeExtents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetInnerBlendingVolumeExtents");

	Params::DollhouseCameraHint_GetInnerBlendingVolumeExtents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetOuterBlendingVolumeExtents
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetOuterBlendingVolumeExtents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetOuterBlendingVolumeExtents");

	Params::DollhouseCameraHint_GetOuterBlendingVolumeExtents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.UpdateActivationBox
// (Event, Public, BlueprintCallable, BlueprintEvent)

void ADollhouseCameraHint::UpdateActivationBox()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "UpdateActivationBox");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.DollhouseCameraHint.DebugDollhouse
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// const struct FVector&                   FocalPoint                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADollhouseCameraHint::DebugDollhouse(const struct FVector& FocalPoint) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "DebugDollhouse");

	Params::DollhouseCameraHint_DebugDollhouse Parms{};

	Parms.FocalPoint = std::move(FocalPoint);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DollhouseCameraHint.GetActivationBoxExtents
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetActivationBoxExtents() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetActivationBoxExtents");

	Params::DollhouseCameraHint_GetActivationBoxExtents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetCameraAxisInvertBehavior
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// EAxis                                   Axis                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECameraAxisInvertBehavior               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECameraAxisInvertBehavior ADollhouseCameraHint::GetCameraAxisInvertBehavior(EAxis Axis) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetCameraAxisInvertBehavior");

	Params::DollhouseCameraHint_GetCameraAxisInvertBehavior Parms{};

	Parms.Axis = Axis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetCameraVolumeExtents
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetCameraVolumeExtents() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetCameraVolumeExtents");

	Params::DollhouseCameraHint_GetCameraVolumeExtents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetCameraVolumeWorldTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform ADollhouseCameraHint::GetCameraVolumeWorldTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetCameraVolumeWorldTransform");

	Params::DollhouseCameraHint_GetCameraVolumeWorldTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetFocalPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ADollhouseCameraHint::GetFocalPoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetFocalPoint");

	Params::DollhouseCameraHint_GetFocalPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DollhouseCameraHint.GetFocalVolumeWorldTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform ADollhouseCameraHint::GetFocalVolumeWorldTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DollhouseCameraHint", "GetFocalVolumeWorldTransform");

	Params::DollhouseCameraHint_GetFocalVolumeWorldTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterInstructionBlueprintFunctionLibrary.InternalTryExecuteCharacterInstruction
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UCharacterInstructionsComponent*  Target                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ECharacterInstruction             instruction                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    Value                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class UObject*                    Instigator                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECharacterInstructionResult             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECharacterInstructionResult UCharacterInstructionBlueprintFunctionLibrary::InternalTryExecuteCharacterInstruction(class UCharacterInstructionsComponent* Target, const ECharacterInstruction instruction, const TArray<uint8>& Value, const class UObject* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CharacterInstructionBlueprintFunctionLibrary", "InternalTryExecuteCharacterInstruction");

	Params::CharacterInstructionBlueprintFunctionLibrary_InternalTryExecuteCharacterInstruction Parms{};

	Parms.Target = Target;
	Parms.instruction = instruction;
	Parms.Value = std::move(Value);
	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterInstructionBlueprintFunctionLibrary.MakeDisableInstructionsRequest
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const TArray<ECharacterInstruction>&    Instructions                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class UObject*                    Executor                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDisableInstructionsRequest      ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FDisableInstructionsRequest UCharacterInstructionBlueprintFunctionLibrary::MakeDisableInstructionsRequest(const TArray<ECharacterInstruction>& Instructions, const class UObject* Executor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CharacterInstructionBlueprintFunctionLibrary", "MakeDisableInstructionsRequest");

	Params::CharacterInstructionBlueprintFunctionLibrary_MakeDisableInstructionsRequest Parms{};

	Parms.Instructions = std::move(Instructions);
	Parms.Executor = Executor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterReactionComponent.OnGenericWorldEvent
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FGenericWorldEvent&        worldEvent                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UCharacterReactionComponent::OnGenericWorldEvent(const struct FGenericWorldEvent& worldEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterReactionComponent", "OnGenericWorldEvent");

	Params::CharacterReactionComponent_OnGenericWorldEvent Parms{};

	Parms.worldEvent = std::move(worldEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterReactionComponent.OnOrientedWorldEvent
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FOrientedWorldEvent&       worldEvent                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UCharacterReactionComponent::OnOrientedWorldEvent(const struct FOrientedWorldEvent& worldEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterReactionComponent", "OnOrientedWorldEvent");

	Params::CharacterReactionComponent_OnOrientedWorldEvent Parms{};

	Parms.worldEvent = std::move(worldEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterSelectWidget.OnEndPIE
// (Final, Native, Protected)
// Parameters:
// bool                                    bIsSimulating                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterSelectWidget::OnEndPIE(bool bIsSimulating)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterSelectWidget", "OnEndPIE");

	Params::CharacterSelectWidget_OnEndPIE Parms{};

	Parms.bIsSimulating = bIsSimulating;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterSelectWidget.OnPlayerOneInput
// (Event, Public, BlueprintEvent)

void UCharacterSelectWidget::OnPlayerOneInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterSelectWidget", "OnPlayerOneInput");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.CharacterSelectWidget.OnPlayerTwoInput
// (Event, Public, BlueprintEvent)

void UCharacterSelectWidget::OnPlayerTwoInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterSelectWidget", "OnPlayerTwoInput");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.CharacterSelectWidget.RegisterInputPreprocessor
// (Final, Native, Public, BlueprintCallable)

void UCharacterSelectWidget::RegisterInputPreprocessor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterSelectWidget", "RegisterInputPreprocessor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterSelectWidget.UnregisterInputPreprocessor
// (Final, Native, Public, BlueprintCallable)

void UCharacterSelectWidget::UnregisterInputPreprocessor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterSelectWidget", "UnregisterInputPreprocessor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlaceSwimRingActor.OnRep_SpawnedSwimRingActor
// (Final, Native, Protected)

void APlaceSwimRingActor::OnRep_SpawnedSwimRingActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlaceSwimRingActor", "OnRep_SpawnedSwimRingActor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlaceSwimRingActor.SpawnSwimRingActor
// (Final, Native, Protected, BlueprintCallable)

void APlaceSwimRingActor::SpawnSwimRingActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlaceSwimRingActor", "SpawnSwimRingActor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlaceSwimRingActor.SwimRingSpawned
// (Event, Protected, BlueprintEvent)

void APlaceSwimRingActor::SwimRingSpawned()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlaceSwimRingActor", "SwimRingSpawned");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PlaceSwimRingActor.TryInteractWithGrabHelper
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelperComponent*             GrabHelperComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APlaceSwimRingActor::TryInteractWithGrabHelper(class AEverholmPlayerCharacter* Character, class UGrabHelperComponent* GrabHelperComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlaceSwimRingActor", "TryInteractWithGrabHelper");

	Params::PlaceSwimRingActor_TryInteractWithGrabHelper Parms{};

	Parms.Character = Character;
	Parms.GrabHelperComponent = GrabHelperComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.HasEverholmSave
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameInstance::HasEverholmSave(const class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameInstance", "HasEverholmSave");

	Params::EverholmGameInstance_HasEverholmSave Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameInstance.IsConnectionSafeForReliableMulticast
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameInstance::IsConnectionSafeForReliableMulticast(const class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameInstance", "IsConnectionSafeForReliableMulticast");

	Params::EverholmGameInstance_IsConnectionSafeForReliableMulticast Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameInstance.BeginLoadingScreen
// (Native, Protected)
// Parameters:
// const class FString&                    MapName                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::BeginLoadingScreen(const class FString& MapName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "BeginLoadingScreen");

	Params::EverholmGameInstance_BeginLoadingScreen Parms{};

	Parms.MapName = std::move(MapName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.EnableSplashScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::EnableSplashScreen(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "EnableSplashScreen");

	Params::EverholmGameInstance_EnableSplashScreen Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.EndLoadingScreen
// (Native, Protected)
// Parameters:
// class UWorld*                           InLoadedWorld                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::EndLoadingScreen(class UWorld* InLoadedWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "EndLoadingScreen");

	Params::EverholmGameInstance_EndLoadingScreen Parms{};

	Parms.InLoadedWorld = InLoadedWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.FinishLoadSavegame
// (Final, Native, Protected)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::FinishLoadSavegame(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "FinishLoadSavegame");

	Params::EverholmGameInstance_FinishLoadSavegame Parms{};

	Parms.World = World;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.PreLoadAdditionalSubLevels
// (Final, Native, Protected)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::PreLoadAdditionalSubLevels(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "PreLoadAdditionalSubLevels");

	Params::EverholmGameInstance_PreLoadAdditionalSubLevels Parms{};

	Parms.World = World;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.PreloadSavegame
// (Final, Native, Protected)
// Parameters:
// const struct FURL&                      URL                                                    (Parm, NativeAccessSpecifierPublic)
// class UWorld*                           World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::PreloadSavegame(const struct FURL& URL, class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "PreloadSavegame");

	Params::EverholmGameInstance_PreloadSavegame Parms{};

	Parms.URL = std::move(URL);
	Parms.World = World;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.ReceiveNetWelcome
// (Final, Native, Protected)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint64                                  inBunchPtr                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDiscard                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::ReceiveNetWelcome(class UWorld* World, uint64 inBunchPtr, bool bDiscard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "ReceiveNetWelcome");

	Params::EverholmGameInstance_ReceiveNetWelcome Parms{};

	Parms.World = World;
	Parms.inBunchPtr = inBunchPtr;
	Parms.bDiscard = bDiscard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.SendNetWelcome
// (Final, Native, Protected)
// Parameters:
// class UNetConnection*                   Connection                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    GameName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    RedirectURL                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::SendNetWelcome(class UNetConnection* Connection, const class FString& LevelName, const class FString& GameName, const class FString& RedirectURL)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "SendNetWelcome");

	Params::EverholmGameInstance_SendNetWelcome Parms{};

	Parms.Connection = Connection;
	Parms.LevelName = std::move(LevelName);
	Parms.GameName = std::move(GameName);
	Parms.RedirectURL = std::move(RedirectURL);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.SetArePlayerPawnsSwapped
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bArePawnsSwapped                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::SetArePlayerPawnsSwapped(bool bArePawnsSwapped)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "SetArePlayerPawnsSwapped");

	Params::EverholmGameInstance_SetArePlayerPawnsSwapped Parms{};

	Parms.bArePawnsSwapped = bArePawnsSwapped;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.SetSelectedSessionMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EEverholmSessionMode                    InSelectedSessionMode                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameInstance::SetSelectedSessionMode(EEverholmSessionMode InSelectedSessionMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "SetSelectedSessionMode");

	Params::EverholmGameInstance_SetSelectedSessionMode Parms{};

	Parms.InSelectedSessionMode = InSelectedSessionMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameInstance.GetArePlayerPawnsSwapped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameInstance::GetArePlayerPawnsSwapped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "GetArePlayerPawnsSwapped");

	Params::EverholmGameInstance_GetArePlayerPawnsSwapped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameInstance.GetSelectedSessionMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EEverholmSessionMode                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EEverholmSessionMode UEverholmGameInstance::GetSelectedSessionMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "GetSelectedSessionMode");

	Params::EverholmGameInstance_GetSelectedSessionMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameInstance.IsReloadingWorld
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameInstance::IsReloadingWorld() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "IsReloadingWorld");

	Params::EverholmGameInstance_IsReloadingWorld Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameInstance.IsSaveSystemActiveUserSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameInstance::IsSaveSystemActiveUserSet() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "IsSaveSystemActiveUserSet");

	Params::EverholmGameInstance_IsSaveSystemActiveUserSet Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameInstance.ShouldShowSplashScreen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameInstance::ShouldShowSplashScreen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameInstance", "ShouldShowSplashScreen");

	Params::EverholmGameInstance_ShouldShowSplashScreen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterWoundedComponent.OnRep_WoundReplicationData
// (Final, Native, Private)

void UCharacterWoundedComponent::OnRep_WoundReplicationData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterWoundedComponent", "OnRep_WoundReplicationData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterWoundedComponent.Server_TryApplyWound
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)
// Parameters:
// class UWoundedData*                     Data                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCharacterWoundedComponent::Server_TryApplyWound(class UWoundedData* Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterWoundedComponent", "Server_TryApplyWound");

	Params::CharacterWoundedComponent_Server_TryApplyWound Parms{};

	Parms.Data = Data;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CharacterWoundedComponent.TryApplyWound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWoundedData*                     Data                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EWoundTriggerResult                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EWoundTriggerResult UCharacterWoundedComponent::TryApplyWound(class UWoundedData* Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterWoundedComponent", "TryApplyWound");

	Params::CharacterWoundedComponent_TryApplyWound Parms{};

	Parms.Data = Data;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterWoundedComponent.TryClearWound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterWoundedComponent::TryClearWound()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterWoundedComponent", "TryClearWound");

	Params::CharacterWoundedComponent_TryClearWound Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterWoundedComponent.GetIsWounded
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCharacterWoundedComponent::GetIsWounded() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterWoundedComponent", "GetIsWounded");

	Params::CharacterWoundedComponent_GetIsWounded Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterWoundedComponent.GetRemainingDuration
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UCharacterWoundedComponent::GetRemainingDuration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterWoundedComponent", "GetRemainingDuration");

	Params::CharacterWoundedComponent_GetRemainingDuration Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CharacterWoundedComponent.GetWoundedData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWoundedData*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWoundedData* UCharacterWoundedComponent::GetWoundedData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterWoundedComponent", "GetWoundedData");

	Params::CharacterWoundedComponent_GetWoundedData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CheckpointComponent.GetPlayerStart
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TSoftObjectPtr<class AEverholmPlayerStart>ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class AEverholmPlayerStart> UCheckpointComponent::GetPlayerStart() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CheckpointComponent", "GetPlayerStart");

	Params::CheckpointComponent_GetPlayerStart Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.CheckpointSelectWidget.GotoCheckpoint
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// class AEverholmPlayerStart*             PlayerStart                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCheckpointSelectWidget::GotoCheckpoint(class AEverholmPlayerStart* PlayerStart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CheckpointSelectWidget", "GotoCheckpoint");

	Params::CheckpointSelectWidget_GotoCheckpoint Parms{};

	Parms.PlayerStart = PlayerStart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CheckpointSelectWidget.EvaluateClosestCheckpoint
// (Final, Native, Private, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class AActor*>&            Progression                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UCheckpointSelectWidget::EvaluateClosestCheckpoint(const TArray<class AActor*>& Progression) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CheckpointSelectWidget", "EvaluateClosestCheckpoint");

	Params::CheckpointSelectWidget_EvaluateClosestCheckpoint Parms{};

	Parms.Progression = std::move(Progression);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CheckpointSelectWidget.GetSortedCheckpointActors
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UCheckpointSelectWidget::GetSortedCheckpointActors() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CheckpointSelectWidget", "GetSortedCheckpointActors");

	Params::CheckpointSelectWidget_GetSortedCheckpointActors Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameFlowEventsNetworkHelper.BeginRestartFlow
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// class AActor*                           PlayerStart                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyProgression                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameFlowEventsNetworkHelper::BeginRestartFlow(class AActor* PlayerStart, const struct FVector& StartLocation, bool bApplyProgression)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameFlowEventsNetworkHelper", "BeginRestartFlow");

	Params::EverholmGameFlowEventsNetworkHelper_BeginRestartFlow Parms{};

	Parms.PlayerStart = PlayerStart;
	Parms.StartLocation = std::move(StartLocation);
	Parms.bApplyProgression = bApplyProgression;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowEventsNetworkHelper.ReceiveSaveDataPacket
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// uint8                                   packetNumber                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    Data                                                   (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AEverholmGameFlowEventsNetworkHelper::ReceiveSaveDataPacket(uint8 packetNumber, const TArray<uint8>& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameFlowEventsNetworkHelper", "ReceiveSaveDataPacket");

	Params::EverholmGameFlowEventsNetworkHelper_ReceiveSaveDataPacket Parms{};

	Parms.packetNumber = packetNumber;
	Parms.Data = std::move(Data);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameFlowEventsNetworkHelper.SetRestartPlayerFlowState
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// EGameFlowState                          State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameFlowEventsNetworkHelper::SetRestartPlayerFlowState(EGameFlowState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameFlowEventsNetworkHelper", "SetRestartPlayerFlowState");

	Params::EverholmGameFlowEventsNetworkHelper_SetRestartPlayerFlowState Parms{};

	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CheckpointVolumeActor.GetCheckpointComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UCheckpointComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UCheckpointComponent* ACheckpointVolumeActor::GetCheckpointComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CheckpointVolumeActor", "GetCheckpointComponent");

	Params::CheckpointVolumeActor_GetCheckpointComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableIK.GetClosestIKBasePoint
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class ACharacter*                 Initiator                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   localQueryLocation                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClimbablePointData              ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FClimbablePointData IClimbableIK::GetClosestIKBasePoint(const class ACharacter* Initiator, const struct FVector& localQueryLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("ClimbableIK", "GetClosestIKBasePoint");

	Params::ClimbableIK_GetClosestIKBasePoint Parms{};

	Parms.Initiator = Initiator;
	Parms.localQueryLocation = std::move(localQueryLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableIK.GetIKHandRotationOffset
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const bool                              bForLeftHand                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator IClimbableIK::GetIKHandRotationOffset(const bool bForLeftHand)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("ClimbableIK", "GetIKHandRotationOffset");

	Params::ClimbableIK_GetIKHandRotationOffset Parms{};

	Parms.bForLeftHand = bForLeftHand;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableIK.GetIKOffsetFromPoint
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector IClimbableIK::GetIKOffsetFromPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("ClimbableIK", "GetIKOffsetFromPoint");

	Params::ClimbableIK_GetIKOffsetFromPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.AddPickupToInventory
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*&        PlayerCharacter                                        (Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*&                     pickupToAdd                                            (Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmFunctionLibrary::AddPickupToInventory(class AEverholmPlayerCharacter*& PlayerCharacter, class APickupBase*& pickupToAdd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "AddPickupToInventory");

	Params::EverholmFunctionLibrary_AddPickupToInventory Parms{};

	Parms.PlayerCharacter = PlayerCharacter;
	Parms.pickupToAdd = pickupToAdd;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	PlayerCharacter = Parms.PlayerCharacter;
	pickupToAdd = Parms.pickupToAdd;
}


// Function Everholm.EverholmFunctionLibrary.ClearAllSaveDataButUserMeta
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmFunctionLibrary::ClearAllSaveDataButUserMeta(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "ClearAllSaveDataButUserMeta");

	Params::EverholmFunctionLibrary_ClearAllSaveDataButUserMeta Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmFunctionLibrary.ClearChapterSelectData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmFunctionLibrary::ClearChapterSelectData(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "ClearChapterSelectData");

	Params::EverholmFunctionLibrary_ClearChapterSelectData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmFunctionLibrary.CreateBallisticFlightArc
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FBallisticFlightParams&    BallisticFlightParams                                  (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FBallisticFlightData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FBallisticFlightData UEverholmFunctionLibrary::CreateBallisticFlightArc(const struct FBallisticFlightParams& BallisticFlightParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "CreateBallisticFlightArc");

	Params::EverholmFunctionLibrary_CreateBallisticFlightArc Parms{};

	Parms.BallisticFlightParams = std::move(BallisticFlightParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.CreateHeightAndDistanceBasedFlightData
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FBallisticFlightParams&    BallisticFlightParams                                  (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const float                             Height                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   playerFacing                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBallisticFlightData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FBallisticFlightData UEverholmFunctionLibrary::CreateHeightAndDistanceBasedFlightData(const struct FBallisticFlightParams& BallisticFlightParams, const float Height, const struct FVector& playerFacing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "CreateHeightAndDistanceBasedFlightData");

	Params::EverholmFunctionLibrary_CreateHeightAndDistanceBasedFlightData Parms{};

	Parms.BallisticFlightParams = std::move(BallisticFlightParams);
	Parms.Height = Height;
	Parms.playerFacing = std::move(playerFacing);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.EvaluateChooserDynamically
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    ContextObject                                          (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UChooserTable*              ChooserTable                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UObject>              OutputClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UObject*>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UObject*> UEverholmFunctionLibrary::EvaluateChooserDynamically(const class UObject* ContextObject, const class UChooserTable* ChooserTable, TSubclassOf<class UObject> OutputClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "EvaluateChooserDynamically");

	Params::EverholmFunctionLibrary_EvaluateChooserDynamically Parms{};

	Parms.ContextObject = ContextObject;
	Parms.ChooserTable = ChooserTable;
	Parms.OutputClass = OutputClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GenerateUniqueFileNameStringBasedOnTransform
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEverholmFunctionLibrary::GenerateUniqueFileNameStringBasedOnTransform(const struct FTransform& Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GenerateUniqueFileNameStringBasedOnTransform");

	Params::EverholmFunctionLibrary_GenerateUniqueFileNameStringBasedOnTransform Parms{};

	Parms.Transform = std::move(Transform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetDefaultPlayerPawnObject
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    bGetPlayerTwo                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UEverholmFunctionLibrary::GetDefaultPlayerPawnObject(bool bGetPlayerTwo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetDefaultPlayerPawnObject");

	Params::EverholmFunctionLibrary_GetDefaultPlayerPawnObject Parms{};

	Parms.bGetPlayerTwo = bGetPlayerTwo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetInventoryFromActor
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmInventoryComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmInventoryComponent* UEverholmFunctionLibrary::GetInventoryFromActor(const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetInventoryFromActor");

	Params::EverholmFunctionLibrary_GetInventoryFromActor Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetLanternPickup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ALanternPickup*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ALanternPickup* UEverholmFunctionLibrary::GetLanternPickup(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetLanternPickup");

	Params::EverholmFunctionLibrary_GetLanternPickup Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetLanternPickupFromActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ALanternPickup*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ALanternPickup* UEverholmFunctionLibrary::GetLanternPickupFromActor(const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetLanternPickupFromActor");

	Params::EverholmFunctionLibrary_GetLanternPickupFromActor Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetLevelBounds
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class ULevel*                     Level                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBoxSphereBounds                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FBoxSphereBounds UEverholmFunctionLibrary::GetLevelBounds(const class ULevel* Level, const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetLevelBounds");

	Params::EverholmFunctionLibrary_GetLevelBounds Parms{};

	Parms.Level = Level;
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetLightPickupFromActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ALanternPickup*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ALanternPickup* UEverholmFunctionLibrary::GetLightPickupFromActor(const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetLightPickupFromActor");

	Params::EverholmFunctionLibrary_GetLightPickupFromActor Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetNumCollected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollectibleType                        Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmFunctionLibrary::GetNumCollected(const class UObject* WorldContextObject, ECollectibleType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetNumCollected");

	Params::EverholmFunctionLibrary_GetNumCollected Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetPickupFromActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class APickupBase>          pickupClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UEverholmFunctionLibrary::GetPickupFromActor(const class AActor* InActor, TSubclassOf<class APickupBase> pickupClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetPickupFromActor");

	Params::EverholmFunctionLibrary_GetPickupFromActor Parms{};

	Parms.InActor = InActor;
	Parms.pickupClass = pickupClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetPickupFromActorByTag
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UEverholmFunctionLibrary::GetPickupFromActorByTag(const class AActor* InActor, const struct FGameplayTag& Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetPickupFromActorByTag");

	Params::EverholmFunctionLibrary_GetPickupFromActorByTag Parms{};

	Parms.InActor = InActor;
	Parms.Tag = std::move(Tag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetRadioPickup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ARadioPickup*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ARadioPickup* UEverholmFunctionLibrary::GetRadioPickup(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetRadioPickup");

	Params::EverholmFunctionLibrary_GetRadioPickup Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetRadioPickupFromActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ARadioPickup*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ARadioPickup* UEverholmFunctionLibrary::GetRadioPickupFromActor(const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetRadioPickupFromActor");

	Params::EverholmFunctionLibrary_GetRadioPickupFromActor Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.GetTotalCollectiblesOfType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECollectibleType                        Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmFunctionLibrary::GetTotalCollectiblesOfType(ECollectibleType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "GetTotalCollectiblesOfType");

	Params::EverholmFunctionLibrary_GetTotalCollectiblesOfType Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.HasCollectedCollectibleByClass
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class APickupBase>          collectiblePickupClass                                 (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmFunctionLibrary::HasCollectedCollectibleByClass(const class UObject* WorldContextObject, TSubclassOf<class APickupBase> collectiblePickupClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "HasCollectedCollectibleByClass");

	Params::EverholmFunctionLibrary_HasCollectedCollectibleByClass Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.collectiblePickupClass = collectiblePickupClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.HasCollectedCollectibleByRow
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDataTableRowHandle&       rowHandle                                              (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmFunctionLibrary::HasCollectedCollectibleByRow(const class UObject* WorldContextObject, const struct FDataTableRowHandle& rowHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "HasCollectedCollectibleByRow");

	Params::EverholmFunctionLibrary_HasCollectedCollectibleByRow Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.rowHandle = std::move(rowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.HasPlayerCollectedCollectibleByRow
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class APawn*                      playerPawn                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDataTableRowHandle&       rowHandle                                              (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmFunctionLibrary::HasPlayerCollectedCollectibleByRow(const class APawn* playerPawn, const struct FDataTableRowHandle& rowHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "HasPlayerCollectedCollectibleByRow");

	Params::EverholmFunctionLibrary_HasPlayerCollectedCollectibleByRow Parms{};

	Parms.playerPawn = playerPawn;
	Parms.rowHandle = std::move(rowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.PredictBallisticFlightArcZAtXY
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   initialVelocity                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             gravityZBeforeApex                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             gravityZAfterApex                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDrawDebug                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPredictedTrajectoryData         ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPredictedTrajectoryData UEverholmFunctionLibrary::PredictBallisticFlightArcZAtXY(const class UObject* WorldContext, const struct FVector& StartLocation, const struct FVector& targetLocation, const struct FVector& initialVelocity, const float gravityZBeforeApex, const float gravityZAfterApex, const bool bDrawDebug)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "PredictBallisticFlightArcZAtXY");

	Params::EverholmFunctionLibrary_PredictBallisticFlightArcZAtXY Parms{};

	Parms.WorldContext = WorldContext;
	Parms.StartLocation = std::move(StartLocation);
	Parms.targetLocation = std::move(targetLocation);
	Parms.initialVelocity = std::move(initialVelocity);
	Parms.gravityZBeforeApex = gravityZBeforeApex;
	Parms.gravityZAfterApex = gravityZAfterApex;
	Parms.bDrawDebug = bDrawDebug;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.ProjectToViewportClamped
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*                Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   edgePixelOffset                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector2D*                       ScreenLocation                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Rotation                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bIsInsideViewport                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmFunctionLibrary::ProjectToViewportClamped(class APlayerController* Player, const struct FVector& WorldLocation, float edgePixelOffset, struct FVector2D* ScreenLocation, float* Rotation, bool* bIsInsideViewport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "ProjectToViewportClamped");

	Params::EverholmFunctionLibrary_ProjectToViewportClamped Parms{};

	Parms.Player = Player;
	Parms.WorldLocation = std::move(WorldLocation);
	Parms.edgePixelOffset = edgePixelOffset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ScreenLocation != nullptr)
		*ScreenLocation = std::move(Parms.ScreenLocation);

	if (Rotation != nullptr)
		*Rotation = Parms.Rotation;

	if (bIsInsideViewport != nullptr)
		*bIsInsideViewport = Parms.bIsInsideViewport;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.QueryHeldPickupTags
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagQuery&         Query                                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmFunctionLibrary::QueryHeldPickupTags(const class AActor* InActor, const struct FGameplayTagQuery& Query)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "QueryHeldPickupTags");

	Params::EverholmFunctionLibrary_QueryHeldPickupTags Parms{};

	Parms.InActor = InActor;
	Parms.Query = std::move(Query);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmFunctionLibrary.SpawnTempPickupInPickupsLevel
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class APickupBase>          pickupClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                spawnTransform                                         (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UEverholmFunctionLibrary::SpawnTempPickupInPickupsLevel(const class UObject* WorldContextObject, TSubclassOf<class APickupBase> pickupClass, const struct FTransform& spawnTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmFunctionLibrary", "SpawnTempPickupInPickupsLevel");

	Params::EverholmFunctionLibrary_SpawnTempPickupInPickupsLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.pickupClass = pickupClass;
	Parms.spawnTransform = std::move(spawnTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Climbable.GetClosestClimbablePoints
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ACharacter*                       Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EClimbGatheringIntent                   gatheringIntent                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FClimbablePointData>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FClimbablePointData> IClimbable::GetClosestClimbablePoints(class ACharacter* Initiator, const struct FVector& WorldLocation, EClimbGatheringIntent gatheringIntent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "GetClosestClimbablePoints");

	Params::Climbable_GetClosestClimbablePoints Parms{};

	Parms.Initiator = Initiator;
	Parms.WorldLocation = std::move(WorldLocation);
	Parms.gatheringIntent = gatheringIntent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Climbable.OnBeingClimbedOnChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class ACharacter*                       climber                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IClimbable::OnBeingClimbedOnChanged(class ACharacter* climber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "OnBeingClimbedOnChanged");

	Params::Climbable_OnBeingClimbedOnChanged Parms{};

	Parms.climber = climber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.Climbable.OnTryReservationChange
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FClimbReservation&         Reservation                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bWasReserved                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IClimbable::OnTryReservationChange(const struct FClimbReservation& Reservation, bool bWasReserved)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "OnTryReservationChange");

	Params::Climbable_OnTryReservationChange Parms{};

	Parms.Reservation = std::move(Reservation);
	Parms.bWasReserved = bWasReserved;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.Climbable.CanClimb
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IClimbable::CanClimb() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "CanClimb");

	Params::Climbable_CanClimb Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Climbable.GetLedgeMetaData
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FLedgeMetaData                   ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FLedgeMetaData IClimbable::GetLedgeMetaData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "GetLedgeMetaData");

	Params::Climbable_GetLedgeMetaData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Climbable.GetMetaData
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FInstancedStruct                 ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FInstancedStruct IClimbable::GetMetaData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "GetMetaData");

	Params::Climbable_GetMetaData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Climbable.GetReservations
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TArray<struct FClimbReservation>        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FClimbReservation> IClimbable::GetReservations() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "GetReservations");

	Params::Climbable_GetReservations Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.Climbable.GetWorldTransform
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FTransform IClimbable::GetWorldTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("Climbable", "GetWorldTransform");

	Params::Climbable_GetWorldTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SmoothedWAFloatHintProcessor.GetRelevantHintValue
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// class ADirectedCameraHint_Base*         hint                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float USmoothedWAFloatHintProcessor::GetRelevantHintValue(class ADirectedCameraHint_Base* hint, const struct FCameraHintInParameters& Params_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothedWAFloatHintProcessor", "GetRelevantHintValue");

	Params::SmoothedWAFloatHintProcessor_GetRelevantHintValue Parms{};

	Parms.hint = hint;
	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.AddRecentPlayers
// (Final, Native, Private)

void AEverholmGameState::AddRecentPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "AddRecentPlayers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.K2_ResetFadeToBlack
// (Event, Public, BlueprintEvent)

void AEverholmGameState::K2_ResetFadeToBlack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "K2_ResetFadeToBlack");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmGameState.K2_SpawnFadeFromBlack
// (Event, Public, BlueprintEvent)

void AEverholmGameState::K2_SpawnFadeFromBlack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "K2_SpawnFadeFromBlack");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmGameState.Multicast_AddPauserPlayerState
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class APlayerState*                     PlayerState                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameState::Multicast_AddPauserPlayerState(class APlayerState* PlayerState, EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "Multicast_AddPauserPlayerState");

	Params::EverholmGameState_Multicast_AddPauserPlayerState Parms{};

	Parms.PlayerState = PlayerState;
	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.Multicast_CollectCollectible
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class FName                             collectible                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameState::Multicast_CollectCollectible(class FName collectible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "Multicast_CollectCollectible");

	Params::EverholmGameState_Multicast_CollectCollectible Parms{};

	Parms.collectible = collectible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.Multicast_QuitSessionSmoothly
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void AEverholmGameState::Multicast_QuitSessionSmoothly()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "Multicast_QuitSessionSmoothly");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.Multicast_RemovePauserPlayerState
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class APlayerState*                     PlayerState                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameState::Multicast_RemovePauserPlayerState(class APlayerState* PlayerState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "Multicast_RemovePauserPlayerState");

	Params::EverholmGameState_Multicast_RemovePauserPlayerState Parms{};

	Parms.PlayerState = PlayerState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.SetDemoEndingFlag
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsEnding                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameState::SetDemoEndingFlag(bool bIsEnding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "SetDemoEndingFlag");

	Params::EverholmGameState_SetDemoEndingFlag Parms{};

	Parms.bIsEnding = bIsEnding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.ShowDemoEndScreen
// (Event, Public, BlueprintEvent)

void AEverholmGameState::ShowDemoEndScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "ShowDemoEndScreen");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmGameState.ShowDemoEndScreenNative
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void AEverholmGameState::ShowDemoEndScreenNative()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "ShowDemoEndScreenNative");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.GetCameraDefaults
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FDefaultCameraParams             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FDefaultCameraParams AEverholmGameState::GetCameraDefaults() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "GetCameraDefaults");

	Params::EverholmGameState_GetCameraDefaults Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.GetCurrentLevelType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EEverholmLevelType                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EEverholmLevelType AEverholmGameState::GetCurrentLevelType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "GetCurrentLevelType");

	Params::EverholmGameState_GetCurrentLevelType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.IsDemoEnding
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameState::IsDemoEnding() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "IsDemoEnding");

	Params::EverholmGameState_IsDemoEnding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.IsInGameplay
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameState::IsInGameplay() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "IsInGameplay");

	Params::EverholmGameState_IsInGameplay Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.IsInLobby
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameState::IsInLobby() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "IsInLobby");

	Params::EverholmGameState_IsInLobby Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.IsInMainMenu
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameState::IsInMainMenu() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "IsInMainMenu");

	Params::EverholmGameState_IsInMainMenu Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.IsReloadingWorld
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameState::IsReloadingWorld() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "IsReloadingWorld");

	Params::EverholmGameState_IsReloadingWorld Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameState.Multicast_RequestThreatLevel
// (Net, NetReliable, Native, Event, NetMulticast, Public, Const)
// Parameters:
// ESuspenseThreatLevel                    threatLevel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          requester                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameState::Multicast_RequestThreatLevel(ESuspenseThreatLevel threatLevel, class UObject* requester) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "Multicast_RequestThreatLevel");

	Params::EverholmGameState_Multicast_RequestThreatLevel Parms{};

	Parms.threatLevel = threatLevel;
	Parms.requester = requester;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameState.Multicast_UnrequestThreatLevel
// (Net, NetReliable, Native, Event, NetMulticast, Public, Const)
// Parameters:
// class UObject*                          requester                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameState::Multicast_UnrequestThreatLevel(class UObject* requester) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameState", "Multicast_UnrequestThreatLevel");

	Params::EverholmGameState_Multicast_UnrequestThreatLevel Parms{};

	Parms.requester = requester;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ClimbableLedgeComponent.GetClosestPointsOnLedge
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class ACharacter*                       Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FClimbablePointData>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FClimbablePointData> UClimbableLedgeComponent::GetClosestPointsOnLedge(class ACharacter* Initiator, const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableLedgeComponent", "GetClosestPointsOnLedge");

	Params::ClimbableLedgeComponent_GetClosestPointsOnLedge Parms{};

	Parms.Initiator = Initiator;
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableLedgeComponent.GetClosestPointsOnLedgeRespectingReservations
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class ACharacter*                       Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FClimbablePointData>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FClimbablePointData> UClimbableLedgeComponent::GetClosestPointsOnLedgeRespectingReservations(class ACharacter* Initiator, const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableLedgeComponent", "GetClosestPointsOnLedgeRespectingReservations");

	Params::ClimbableLedgeComponent_GetClosestPointsOnLedgeRespectingReservations Parms{};

	Parms.Initiator = Initiator;
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableLedgeComponent.HasFalloffPrevention
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbableLedgeComponent::HasFalloffPrevention() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableLedgeComponent", "HasFalloffPrevention");

	Params::ClimbableLedgeComponent_HasFalloffPrevention Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableLedgeComponent.HasLimitedFalloffPrevention
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbableLedgeComponent::HasLimitedFalloffPrevention() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableLedgeComponent", "HasLimitedFalloffPrevention");

	Params::ClimbableLedgeComponent_HasLimitedFalloffPrevention Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameState.GetGameChalkboard
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          Context                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UChalkboardWrapper*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UChalkboardWrapper* AEverholmIngameGameState::GetGameChalkboard(class UObject* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmIngameGameState", "GetGameChalkboard");

	Params::EverholmIngameGameState_GetGameChalkboard Parms{};

	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameState.ClearSavedCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bClearAllLevels                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::ClearSavedCheckpoint(bool bClearAllLevels)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "ClearSavedCheckpoint");

	Params::EverholmIngameGameState_ClearSavedCheckpoint Parms{};

	Parms.bClearAllLevels = bClearAllLevels;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.EnableBoomerChaseGameplayContext
// (Event, Public, BlueprintEvent)
// Parameters:
// class UObject*                          contextInstigator                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnableContext                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::EnableBoomerChaseGameplayContext(class UObject* contextInstigator, bool bEnableContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "EnableBoomerChaseGameplayContext");

	Params::EverholmIngameGameState_EnableBoomerChaseGameplayContext Parms{};

	Parms.contextInstigator = contextInstigator;
	Parms.bEnableContext = bEnableContext;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmIngameGameState.Event_RollCredits
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           Caller                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::Event_RollCredits(class AActor* Caller)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "Event_RollCredits");

	Params::EverholmIngameGameState_Event_RollCredits Parms{};

	Parms.Caller = Caller;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.Multicast_RollCredits
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// class AActor*                           Caller                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::Multicast_RollCredits(class AActor* Caller)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "Multicast_RollCredits");

	Params::EverholmIngameGameState_Multicast_RollCredits Parms{};

	Parms.Caller = Caller;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.Multicast_ShowSaveIcon
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// bool                                    bShow                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::Multicast_ShowSaveIcon(bool bShow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "Multicast_ShowSaveIcon");

	Params::EverholmIngameGameState_Multicast_ShowSaveIcon Parms{};

	Parms.bShow = bShow;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.Multicast_UpdatePresence
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const TSoftObjectPtr<class AEverholmPlayerStart>&PlayerStart                                            (ConstParm, Parm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::Multicast_UpdatePresence(const TSoftObjectPtr<class AEverholmPlayerStart>& PlayerStart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "Multicast_UpdatePresence");

	Params::EverholmIngameGameState_Multicast_UpdatePresence Parms{};

	Parms.PlayerStart = PlayerStart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.RollCredits
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Caller                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::RollCredits(class AActor* Caller)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "RollCredits");

	Params::EverholmIngameGameState_RollCredits Parms{};

	Parms.Caller = Caller;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.SetWaveWindDominantAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   dominantAngle                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::SetWaveWindDominantAngle(float dominantAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "SetWaveWindDominantAngle");

	Params::EverholmIngameGameState_SetWaveWindDominantAngle Parms{};

	Parms.dominantAngle = dominantAngle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.UpdatePresence
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerStart*             PlayerStart                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::UpdatePresence(class AEverholmPlayerStart* PlayerStart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "UpdatePresence");

	Params::EverholmIngameGameState_UpdatePresence Parms{};

	Parms.PlayerStart = PlayerStart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameState.GetWaveWindDominantAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AEverholmIngameGameState::GetWaveWindDominantAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "GetWaveWindDominantAngle");

	Params::EverholmIngameGameState_GetWaveWindDominantAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameState.HasLoadedSaveData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmIngameGameState::HasLoadedSaveData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "HasLoadedSaveData");

	Params::EverholmIngameGameState_HasLoadedSaveData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameState.IsCinematicModeEnabled
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmIngameGameState::IsCinematicModeEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "IsCinematicModeEnabled");

	Params::EverholmIngameGameState_IsCinematicModeEnabled Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameState.PrintCurrentCheckpoint
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// bool                                    bPrintToScreen                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOutputAllLevels                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameState::PrintCurrentCheckpoint(bool bPrintToScreen, bool bOutputAllLevels) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameState", "PrintCurrentCheckpoint");

	Params::EverholmIngameGameState_PrintCurrentCheckpoint Parms{};

	Parms.bPrintToScreen = bPrintToScreen;
	Parms.bOutputAllLevels = bOutputAllLevels;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ClimbableSurface.GetClosestPointOnClimbableSurface
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class ACharacter*                       Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBoxComponent*                    surface                                                (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRespectReservations                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAdjustForCharacterCapsule                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outClosestPoint                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AClimbableSurface::GetClosestPointOnClimbableSurface(class ACharacter* Initiator, class UBoxComponent* surface, const struct FVector& Location, bool bRespectReservations, bool bAdjustForCharacterCapsule, struct FVector* outClosestPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableSurface", "GetClosestPointOnClimbableSurface");

	Params::ClimbableSurface_GetClosestPointOnClimbableSurface Parms{};

	Parms.Initiator = Initiator;
	Parms.surface = surface;
	Parms.Location = std::move(Location);
	Parms.bRespectReservations = bRespectReservations;
	Parms.bAdjustForCharacterCapsule = bAdjustForCharacterCapsule;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outClosestPoint != nullptr)
		*outClosestPoint = std::move(Parms.outClosestPoint);

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableSurface.SetSurfaceEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AClimbableSurface::SetSurfaceEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableSurface", "SetSurfaceEnabled");

	Params::ClimbableSurface_SetSurfaceEnabled Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ClimbableSurface.IsSurfaceEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AClimbableSurface::IsSurfaceEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableSurface", "IsSurfaceEnabled");

	Params::ClimbableSurface_IsSurfaceEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbableSurface.MoveInLocationFromEdges
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, Const)
// Parameters:
// const class ACharacter*                 Initiator                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UBoxComponent*              surface                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   distanceFromSides                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   distanceFromTopBottom                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AClimbableSurface::MoveInLocationFromEdges(const class ACharacter* Initiator, const class UBoxComponent* surface, const struct FVector& Location, float distanceFromSides, float distanceFromTopBottom) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableSurface", "MoveInLocationFromEdges");

	Params::ClimbableSurface_MoveInLocationFromEdges Parms{};

	Parms.Initiator = Initiator;
	Parms.surface = surface;
	Parms.Location = std::move(Location);
	Parms.distanceFromSides = distanceFromSides;
	Parms.distanceFromTopBottom = distanceFromTopBottom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmHostSessionCallbackProxy.EverholmLaunchSession
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameStartParam&           startParam                                             (Parm, NativeAccessSpecifierPublic)
// class UEverholmHostSessionCallbackProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmHostSessionCallbackProxy* UEverholmHostSessionCallbackProxy::EverholmLaunchSession(class UObject* WorldContextObject, const struct FGameStartParam& startParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmHostSessionCallbackProxy", "EverholmLaunchSession");

	Params::EverholmHostSessionCallbackProxy_EverholmLaunchSession Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.startParam = std::move(startParam);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.Evaluate
// (Native, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FClimbablePointData>&closestClimbablePointsInArea                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<struct FLedgeMetaDataWrapper>&closestLedgesInArea                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool&                                   pendingAbort                                           (Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClimbingConditionResult         ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FClimbingConditionResult UClimbingCondition::Evaluate(class AEverholmCharacter* Initiator, const TArray<struct FClimbablePointData>& closestClimbablePointsInArea, const TArray<struct FLedgeMetaDataWrapper>& closestLedgesInArea, bool& pendingAbort)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "Evaluate");

	Params::ClimbingCondition_Evaluate Parms{};

	Parms.Initiator = Initiator;
	Parms.closestClimbablePointsInArea = std::move(closestClimbablePointsInArea);
	Parms.closestLedgesInArea = std::move(closestLedgesInArea);
	Parms.pendingAbort = pendingAbort;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	pendingAbort = Parms.pendingAbort;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.Filter_IsFacingCharacter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FClimbablePointData>&pointsToFilter                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   dotThreshold                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FClimbablePointData>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FClimbablePointData> UClimbingCondition::Filter_IsFacingCharacter(const TArray<struct FClimbablePointData>& pointsToFilter, float dotThreshold)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "Filter_IsFacingCharacter");

	Params::ClimbingCondition_Filter_IsFacingCharacter Parms{};

	Parms.pointsToFilter = std::move(pointsToFilter);
	Parms.dotThreshold = dotThreshold;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.Filter_IsInReach
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FClimbablePointData>&pointsToFilter                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FClimbablePointData>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FClimbablePointData> UClimbingCondition::Filter_IsInReach(const TArray<struct FClimbablePointData>& pointsToFilter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "Filter_IsInReach");

	Params::ClimbingCondition_Filter_IsInReach Parms{};

	Parms.pointsToFilter = std::move(pointsToFilter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.GetCharacterLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UClimbingCondition::GetCharacterLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "GetCharacterLocation");

	Params::ClimbingCondition_GetCharacterLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.GetClimbingIntent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FClimbingIntent                  ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FClimbingIntent UClimbingCondition::GetClimbingIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "GetClimbingIntent");

	Params::ClimbingCondition_GetClimbingIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.GetLedgeClimbConditionSettings
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FLedgeClimbConditionSettings     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FLedgeClimbConditionSettings UClimbingCondition::GetLedgeClimbConditionSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "GetLedgeClimbConditionSettings");

	Params::ClimbingCondition_GetLedgeClimbConditionSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.GetPointOfQuery
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UClimbingCondition::GetPointOfQuery() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "GetPointOfQuery");

	Params::ClimbingCondition_GetPointOfQuery Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.IsSurfaceClimbing
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingCondition::IsSurfaceClimbing() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "IsSurfaceClimbing");

	Params::ClimbingCondition_IsSurfaceClimbing Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingCondition.WantsToClimb
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingCondition::WantsToClimb() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingCondition", "WantsToClimb");

	Params::ClimbingCondition_WantsToClimb Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.DoesPlatformSupportGameShare
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::DoesPlatformSupportGameShare()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "DoesPlatformSupportGameShare");

	Params::EverholmGameShareManager_DoesPlatformSupportGameShare Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.Get
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmGameShareManager*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmGameShareManager* UEverholmGameShareManager::Get(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "Get");

	Params::EverholmGameShareManager_Get Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.GetGameShareButtonIsVisible
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmGameShareButton                Button                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::GetGameShareButtonIsVisible(const class UObject* WorldContextObject, EEverholmGameShareButton Button)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "GetGameShareButtonIsVisible");

	Params::EverholmGameShareManager_GetGameShareButtonIsVisible Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Button = Button;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.GetGameShareButtonVisibility
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmGameShareButton                Button                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ESlateVisibility                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESlateVisibility UEverholmGameShareManager::GetGameShareButtonVisibility(const class UObject* WorldContextObject, EEverholmGameShareButton Button)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "GetGameShareButtonVisibility");

	Params::EverholmGameShareManager_GetGameShareButtonVisibility Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Button = Button;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.GetInitialGameShareButtonFocus
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCommonButtonBase*                startLocal                                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCommonButtonBase*                startInternet                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCommonButtonBase*                Stop                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCommonButtonBase*                Back                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCommonButtonBase*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UCommonButtonBase* UEverholmGameShareManager::GetInitialGameShareButtonFocus(const class UObject* WorldContextObject, class UCommonButtonBase* startLocal, class UCommonButtonBase* startInternet, class UCommonButtonBase* Stop, class UCommonButtonBase* Back)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "GetInitialGameShareButtonFocus");

	Params::EverholmGameShareManager_GetInitialGameShareButtonFocus Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.startLocal = startLocal;
	Parms.startInternet = startInternet;
	Parms.Stop = Stop;
	Parms.Back = Back;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.IsGameChatActive
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::IsGameChatActive(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "IsGameChatActive");

	Params::EverholmGameShareManager_IsGameChatActive Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.IsGameShareInitialized
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::IsGameShareInitialized(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "IsGameShareInitialized");

	Params::EverholmGameShareManager_IsGameShareInitialized Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.IsGameSharePlayerAllowedToPauseGame
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class APlayerController*          PlayerController                                       (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::IsGameSharePlayerAllowedToPauseGame(const class UObject* WorldContextObject, const class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "IsGameSharePlayerAllowedToPauseGame");

	Params::EverholmGameShareManager_IsGameSharePlayerAllowedToPauseGame Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.IsGameShareSessionActive
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::IsGameShareSessionActive(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "IsGameShareSessionActive");

	Params::EverholmGameShareManager_IsGameShareSessionActive Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.IsGameShareSessionViaChatActive
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::IsGameShareSessionViaChatActive(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "IsGameShareSessionViaChatActive");

	Params::EverholmGameShareManager_IsGameShareSessionViaChatActive Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.IsLocalGameShareSessionActive
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameShareManager::IsLocalGameShareSessionActive(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "IsLocalGameShareSessionActive");

	Params::EverholmGameShareManager_IsLocalGameShareSessionActive Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameShareManager.StartInternetGameShareSession
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameShareManager::StartInternetGameShareSession(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "StartInternetGameShareSession");

	Params::EverholmGameShareManager_StartInternetGameShareSession Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameShareManager.StartLocalGameShareSession
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameShareManager::StartLocalGameShareSession(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "StartLocalGameShareSession");

	Params::EverholmGameShareManager_StartLocalGameShareSession Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameShareManager.StopGameShareSession
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameShareManager::StopGameShareSession(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameShareManager", "StopGameShareSession");

	Params::EverholmGameShareManager_StopGameShareSession Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlayerNameWidget.GetOwningPlayerName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPlayerNameWidget::GetOwningPlayerName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerNameWidget", "GetOwningPlayerName");

	Params::PlayerNameWidget_GetOwningPlayerName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.GetAllClosestClimbablePointsAtLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EClimbGatheringIntent                   gatheringIntent                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FClimbablePointData>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FClimbablePointData> UClimbingComponent::GetAllClosestClimbablePointsAtLocation(const struct FVector& Location, EClimbGatheringIntent gatheringIntent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "GetAllClosestClimbablePointsAtLocation");

	Params::ClimbingComponent_GetAllClosestClimbablePointsAtLocation Parms{};

	Parms.Location = std::move(Location);
	Parms.gatheringIntent = gatheringIntent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.OnLedgeClimbAlignmentFinished
// (Final, Native, Public)
// Parameters:
// EEndAlignmentResult                     endResult                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UClimbingComponent::OnLedgeClimbAlignmentFinished(EEndAlignmentResult endResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "OnLedgeClimbAlignmentFinished");

	Params::ClimbingComponent_OnLedgeClimbAlignmentFinished Parms{};

	Parms.endResult = endResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ClimbingComponent.StartWantToClimb
// (Final, Native, Public, BlueprintCallable)

void UClimbingComponent::StartWantToClimb()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "StartWantToClimb");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ClimbingComponent.StopWantToClimb
// (Final, Native, Public, BlueprintCallable)

void UClimbingComponent::StopWantToClimb()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "StopWantToClimb");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ClimbingComponent.TryLedgeClimb
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FClimbablePointData&       Target                                                 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              bIsImmediate                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::TryLedgeClimb(const struct FClimbablePointData& Target, const bool bIsImmediate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "TryLedgeClimb");

	Params::ClimbingComponent_TryLedgeClimb Parms{};

	Parms.Target = std::move(Target);
	Parms.bIsImmediate = bIsImmediate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.TrySurfaceClimb
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FClimbablePointData&       climbTo                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::TrySurfaceClimb(const struct FClimbablePointData& climbTo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "TrySurfaceClimb");

	Params::ClimbingComponent_TrySurfaceClimb Parms{};

	Parms.climbTo = std::move(climbTo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.TrySurfaceClimbHandOver
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FClimbablePointData&       climbTo                                                (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const bool                              isInitialClimbStep                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Duration                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EClimbingDirectionVertical        Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EClimbingPose                     EndingPose                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::TrySurfaceClimbHandOver(const struct FClimbablePointData& climbTo, const bool isInitialClimbStep, const float Duration, const EClimbingDirectionVertical Direction, const EClimbingPose EndingPose)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "TrySurfaceClimbHandOver");

	Params::ClimbingComponent_TrySurfaceClimbHandOver Parms{};

	Parms.climbTo = std::move(climbTo);
	Parms.isInitialClimbStep = isInitialClimbStep;
	Parms.Duration = Duration;
	Parms.Direction = Direction;
	Parms.EndingPose = EndingPose;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.GetClimbingIntent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FClimbingIntent                  ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FClimbingIntent UClimbingComponent::GetClimbingIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "GetClimbingIntent");

	Params::ClimbingComponent_GetClimbingIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.GetClimbingReference
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UObject* UClimbingComponent::GetClimbingReference() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "GetClimbingReference");

	Params::ClimbingComponent_GetClimbingReference Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.GetCustomClimbActionInstance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAbstractEnum&             CustomAction                                           (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UCustomClimbAction*>       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UCustomClimbAction*> UClimbingComponent::GetCustomClimbActionInstance(const struct FAbstractEnum& CustomAction) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "GetCustomClimbActionInstance");

	Params::ClimbingComponent_GetCustomClimbActionInstance Parms{};

	Parms.CustomAction = std::move(CustomAction);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.GetHasClimbPointInReach
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::GetHasClimbPointInReach() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "GetHasClimbPointInReach");

	Params::ClimbingComponent_GetHasClimbPointInReach Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.IsHanging
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::IsHanging() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "IsHanging");

	Params::ClimbingComponent_IsHanging Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.IsInDetectionArea
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UClimbDetectionArea*              Area                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::IsInDetectionArea(class UClimbDetectionArea* Area, const struct FVector& Location) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "IsInDetectionArea");

	Params::ClimbingComponent_IsInDetectionArea Parms{};

	Parms.Area = Area;
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.IsSurfaceClimbing
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::IsSurfaceClimbing() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "IsSurfaceClimbing");

	Params::ClimbingComponent_IsSurfaceClimbing Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbingComponent.WantsToClimb
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbingComponent::WantsToClimb() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbingComponent", "WantsToClimb");

	Params::ClimbingComponent_WantsToClimb Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LedgeClimbChooserContext.Reset
// (Native, Event, Public, BlueprintEvent)

void ULedgeClimbChooserContext::Reset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LedgeClimbChooserContext", "Reset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LedgeClimbChooserContext.Set
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               climbingCharacter                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              IsMovingOnGround                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              IsCrouching                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              wantsToSprint                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              isMovingUpwards                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              isComingFromHoist                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EEverholmCharacterMovementMode    MovementMode_0                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ELedgeTraversalType               traversalType_0                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             heightDiff                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             LedgeHeight_0                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLedgeMetaData&            MetaData_0                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const ESuspenseThreatLevel              threatLevel_0                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ELedgeClimbState                  NextState_0                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   alignmentOffset                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             triggerRadius_0                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   motionWarpingOffset                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULedgeClimbChooserContext::Set(class AEverholmCharacter* climbingCharacter, const bool IsMovingOnGround, const bool IsCrouching, const bool wantsToSprint, const bool isMovingUpwards, const bool isComingFromHoist, const EEverholmCharacterMovementMode MovementMode_0, const ELedgeTraversalType traversalType_0, const float heightDiff, const float LedgeHeight_0, const struct FLedgeMetaData& MetaData_0, const ESuspenseThreatLevel threatLevel_0, const ELedgeClimbState NextState_0, const struct FVector& alignmentOffset, const float triggerRadius_0, const struct FVector& motionWarpingOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LedgeClimbChooserContext", "Set");

	Params::LedgeClimbChooserContext_Set Parms{};

	Parms.climbingCharacter = climbingCharacter;
	Parms.IsMovingOnGround = IsMovingOnGround;
	Parms.IsCrouching = IsCrouching;
	Parms.wantsToSprint = wantsToSprint;
	Parms.isMovingUpwards = isMovingUpwards;
	Parms.isComingFromHoist = isComingFromHoist;
	Parms.MovementMode_0 = MovementMode_0;
	Parms.traversalType_0 = traversalType_0;
	Parms.heightDiff = heightDiff;
	Parms.LedgeHeight_0 = LedgeHeight_0;
	Parms.MetaData_0 = std::move(MetaData_0);
	Parms.threatLevel_0 = threatLevel_0;
	Parms.NextState_0 = NextState_0;
	Parms.alignmentOffset = std::move(alignmentOffset);
	Parms.triggerRadius_0 = triggerRadius_0;
	Parms.motionWarpingOffset = std::move(motionWarpingOffset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LedgeHangChooserContext.Reset
// (Native, Event, Public, BlueprintEvent)

void ULedgeHangChooserContext::Reset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LedgeHangChooserContext", "Reset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LedgeHangChooserContext.Set
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               climbingCharacter                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              isComingFromHoist                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ELedgeTraversalType               traversalType_0                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLedgeMetaData&            MetaData_0                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const ESuspenseThreatLevel              threatLevel_0                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULedgeHangChooserContext::Set(class AEverholmCharacter* climbingCharacter, const bool isComingFromHoist, const ELedgeTraversalType traversalType_0, const struct FLedgeMetaData& MetaData_0, const ESuspenseThreatLevel threatLevel_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LedgeHangChooserContext", "Set");

	Params::LedgeHangChooserContext_Set Parms{};

	Parms.climbingCharacter = climbingCharacter;
	Parms.isComingFromHoist = isComingFromHoist;
	Parms.traversalType_0 = traversalType_0;
	Parms.MetaData_0 = std::move(MetaData_0);
	Parms.threatLevel_0 = threatLevel_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SheepSkinVehicleActor.AreAllKidsUnderSkin
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ASheepSkinVehicleActor::AreAllKidsUnderSkin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinVehicleActor", "AreAllKidsUnderSkin");

	Params::SheepSkinVehicleActor_AreAllKidsUnderSkin Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SheepSkinVehicleActor.ForceExitAllNPC
// (Final, Native, Protected, BlueprintCallable)

void ASheepSkinVehicleActor::ForceExitAllNPC()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinVehicleActor", "ForceExitAllNPC");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SheepSkinVehicleActor.NPCEntered
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const EPlayerPawnType                   pawnType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASheepSkinVehicleActor::NPCEntered(const EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinVehicleActor", "NPCEntered");

	Params::SheepSkinVehicleActor_NPCEntered Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SheepSkinVehicleActor.NPCEnterUnderSkinEvent
// (Event, Protected, BlueprintEvent)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASheepSkinVehicleActor::NPCEnterUnderSkinEvent(EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinVehicleActor", "NPCEnterUnderSkinEvent");

	Params::SheepSkinVehicleActor_NPCEnterUnderSkinEvent Parms{};

	Parms.pawnType = pawnType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.SheepSkinVehicleActor.NPCExitUnderSkinEvent
// (Event, Protected, BlueprintEvent)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASheepSkinVehicleActor::NPCExitUnderSkinEvent(EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinVehicleActor", "NPCExitUnderSkinEvent");

	Params::SheepSkinVehicleActor_NPCExitUnderSkinEvent Parms{};

	Parms.pawnType = pawnType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.SheepSkinVehicleActor.OnRep_NPCUnderSkinArray
// (Final, Native, Protected)
// Parameters:
// const TArray<EPlayerPawnType>&          local_NPCUnderSkinArray                                (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void ASheepSkinVehicleActor::OnRep_NPCUnderSkinArray(const TArray<EPlayerPawnType>& local_NPCUnderSkinArray)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinVehicleActor", "OnRep_NPCUnderSkinArray");

	Params::SheepSkinVehicleActor_OnRep_NPCUnderSkinArray Parms{};

	Parms.local_NPCUnderSkinArray = std::move(local_NPCUnderSkinArray);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LedgeClimbExitChooserContext.Reset
// (Native, Event, Public, BlueprintEvent)

void ULedgeClimbExitChooserContext::Reset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LedgeClimbExitChooserContext", "Reset");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.LedgeClimbExitChooserContext.Set
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               climbingCharacter                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              isComingFromHoist                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ELedgeTraversalType               traversalType_0                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLedgeMetaData&            MetaData_0                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const ESuspenseThreatLevel              threatLevel_0                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   motionWarpingOffset                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ULedgeClimbExitChooserContext::Set(class AEverholmCharacter* climbingCharacter, const bool isComingFromHoist, const ELedgeTraversalType traversalType_0, const struct FLedgeMetaData& MetaData_0, const ESuspenseThreatLevel threatLevel_0, const struct FVector& motionWarpingOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LedgeClimbExitChooserContext", "Set");

	Params::LedgeClimbExitChooserContext_Set Parms{};

	Parms.climbingCharacter = climbingCharacter;
	Parms.isComingFromHoist = isComingFromHoist;
	Parms.traversalType_0 = traversalType_0;
	Parms.MetaData_0 = std::move(MetaData_0);
	Parms.threatLevel_0 = threatLevel_0;
	Parms.motionWarpingOffset = std::move(motionWarpingOffset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnInteract
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnInteract(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnInteract");

	Params::InteractionComponentEventContext_OnInteract Parms{};

	Parms.Initiator = Initiator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnInteractEnd
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnInteractEnd(class APawn* Initiator, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnInteractEnd");

	Params::InteractionComponentEventContext_OnInteractEnd Parms{};

	Parms.Initiator = Initiator;
	Parms.interactEndReason = interactEndReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnInteractFailed
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnInteractFailed(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnInteractFailed");

	Params::InteractionComponentEventContext_OnInteractFailed Parms{};

	Parms.Initiator = Initiator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnInteractFocus
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bHasFocus                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnInteractFocus(class APawn* Initiator, bool bHasFocus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnInteractFocus");

	Params::InteractionComponentEventContext_OnInteractFocus Parms{};

	Parms.Initiator = Initiator;
	Parms.bHasFocus = bHasFocus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnPrepareEndInteraction
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnPrepareEndInteraction(class AEverholmCharacter* interactor, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnPrepareEndInteraction");

	Params::InteractionComponentEventContext_OnPrepareEndInteraction Parms{};

	Parms.interactor = interactor;
	Parms.interactEndReason = interactEndReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnPrepareStartInteraction
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnPrepareStartInteraction(class AEverholmCharacter* interactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnPrepareStartInteraction");

	Params::InteractionComponentEventContext_OnPrepareStartInteraction Parms{};

	Parms.interactor = interactor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnSharedEventTriggered
// (Final, Native, Private)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnSharedEventTriggered(class FName EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnSharedEventTriggered");

	Params::InteractionComponentEventContext_OnSharedEventTriggered Parms{};

	Parms.EventName = EventName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InteractionComponentEventContext.OnValueChanged
// (Final, Native, Private)
// Parameters:
// ESharedInteractableValueID              ID                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsInitialization                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInteractionComponentEventContext::OnValueChanged(ESharedInteractableValueID ID, int32 NewValue, bool bIsInitialization)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InteractionComponentEventContext", "OnValueChanged");

	Params::InteractionComponentEventContext_OnValueChanged Parms{};

	Parms.ID = ID;
	Parms.NewValue = NewValue;
	Parms.bIsInitialization = bIsInitialization;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CustomClimbAction.ExecuteAction
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FClimbablePointData&       Target                                                 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCustomClimbAction::ExecuteAction(class AEverholmCharacter* Initiator, const struct FClimbablePointData& Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomClimbAction", "ExecuteAction");

	Params::CustomClimbAction_ExecuteAction Parms{};

	Parms.Initiator = Initiator;
	Parms.Target = std::move(Target);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CustomClimbAction.GetClimbingComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UClimbingComponent*               ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UClimbingComponent* UCustomClimbAction::GetClimbingComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomClimbAction", "GetClimbingComponent");

	Params::CustomClimbAction_GetClimbingComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CustomClimbAction.GetEverholmCharacterMovementComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmCharacterMovementComponent*ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmCharacterMovementComponent* UCustomClimbAction::GetEverholmCharacterMovementComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomClimbAction", "GetEverholmCharacterMovementComponent");

	Params::CustomClimbAction_GetEverholmCharacterMovementComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ClimbDetectionArea.GetPointOfQuery
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FClimbingIntent&           Intent                                                 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UClimbDetectionArea::GetPointOfQuery(class AEverholmCharacter* Initiator, const struct FClimbingIntent& Intent) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbDetectionArea", "GetPointOfQuery");

	Params::ClimbDetectionArea_GetPointOfQuery Parms{};

	Parms.Initiator = Initiator;
	Parms.Intent = std::move(Intent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmHumbug.OnDetachFromTarget_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   DetachmentOffset                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::OnDetachFromTarget_Multicast(const struct FVector& DetachmentOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnDetachFromTarget_Multicast");

	Params::EverholmHumbug_OnDetachFromTarget_Multicast Parms{};

	Parms.DetachmentOffset = std::move(DetachmentOffset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnHitWallEnd
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::OnHitWallEnd(class AEverholmCharacter* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnHitWallEnd");

	Params::EverholmHumbug_OnHitWallEnd Parms{};

	Parms.Initiator = Initiator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnLerpingEnd
// (Final, Native, Public)

void AEverholmHumbug::OnLerpingEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnLerpingEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnLerpingStart
// (Final, Native, Public)
// Parameters:
// const float                             TotalDuration                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::OnLerpingStart(const float TotalDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnLerpingStart");

	Params::EverholmHumbug_OnLerpingStart Parms{};

	Parms.TotalDuration = TotalDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnPickupHumbugHit
// (Final, Native, Private, HasOutParams, HasDefaults)
// Parameters:
// class AActor*                           SelfActor                                              (Parm, ZeroConstructor, 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 AEverholmHumbug::OnPickupHumbugHit(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnPickupHumbugHit");

	Params::EverholmHumbug_OnPickupHumbugHit Parms{};

	Parms.SelfActor = SelfActor;
	Parms.OtherActor = OtherActor;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnPickupPickedUp
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::OnPickupPickedUp(class AEverholmCharacter* Initiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnPickupPickedUp");

	Params::EverholmHumbug_OnPickupPickedUp Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnPickupPutDown
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::OnPickupPutDown(class AEverholmCharacter* Initiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnPickupPutDown");

	Params::EverholmHumbug_OnPickupPutDown Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnPickupThrown
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::OnPickupThrown(class AEverholmCharacter* Initiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnPickupThrown");

	Params::EverholmHumbug_OnPickupThrown Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnProjectileStop
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AEverholmHumbug::OnProjectileStop(class AEverholmCharacter* Initiator, class APickupBase* pickup, const struct FHitResult& ImpactResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnProjectileStop");

	Params::EverholmHumbug_OnProjectileStop Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;
	Parms.ImpactResult = std::move(ImpactResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.OnRep_PickupHumbug
// (Final, Native, Private)

void AEverholmHumbug::OnRep_PickupHumbug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "OnRep_PickupHumbug");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.RequestPickupDrop_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void AEverholmHumbug::RequestPickupDrop_Multicast()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "RequestPickupDrop_Multicast");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.SetIsAttached
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsAttached                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::SetIsAttached(bool bInIsAttached)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "SetIsAttached");

	Params::EverholmHumbug_SetIsAttached Parms{};

	Parms.bInIsAttached = bInIsAttached;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.SetPacified
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsPacified                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::SetPacified(bool bInIsPacified)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "SetPacified");

	Params::EverholmHumbug_SetPacified Parms{};

	Parms.bInIsPacified = bInIsPacified;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.SetTargetLerpingInfo_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              TargetComponent                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TargetSocket                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::SetTargetLerpingInfo_Multicast(class UPrimitiveComponent* TargetComponent, class FName TargetSocket)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "SetTargetLerpingInfo_Multicast");

	Params::EverholmHumbug_SetTargetLerpingInfo_Multicast Parms{};

	Parms.TargetComponent = TargetComponent;
	Parms.TargetSocket = TargetSocket;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.UpdateHumbugCollision
// (Event, Protected, BlueprintEvent)
// Parameters:
// EHumbugSimulationType                   SimulationType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::UpdateHumbugCollision(EHumbugSimulationType SimulationType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "UpdateHumbugCollision");

	Params::EverholmHumbug_UpdateHumbugCollision Parms{};

	Parms.SimulationType = SimulationType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmHumbug.UpdateHumbugCollision_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private, BlueprintCallable)
// Parameters:
// EHumbugSimulationType                   SimulationType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::UpdateHumbugCollision_Multicast(EHumbugSimulationType SimulationType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "UpdateHumbugCollision_Multicast");

	Params::EverholmHumbug_UpdateHumbugCollision_Multicast Parms{};

	Parms.SimulationType = SimulationType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmHumbug.UpdateHumbugSimulation
// (Event, Protected, BlueprintEvent)
// Parameters:
// EHumbugSimulationType                   SimulationType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmHumbug::UpdateHumbugSimulation(EHumbugSimulationType SimulationType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "UpdateHumbugSimulation");

	Params::EverholmHumbug_UpdateHumbugSimulation Parms{};

	Parms.SimulationType = SimulationType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmHumbug.GetIsAttached
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmHumbug::GetIsAttached() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "GetIsAttached");

	Params::EverholmHumbug_GetIsAttached Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmHumbug.GetIsPacified
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmHumbug::GetIsPacified() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "GetIsPacified");

	Params::EverholmHumbug_GetIsPacified Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmHumbug.GetIsPickedUp
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmHumbug::GetIsPickedUp() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "GetIsPickedUp");

	Params::EverholmHumbug_GetIsPickedUp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmHumbug.GetIsThrown
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmHumbug::GetIsThrown() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmHumbug", "GetIsThrown");

	Params::EverholmHumbug_GetIsThrown Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CompanionInteractionComponent.TryStopAllInteractors
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UEverholmInteractionComponent*    specificInteractionComponent                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCompanionInteractionComponent::TryStopAllInteractors(class UEverholmInteractionComponent* specificInteractionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CompanionInteractionComponent", "TryStopAllInteractors");

	Params::CompanionInteractionComponent_TryStopAllInteractors Parms{};

	Parms.specificInteractionComponent = specificInteractionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CompanionInteractionComponent.TryStopCompanionInteractor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UEverholmInteractionComponent*    specificInteractionComponent                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCompanionInteractionComponent::TryStopCompanionInteractor(class UEverholmInteractionComponent* specificInteractionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CompanionInteractionComponent", "TryStopCompanionInteractor");

	Params::CompanionInteractionComponent_TryStopCompanionInteractor Parms{};

	Parms.specificInteractionComponent = specificInteractionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CompanionInteractionComponent.TryStopNPCKidInteractor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         kidType                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmInteractionComponent*    specificInteractionComponent                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCompanionInteractionComponent::TryStopNPCKidInteractor(EPlayerPawnType kidType, class UEverholmInteractionComponent* specificInteractionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CompanionInteractionComponent", "TryStopNPCKidInteractor");

	Params::CompanionInteractionComponent_TryStopNPCKidInteractor Parms{};

	Parms.kidType = kidType;
	Parms.specificInteractionComponent = specificInteractionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.CompassWidget.GetFlatCameraForward
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UCompassWidget::GetFlatCameraForward() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CompassWidget", "GetFlatCameraForward");

	Params::CompassWidget_GetFlatCameraForward Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CompassWidget.GetNorthVector
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UCompassWidget::GetNorthVector() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CompassWidget", "GetNorthVector");

	Params::CompassWidget_GetNorthVector Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.AreAllPlayersAlive
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::AreAllPlayersAlive(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "AreAllPlayersAlive");

	Params::CoOpBlueprintFunctionLibrary_AreAllPlayersAlive Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.EverholmSessionStartedAsSinglePlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::EverholmSessionStartedAsSinglePlayer(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "EverholmSessionStartedAsSinglePlayer");

	Params::CoOpBlueprintFunctionLibrary_EverholmSessionStartedAsSinglePlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetBoyController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AController* UCoOpBlueprintFunctionLibrary::GetBoyController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetBoyController");

	Params::CoOpBlueprintFunctionLibrary_GetBoyController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetBoyPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetBoyPlayerCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetBoyPlayerCharacter");

	Params::CoOpBlueprintFunctionLibrary_GetBoyPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetBoyPlayerController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerController*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerController* UCoOpBlueprintFunctionLibrary::GetBoyPlayerController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetBoyPlayerController");

	Params::CoOpBlueprintFunctionLibrary_GetBoyPlayerController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetBoyReference
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPlayerReferenceData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPlayerReferenceData UCoOpBlueprintFunctionLibrary::GetBoyReference(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetBoyReference");

	Params::CoOpBlueprintFunctionLibrary_GetBoyReference Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetCompanionAIController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AAIController*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AAIController* UCoOpBlueprintFunctionLibrary::GetCompanionAIController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetCompanionAIController");

	Params::CoOpBlueprintFunctionLibrary_GetCompanionAIController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetCompanionAIPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetCompanionAIPlayerCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetCompanionAIPlayerCharacter");

	Params::CoOpBlueprintFunctionLibrary_GetCompanionAIPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetControllers
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AController*>              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AController*> UCoOpBlueprintFunctionLibrary::GetControllers(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetControllers");

	Params::CoOpBlueprintFunctionLibrary_GetControllers Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetEverholmBaseHUD
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmBaseHUD*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmBaseHUD* UCoOpBlueprintFunctionLibrary::GetEverholmBaseHUD(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetEverholmBaseHUD");

	Params::CoOpBlueprintFunctionLibrary_GetEverholmBaseHUD Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetEverholmGameMode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEVRGameMode                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EEVRGameMode UCoOpBlueprintFunctionLibrary::GetEverholmGameMode(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetEverholmGameMode");

	Params::CoOpBlueprintFunctionLibrary_GetEverholmGameMode Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetEverholmPlayerController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AEverholmPlayerCharacter*         inCharacter                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerController*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerController* UCoOpBlueprintFunctionLibrary::GetEverholmPlayerController(class AEverholmPlayerCharacter* inCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetEverholmPlayerController");

	Params::CoOpBlueprintFunctionLibrary_GetEverholmPlayerController Parms{};

	Parms.inCharacter = inCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetEverholmSessionMode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmSessionMode                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EEverholmSessionMode UCoOpBlueprintFunctionLibrary::GetEverholmSessionMode(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetEverholmSessionMode");

	Params::CoOpBlueprintFunctionLibrary_GetEverholmSessionMode Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetFirstLocallyControlledPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetFirstLocallyControlledPlayerCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetFirstLocallyControlledPlayerCharacter");

	Params::CoOpBlueprintFunctionLibrary_GetFirstLocallyControlledPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetGirlController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AController* UCoOpBlueprintFunctionLibrary::GetGirlController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetGirlController");

	Params::CoOpBlueprintFunctionLibrary_GetGirlController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetGirlPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetGirlPlayerCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetGirlPlayerCharacter");

	Params::CoOpBlueprintFunctionLibrary_GetGirlPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetGirlPlayerController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerController*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerController* UCoOpBlueprintFunctionLibrary::GetGirlPlayerController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetGirlPlayerController");

	Params::CoOpBlueprintFunctionLibrary_GetGirlPlayerController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetGirlReference
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPlayerReferenceData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPlayerReferenceData UCoOpBlueprintFunctionLibrary::GetGirlReference(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetGirlReference");

	Params::CoOpBlueprintFunctionLibrary_GetGirlReference Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetHumanPlayerCount
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UCoOpBlueprintFunctionLibrary::GetHumanPlayerCount(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetHumanPlayerCount");

	Params::CoOpBlueprintFunctionLibrary_GetHumanPlayerCount Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetLocalPlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class APlayerController*          InPlayerController                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ULocalPlayer*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULocalPlayer* UCoOpBlueprintFunctionLibrary::GetLocalPlayer(const class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetLocalPlayer");

	Params::CoOpBlueprintFunctionLibrary_GetLocalPlayer Parms{};

	Parms.InPlayerController = InPlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetNPCKidsCount
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UCoOpBlueprintFunctionLibrary::GetNPCKidsCount(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetNPCKidsCount");

	Params::CoOpBlueprintFunctionLibrary_GetNPCKidsCount Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetOtherPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmPlayerCharacter*   Player                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetOtherPlayerCharacter(const class UObject* WorldContextObject, const class AEverholmPlayerCharacter* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetOtherPlayerCharacter");

	Params::CoOpBlueprintFunctionLibrary_GetOtherPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerCharacterByType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetPlayerCharacterByType(const class UObject* WorldContextObject, EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerCharacterByType");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerCharacterByType Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerCharacterNearestLocation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bUse2DDistance                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDisregardCompanion                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetPlayerCharacterNearestLocation(const class UObject* WorldContextObject, const struct FVector& Location, const bool bUse2DDistance, const bool bDisregardCompanion)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerCharacterNearestLocation");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerCharacterNearestLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Location = std::move(Location);
	Parms.bUse2DDistance = bUse2DDistance;
	Parms.bDisregardCompanion = bDisregardCompanion;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerCharacters
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AEverholmPlayerCharacter*> ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AEverholmPlayerCharacter*> UCoOpBlueprintFunctionLibrary::GetPlayerCharacters(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerCharacters");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerCharacters Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerControllers
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AEverholmPlayerController*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AEverholmPlayerController*> UCoOpBlueprintFunctionLibrary::GetPlayerControllers(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerControllers");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerControllers Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerManagerSubsystem
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmPlayerManagerSubsystem*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmPlayerManagerSubsystem* UCoOpBlueprintFunctionLibrary::GetPlayerManagerSubsystem(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerManagerSubsystem");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerManagerSubsystem Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerOneController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AController* UCoOpBlueprintFunctionLibrary::GetPlayerOneController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerOneController");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerOneController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerOnePawn
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APawn* UCoOpBlueprintFunctionLibrary::GetPlayerOnePawn(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerOnePawn");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerOnePawn Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerOnePlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetPlayerOnePlayerCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerOnePlayerCharacter");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerOnePlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerOnePlayerController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerController*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerController* UCoOpBlueprintFunctionLibrary::GetPlayerOnePlayerController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerOnePlayerController");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerOnePlayerController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerOnePlayerState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerState*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerState* UCoOpBlueprintFunctionLibrary::GetPlayerOnePlayerState(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerOnePlayerState");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerOnePlayerState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerOneReference
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPlayerReferenceData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPlayerReferenceData UCoOpBlueprintFunctionLibrary::GetPlayerOneReference(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerOneReference");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerOneReference Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayersCount
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UCoOpBlueprintFunctionLibrary::GetPlayersCount(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayersCount");

	Params::CoOpBlueprintFunctionLibrary_GetPlayersCount Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerTwoController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AController* UCoOpBlueprintFunctionLibrary::GetPlayerTwoController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerTwoController");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerTwoController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerTwoPawn
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APawn* UCoOpBlueprintFunctionLibrary::GetPlayerTwoPawn(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerTwoPawn");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerTwoPawn Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerTwoPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UCoOpBlueprintFunctionLibrary::GetPlayerTwoPlayerCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerTwoPlayerCharacter");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerTwoPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerTwoPlayerController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerController*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerController* UCoOpBlueprintFunctionLibrary::GetPlayerTwoPlayerController(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerTwoPlayerController");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerTwoPlayerController Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerTwoPlayerState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerState*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerState* UCoOpBlueprintFunctionLibrary::GetPlayerTwoPlayerState(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerTwoPlayerState");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerTwoPlayerState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetPlayerTwoReference
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FPlayerReferenceData             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPlayerReferenceData UCoOpBlueprintFunctionLibrary::GetPlayerTwoReference(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetPlayerTwoReference");

	Params::CoOpBlueprintFunctionLibrary_GetPlayerTwoReference Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.GetRegisteredPlayerCharacters
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AEverholmPlayerCharacter*> ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AEverholmPlayerCharacter*> UCoOpBlueprintFunctionLibrary::GetRegisteredPlayerCharacters(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "GetRegisteredPlayerCharacters");

	Params::CoOpBlueprintFunctionLibrary_GetRegisteredPlayerCharacters Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.IsAnyPlayerByWater
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::IsAnyPlayerByWater(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "IsAnyPlayerByWater");

	Params::CoOpBlueprintFunctionLibrary_IsAnyPlayerByWater Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.IsAnyPlayerDead
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::IsAnyPlayerDead(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "IsAnyPlayerDead");

	Params::CoOpBlueprintFunctionLibrary_IsAnyPlayerDead Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.IsCharacterNPC
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::IsCharacterNPC(class UObject* WorldContextObject, class AEverholmPlayerCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "IsCharacterNPC");

	Params::CoOpBlueprintFunctionLibrary_IsCharacterNPC Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.IsPawnTypeNPC
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::IsPawnTypeNPC(class UObject* WorldContextObject, EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "IsPawnTypeNPC");

	Params::CoOpBlueprintFunctionLibrary_IsPawnTypeNPC Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.IsPlayerAlive
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::IsPlayerAlive(class UObject* WorldContextObject, EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "IsPlayerAlive");

	Params::CoOpBlueprintFunctionLibrary_IsPlayerAlive Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.IsUsingUnifiedInventory
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::IsUsingUnifiedInventory(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "IsUsingUnifiedInventory");

	Params::CoOpBlueprintFunctionLibrary_IsUsingUnifiedInventory Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.ShouldDisableCheckpoints
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCoOpBlueprintFunctionLibrary::ShouldDisableCheckpoints(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "ShouldDisableCheckpoints");

	Params::CoOpBlueprintFunctionLibrary_ShouldDisableCheckpoints Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.TriggerOnLocalCharacterSpawn
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter**        playerPawn                                             (Parm, OutParm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UCoOpBlueprintFunctionLibrary::TriggerOnLocalCharacterSpawn(class UObject* WorldContext, const struct FLatentActionInfo& LatentInfo, EPlayerPawnType pawnType, class AEverholmPlayerCharacter** playerPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "TriggerOnLocalCharacterSpawn");

	Params::CoOpBlueprintFunctionLibrary_TriggerOnLocalCharacterSpawn Parms{};

	Parms.WorldContext = WorldContext;
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (playerPawn != nullptr)
		*playerPawn = Parms.playerPawn;
}


// Function Everholm.CoOpBlueprintFunctionLibrary.WaitForPlayersSpawned
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UCoOpBlueprintFunctionLibrary::WaitForPlayersSpawned(class UObject* WorldContext, const struct FLatentActionInfo& LatentInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("CoOpBlueprintFunctionLibrary", "WaitForPlayersSpawned");

	Params::CoOpBlueprintFunctionLibrary_WaitForPlayersSpawned Parms{};

	Parms.WorldContext = WorldContext;
	Parms.LatentInfo = std::move(LatentInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ShadowPlayerCamera.AddShadowActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FShadowActor&              ShadowActor                                            (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AShadowPlayerCamera::AddShadowActor(const struct FShadowActor& ShadowActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerCamera", "AddShadowActor");

	Params::ShadowPlayerCamera_AddShadowActor Parms{};

	Parms.ShadowActor = std::move(ShadowActor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ShadowPlayerCamera.HandlePlayerEnterShadows
// (Final, Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*&        Player                                                 (Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AShadowPlayerCamera::HandlePlayerEnterShadows(class AEverholmPlayerCharacter*& Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerCamera", "HandlePlayerEnterShadows");

	Params::ShadowPlayerCamera_HandlePlayerEnterShadows Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Player = Parms.Player;
}


// Function Everholm.ShadowPlayerCamera.HandlePlayerLeaveShadows
// (Final, Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*&        Player                                                 (Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AShadowPlayerCamera::HandlePlayerLeaveShadows(class AEverholmPlayerCharacter*& Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerCamera", "HandlePlayerLeaveShadows");

	Params::ShadowPlayerCamera_HandlePlayerLeaveShadows Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Player = Parms.Player;
}


// Function Everholm.ShadowPlayerCamera.OnShadowPickupStashed
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsQuickStash                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AShadowPlayerCamera::OnShadowPickupStashed(class AEverholmCharacter* Initiator, bool bIsQuickStash, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerCamera", "OnShadowPickupStashed");

	Params::ShadowPlayerCamera_OnShadowPickupStashed Parms{};

	Parms.Initiator = Initiator;
	Parms.bIsQuickStash = bIsQuickStash;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ShadowPlayerCamera.RemoveShadowActor
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*&                          Actor                                                  (Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AShadowPlayerCamera::RemoveShadowActor(class AActor*& Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerCamera", "RemoveShadowActor");

	Params::ShadowPlayerCamera_RemoveShadowActor Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Actor = Parms.Actor;
}


// Function Everholm.ShadowPlayerCamera.GetDecalOffset
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AShadowPlayerCamera::GetDecalOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerCamera", "GetDecalOffset");

	Params::ShadowPlayerCamera_GetDecalOffset Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.ShadowPlayerCamera.GetPlayerDecal
// (Final, Native, Protected, BlueprintCallable, Const)
// Parameters:
// class UDecalComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UDecalComponent* AShadowPlayerCamera::GetPlayerDecal() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ShadowPlayerCamera", "GetPlayerDecal");

	Params::ShadowPlayerCamera_GetPlayerDecal Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.CopyPlayerActionComponent.IsActionListEmpty
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UCopyPlayerActionComponent::IsActionListEmpty() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CopyPlayerActionComponent", "IsActionListEmpty");

	Params::CopyPlayerActionComponent_IsActionListEmpty Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DamageInterface.TakeReplicatedDamage
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitNormal                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      BoneName                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ShotFromDirection                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               InstigatedBy                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void IDamageInterface::TakeReplicatedDamage(const class UDamageType* DamageType, const struct FVector& HitLocation, const struct FVector& HitNormal, class UPrimitiveComponent* HitComponent, const class FName& BoneName, const struct FVector& ShotFromDirection, class AEverholmCharacter* InstigatedBy, class AActor* DamageCauser, const struct FHitResult& HitInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("DamageInterface", "TakeReplicatedDamage");

	Params::DamageInterface_TakeReplicatedDamage Parms{};

	Parms.DamageType = DamageType;
	Parms.HitLocation = std::move(HitLocation);
	Parms.HitNormal = std::move(HitNormal);
	Parms.HitComponent = HitComponent;
	Parms.BoneName = BoneName;
	Parms.ShotFromDirection = std::move(ShotFromDirection);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.HitInfo = std::move(HitInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DemoMainMenu.OnEndPIE
// (Final, Native, Protected)
// Parameters:
// bool                                    bIsSimulating                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDemoMainMenu::OnEndPIE(bool bIsSimulating)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DemoMainMenu", "OnEndPIE");

	Params::DemoMainMenu_OnEndPIE Parms{};

	Parms.bIsSimulating = bIsSimulating;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DemoMainMenu.OnStartKeyPressed
// (Event, Public, BlueprintEvent)

void UDemoMainMenu::OnStartKeyPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DemoMainMenu", "OnStartKeyPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.DemoMainMenu.RegisterInputPreprocessor
// (Final, Native, Public, BlueprintCallable)

void UDemoMainMenu::RegisterInputPreprocessor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DemoMainMenu", "RegisterInputPreprocessor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DemoMainMenu.UnregisterInputPreprocessor
// (Final, Native, Public, BlueprintCallable)

void UDemoMainMenu::UnregisterInputPreprocessor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DemoMainMenu", "UnregisterInputPreprocessor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WeightedAverageFloatHintProcessor.GetRelevantHintValue
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class ADirectedCameraHint_Base*   hint                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCameraHintInParameters&   Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWeightedAverageFloatHintProcessor::GetRelevantHintValue(const class ADirectedCameraHint_Base* hint, const struct FCameraHintInParameters& Params_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WeightedAverageFloatHintProcessor", "GetRelevantHintValue");

	Params::WeightedAverageFloatHintProcessor_GetRelevantHintValue Parms{};

	Parms.hint = hint;
	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DirectedCameraPreview.BlueprintEditorTick
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADirectedCameraPreview::BlueprintEditorTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DirectedCameraPreview", "BlueprintEditorTick");

	Params::DirectedCameraPreview_BlueprintEditorTick Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.DockBoatActor.SetDockpointActorOnBoat
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ABoatVehicle*                     boat                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ADockBoatActor::SetDockpointActorOnBoat(class ABoatVehicle* boat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DockBoatActor", "SetDockpointActorOnBoat");

	Params::DockBoatActor_SetDockpointActorOnBoat Parms{};

	Parms.boat = boat;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.DockBoatActor.TriggerEnterForOtherPlayer
// (Event, Public, BlueprintEvent)

void ADockBoatActor::TriggerEnterForOtherPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DockBoatActor", "TriggerEnterForOtherPlayer");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.DockCheckpointActor.GetDockBoatActorAtIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ADockBoatActor*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ADockBoatActor* ADockCheckpointActor::GetDockBoatActorAtIndex(int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DockCheckpointActor", "GetDockBoatActorAtIndex");

	Params::DockCheckpointActor_GetDockBoatActorAtIndex Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DockCheckpointActor.GetCheckpointComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UCheckpointComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UCheckpointComponent* ADockCheckpointActor::GetCheckpointComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DockCheckpointActor", "GetCheckpointComponent");

	Params::DockCheckpointActor_GetCheckpointComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SubtitleSystemBlueprintFunctionLibrary.GetSubtitleSystem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USubtitleSubsystem*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USubtitleSubsystem* USubtitleSystemBlueprintFunctionLibrary::GetSubtitleSystem(class UObject* WorldContextObject) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SubtitleSystemBlueprintFunctionLibrary", "GetSubtitleSystem");

	Params::SubtitleSystemBlueprintFunctionLibrary_GetSubtitleSystem Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggablePushBoatComponent.AreAllGrabHelpersInWater
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggablePushBoatComponent::AreAllGrabHelpersInWater()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggablePushBoatComponent", "AreAllGrabHelpersInWater");

	Params::DraggablePushBoatComponent_AreAllGrabHelpersInWater Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggablePushBoatComponent.AreAllStabilizerPointsInWater
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UDraggablePushBoatComponent::AreAllStabilizerPointsInWater()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggablePushBoatComponent", "AreAllStabilizerPointsInWater");

	Params::DraggablePushBoatComponent_AreAllStabilizerPointsInWater Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggablePushBoatComponent.GetCurrentWaterBody
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AWaterBody*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWaterBody* UDraggablePushBoatComponent::GetCurrentWaterBody()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggablePushBoatComponent", "GetCurrentWaterBody");

	Params::DraggablePushBoatComponent_GetCurrentWaterBody Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggablePushBoatComponent.PrepareForEnterBoat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bEnteringBoat                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggablePushBoatComponent::PrepareForEnterBoat(const bool bEnteringBoat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggablePushBoatComponent", "PrepareForEnterBoat");

	Params::DraggablePushBoatComponent_PrepareForEnterBoat Parms{};

	Parms.bEnteringBoat = bEnteringBoat;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggablePushBoatComponent.SetLaunchRotationScalar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   rotScalar                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggablePushBoatComponent::SetLaunchRotationScalar(float rotScalar)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggablePushBoatComponent", "SetLaunchRotationScalar");

	Params::DraggablePushBoatComponent_SetLaunchRotationScalar Parms{};

	Parms.rotScalar = rotScalar;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggablePushBoatComponent.SetLaunchVelocityScalar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   velScalar                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggablePushBoatComponent::SetLaunchVelocityScalar(float velScalar)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggablePushBoatComponent", "SetLaunchVelocityScalar");

	Params::DraggablePushBoatComponent_SetLaunchVelocityScalar Parms{};

	Parms.velScalar = velScalar;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggingMovementMode.Multi_TryExitDragging
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void UDraggingMovementMode::Multi_TryExitDragging()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "Multi_TryExitDragging");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggingMovementMode.OnDragImpact
// (Final, Native, Public, BlueprintCallable)

void UDraggingMovementMode::OnDragImpact()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "OnDragImpact");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggingMovementMode.OnDragStop
// (Final, Native, Public, BlueprintCallable)

void UDraggingMovementMode::OnDragStop()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "OnDragStop");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggingMovementMode.SetTargetAnimationIntent
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Intent                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UDraggingMovementMode::SetTargetAnimationIntent(const struct FVector& Intent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "SetTargetAnimationIntent");

	Params::DraggingMovementMode_SetTargetAnimationIntent Parms{};

	Parms.Intent = std::move(Intent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.DraggingMovementMode.GetCurrentDraggable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UDraggableComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UDraggableComponent* UDraggingMovementMode::GetCurrentDraggable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "GetCurrentDraggable");

	Params::DraggingMovementMode_GetCurrentDraggable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggingMovementMode.GetCurrentGrabHelper
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGrabHelperComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGrabHelperComponent* UDraggingMovementMode::GetCurrentGrabHelper() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "GetCurrentGrabHelper");

	Params::DraggingMovementMode_GetCurrentGrabHelper Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggingMovementMode.GetCurrentlyDraggedObject
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UDraggingMovementMode::GetCurrentlyDraggedObject() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "GetCurrentlyDraggedObject");

	Params::DraggingMovementMode_GetCurrentlyDraggedObject Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.DraggingMovementMode.GetDraggableDraggerRequirements
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EDraggerRequirements                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EDraggerRequirements UDraggingMovementMode::GetDraggableDraggerRequirements() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraggingMovementMode", "GetDraggableDraggerRequirements");

	Params::DraggingMovementMode_GetDraggableDraggerRequirements Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MoverBaseActor.LevelOffsetAdded
// (Event, Protected, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   Offset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMoverBaseActor::LevelOffsetAdded(const struct FVector& Offset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MoverBaseActor", "LevelOffsetAdded");

	Params::MoverBaseActor_LevelOffsetAdded Parms{};

	Parms.Offset = std::move(Offset);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.DraisineMovementComponent.WaitToDecelTimerHandleDone
// (Final, Native, Protected)

void UDraisineMovementComponent::WaitToDecelTimerHandleDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("DraisineMovementComponent", "WaitToDecelTimerHandleDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EnvQueryGenerator_ComponentBase.AddGeneratedComponent
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UActorComponent*                  generatedComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEnvQueryGenerator_ComponentBase::AddGeneratedComponent(class UActorComponent* generatedComponent) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvQueryGenerator_ComponentBase", "AddGeneratedComponent");

	Params::EnvQueryGenerator_ComponentBase_AddGeneratedComponent Parms{};

	Parms.generatedComponent = generatedComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EnvQueryGenerator_ComponentBase.DoItemGeneration
// (Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const TArray<struct FVector>&           ContextLocations                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UEnvQueryGenerator_ComponentBase::DoItemGeneration(const TArray<struct FVector>& ContextLocations) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvQueryGenerator_ComponentBase", "DoItemGeneration");

	Params::EnvQueryGenerator_ComponentBase_DoItemGeneration Parms{};

	Parms.ContextLocations = std::move(ContextLocations);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EnvQueryGenerator_ComponentBase.GetQuerier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UEnvQueryGenerator_ComponentBase::GetQuerier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EnvQueryGenerator_ComponentBase", "GetQuerier");

	Params::EnvQueryGenerator_ComponentBase_GetQuerier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.DisplayAIDebugInfoOnPawn
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             textZOffset                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    Color                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    additionalDebugText                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::DisplayAIDebugInfoOnPawn(class APawn* Pawn, const float textZOffset, const struct FColor& Color, const class FString& additionalDebugText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "DisplayAIDebugInfoOnPawn");

	Params::EverholmAIBlueprintLibrary_DisplayAIDebugInfoOnPawn Parms{};

	Parms.Pawn = Pawn;
	Parms.textZOffset = textZOffset;
	Parms.Color = std::move(Color);
	Parms.additionalDebugText = std::move(additionalDebugText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.ForceDetectKids
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    Instigator                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ForcedPerceivabilityGameplayTag                        (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             detectionRadiusAroundCompanion                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            ignoredActors                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           detectionContext                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              alsoDetectNPCKids                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::ForceDetectKids(const class UObject* Instigator, const struct FGameplayTag& ForcedPerceivabilityGameplayTag, const float detectionRadiusAroundCompanion, const TArray<class AActor*>& ignoredActors, class AActor* detectionContext, const bool alsoDetectNPCKids)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "ForceDetectKids");

	Params::EverholmAIBlueprintLibrary_ForceDetectKids Parms{};

	Parms.Instigator = Instigator;
	Parms.ForcedPerceivabilityGameplayTag = std::move(ForcedPerceivabilityGameplayTag);
	Parms.detectionRadiusAroundCompanion = detectionRadiusAroundCompanion;
	Parms.ignoredActors = std::move(ignoredActors);
	Parms.detectionContext = detectionContext;
	Parms.alsoDetectNPCKids = alsoDetectNPCKids;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.ForceForgetKids
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    Instigator                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ForcedPerceivabilityGameplayTag                        (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              alsoForgetNPCKids                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::ForceForgetKids(const class UObject* Instigator, const struct FGameplayTag& ForcedPerceivabilityGameplayTag, const bool alsoForgetNPCKids)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "ForceForgetKids");

	Params::EverholmAIBlueprintLibrary_ForceForgetKids Parms{};

	Parms.Instigator = Instigator;
	Parms.ForcedPerceivabilityGameplayTag = std::move(ForcedPerceivabilityGameplayTag);
	Parms.alsoForgetNPCKids = alsoForgetNPCKids;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetAIAlertState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIAlertState                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIAlertState UEverholmAIBlueprintLibrary::GetAIAlertState(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetAIAlertState");

	Params::EverholmAIBlueprintLibrary_GetAIAlertState Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetAIAlertStateAnalyzer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAIAlertStateAnalyzer*            ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAIAlertStateAnalyzer* UEverholmAIBlueprintLibrary::GetAIAlertStateAnalyzer(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetAIAlertStateAnalyzer");

	Params::EverholmAIBlueprintLibrary_GetAIAlertStateAnalyzer Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetAllNPCKidsFollowingPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         Player                                                 (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AEverholmPlayerCharacter*> ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AEverholmPlayerCharacter*> UEverholmAIBlueprintLibrary::GetAllNPCKidsFollowingPlayer(class UObject* WorldContextObject, class AEverholmPlayerCharacter* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetAllNPCKidsFollowingPlayer");

	Params::EverholmAIBlueprintLibrary_GetAllNPCKidsFollowingPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetBestInteractionInArray
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const TArray<class UEverholmInteractionComponent*>&interactionCandidates                                  (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTarsierAINavigator*              Navigator                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseGameplayTags                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRequireValidPath                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmInteractionComponent*    ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmInteractionComponent* UEverholmAIBlueprintLibrary::GetBestInteractionInArray(const TArray<class UEverholmInteractionComponent*>& interactionCandidates, class APawn* Initiator, class UTarsierAINavigator* Navigator, bool bUseGameplayTags, bool bRequireValidPath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetBestInteractionInArray");

	Params::EverholmAIBlueprintLibrary_GetBestInteractionInArray Parms{};

	Parms.interactionCandidates = std::move(interactionCandidates);
	Parms.Initiator = Initiator;
	Parms.Navigator = Navigator;
	Parms.bUseGameplayTags = bUseGameplayTags;
	Parms.bRequireValidPath = bRequireValidPath;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetCompanionsFollowingPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AEverholmPlayerCharacter*> ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AEverholmPlayerCharacter*> UEverholmAIBlueprintLibrary::GetCompanionsFollowingPlayer(class UObject* WorldContextObject, class AEverholmPlayerCharacter* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetCompanionsFollowingPlayer");

	Params::EverholmAIBlueprintLibrary_GetCompanionsFollowingPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetDistanceToClosestIdentifiableKids
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmCharacter*         queryActor                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              excludeNonTargetable                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              sortOutput                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FTargetDistances>         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FTargetDistances> UEverholmAIBlueprintLibrary::GetDistanceToClosestIdentifiableKids(class UWorld* World, const class AEverholmCharacter* queryActor, const bool excludeNonTargetable, const bool sortOutput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetDistanceToClosestIdentifiableKids");

	Params::EverholmAIBlueprintLibrary_GetDistanceToClosestIdentifiableKids Parms{};

	Parms.World = World;
	Parms.queryActor = queryActor;
	Parms.excludeNonTargetable = excludeNonTargetable;
	Parms.sortOutput = sortOutput;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetFollowActorCloselyState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::GetFollowActorCloselyState(const class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetFollowActorCloselyState");

	Params::EverholmAIBlueprintLibrary_GetFollowActorCloselyState Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetFollowActorState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::GetFollowActorState(const class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetFollowActorState");

	Params::EverholmAIBlueprintLibrary_GetFollowActorState Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetHandholdingState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::GetHandholdingState(const class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetHandholdingState");

	Params::EverholmAIBlueprintLibrary_GetHandholdingState Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetPreviousAIAlertState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIAlertState                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIAlertState UEverholmAIBlueprintLibrary::GetPreviousAIAlertState(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetPreviousAIAlertState");

	Params::EverholmAIBlueprintLibrary_GetPreviousAIAlertState Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.GetQueryResultsAsComponents
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UEnvQueryInstanceBlueprintWrapper*QueryInstance                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UActorComponent*>*         resultComponents                                       (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::GetQueryResultsAsComponents(class UEnvQueryInstanceBlueprintWrapper* QueryInstance, TArray<class UActorComponent*>* resultComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "GetQueryResultsAsComponents");

	Params::EverholmAIBlueprintLibrary_GetQueryResultsAsComponents Parms{};

	Parms.QueryInstance = QueryInstance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (resultComponents != nullptr)
		*resultComponents = std::move(Parms.resultComponents);

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.HasActorInAIChalkboard
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UAIChalkboardWrapper*       BrainChalkboard                                        (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::HasActorInAIChalkboard(const class UAIChalkboardWrapper* BrainChalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "HasActorInAIChalkboard");

	Params::EverholmAIBlueprintLibrary_HasActorInAIChalkboard Parms{};

	Parms.BrainChalkboard = BrainChalkboard;
	Parms.sectionKey = std::move(sectionKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.IsAIAlertState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIAlertState                           State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::IsAIAlertState(class APawn* Pawn, EAIAlertState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "IsAIAlertState");

	Params::EverholmAIBlueprintLibrary_IsAIAlertState Parms{};

	Parms.Pawn = Pawn;
	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.IsCompanionCharacterFollowingPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::IsCompanionCharacterFollowingPlayer(class UObject* WorldContextObject, EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "IsCompanionCharacterFollowingPlayer");

	Params::EverholmAIBlueprintLibrary_IsCompanionCharacterFollowingPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.IsInteractionAvailable
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUseGameplayTags                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::IsInteractionAvailable(class UEverholmInteractionComponent* InteractionComponent, class APawn* Initiator, bool bUseGameplayTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "IsInteractionAvailable");

	Params::EverholmAIBlueprintLibrary_IsInteractionAvailable Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.Initiator = Initiator;
	Parms.bUseGameplayTags = bUseGameplayTags;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.IsInteractionReachable
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTarsierAINavigator*              Navigator                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::IsInteractionReachable(class UEverholmInteractionComponent* InteractionComponent, class APawn* Initiator, class UTarsierAINavigator* Navigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "IsInteractionReachable");

	Params::EverholmAIBlueprintLibrary_IsInteractionReachable Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.Initiator = Initiator;
	Parms.Navigator = Navigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.IsPreviousAIAlertState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIAlertState                           State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmAIBlueprintLibrary::IsPreviousAIAlertState(class APawn* Pawn, EAIAlertState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "IsPreviousAIAlertState");

	Params::EverholmAIBlueprintLibrary_IsPreviousAIAlertState Parms{};

	Parms.Pawn = Pawn;
	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.OverrideAIAlertState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIAlertState                           State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::OverrideAIAlertState(class APawn* Pawn, EAIAlertState State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "OverrideAIAlertState");

	Params::EverholmAIBlueprintLibrary_OverrideAIAlertState Parms{};

	Parms.Pawn = Pawn;
	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.OverrideNoiseStrengthToIdentify
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   noiseStrength                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::OverrideNoiseStrengthToIdentify(class APawn* Pawn, float noiseStrength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "OverrideNoiseStrengthToIdentify");

	Params::EverholmAIBlueprintLibrary_OverrideNoiseStrengthToIdentify Parms{};

	Parms.Pawn = Pawn;
	Parms.noiseStrength = noiseStrength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.ResetNoiseStrengthToIdentify
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::ResetNoiseStrengthToIdentify(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "ResetNoiseStrengthToIdentify");

	Params::EverholmAIBlueprintLibrary_ResetNoiseStrengthToIdentify Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.RoundDegreesToCircleIndex
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const float                             Angle                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmAIBlueprintLibrary::RoundDegreesToCircleIndex(const float Angle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "RoundDegreesToCircleIndex");

	Params::EverholmAIBlueprintLibrary_RoundDegreesToCircleIndex Parms{};

	Parms.Angle = Angle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAIBlueprintLibrary.ScriptedDetection
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EOnScriptedDetectionType                detectionType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::ScriptedDetection(class APawn* Pawn, class AActor* TargetActor, const struct FVector& Location, EOnScriptedDetectionType detectionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "ScriptedDetection");

	Params::EverholmAIBlueprintLibrary_ScriptedDetection Parms{};

	Parms.Pawn = Pawn;
	Parms.TargetActor = TargetActor;
	Parms.Location = std::move(Location);
	Parms.detectionType = detectionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.ScriptedDetectionWithinRadius
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAILocationUnion&          searchLocation                                         (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   detectionRadius                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EOnScriptedDetectionType                detectionType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFilterOutAlertedAIs                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::ScriptedDetectionWithinRadius(class AActor* TargetActor, const struct FAILocationUnion& searchLocation, float detectionRadius, EOnScriptedDetectionType detectionType, bool bFilterOutAlertedAIs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "ScriptedDetectionWithinRadius");

	Params::EverholmAIBlueprintLibrary_ScriptedDetectionWithinRadius Parms{};

	Parms.TargetActor = TargetActor;
	Parms.searchLocation = std::move(searchLocation);
	Parms.detectionRadius = detectionRadius;
	Parms.detectionType = detectionType;
	Parms.bFilterOutAlertedAIs = bFilterOutAlertedAIs;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SendCompanionInteractWithActorOrder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           orderInteractionActor                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SendCompanionInteractWithActorOrder(class AActor* orderInteractionActor, class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SendCompanionInteractWithActorOrder");

	Params::EverholmAIBlueprintLibrary_SendCompanionInteractWithActorOrder Parms{};

	Parms.orderInteractionActor = orderInteractionActor;
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SendCompanionInteractWithComponentOrder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UEverholmInteractionComponent*    orderInteractionComponent                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SendCompanionInteractWithComponentOrder(class UEverholmInteractionComponent* orderInteractionComponent, class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SendCompanionInteractWithComponentOrder");

	Params::EverholmAIBlueprintLibrary_SendCompanionInteractWithComponentOrder Parms{};

	Parms.orderInteractionComponent = orderInteractionComponent;
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SendInteractWithActorOrder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           orderInteractionActor                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SendInteractWithActorOrder(EPlayerPawnType pawnType, class AActor* orderInteractionActor, class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SendInteractWithActorOrder");

	Params::EverholmAIBlueprintLibrary_SendInteractWithActorOrder Parms{};

	Parms.pawnType = pawnType;
	Parms.orderInteractionActor = orderInteractionActor;
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SendInteractWithComponentOrder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmInteractionComponent*    orderInteractionComponent                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SendInteractWithComponentOrder(EPlayerPawnType pawnType, class UEverholmInteractionComponent* orderInteractionComponent, class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SendInteractWithComponentOrder");

	Params::EverholmAIBlueprintLibrary_SendInteractWithComponentOrder Parms{};

	Parms.pawnType = pawnType;
	Parms.orderInteractionComponent = orderInteractionComponent;
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SetCompanionFollowState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldFollow                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    optionalInstigator                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SetCompanionFollowState(bool bShouldFollow, class UObject* WorldContextObject, const class UObject* optionalInstigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SetCompanionFollowState");

	Params::EverholmAIBlueprintLibrary_SetCompanionFollowState Parms{};

	Parms.bShouldFollow = bShouldFollow;
	Parms.WorldContextObject = WorldContextObject;
	Parms.optionalInstigator = optionalInstigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SetFollowActorCloselyState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    Instigator                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bShouldFollowClosely                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SetFollowActorCloselyState(class AActor* Actor, const class UObject* Instigator, const bool bShouldFollowClosely)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SetFollowActorCloselyState");

	Params::EverholmAIBlueprintLibrary_SetFollowActorCloselyState Parms{};

	Parms.Actor = Actor;
	Parms.Instigator = Instigator;
	Parms.bShouldFollowClosely = bShouldFollowClosely;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SetFollowActorState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    Instigator                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bShouldFollow                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SetFollowActorState(class AActor* Actor, const class UObject* Instigator, const bool bShouldFollow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SetFollowActorState");

	Params::EverholmAIBlueprintLibrary_SetFollowActorState Parms{};

	Parms.Actor = Actor;
	Parms.Instigator = Instigator;
	Parms.bShouldFollow = bShouldFollow;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SetHandholdingState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    Instigator                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bShouldHoldHands                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SetHandholdingState(class AActor* Actor, const class UObject* Instigator, const bool bShouldHoldHands)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SetHandholdingState");

	Params::EverholmAIBlueprintLibrary_SetHandholdingState Parms{};

	Parms.Actor = Actor;
	Parms.Instigator = Instigator;
	Parms.bShouldHoldHands = bShouldHoldHands;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.SetNPCKidFollowState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldFollow                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    optionalInstigator                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::SetNPCKidFollowState(bool bShouldFollow, EPlayerPawnType pawnType, class UObject* WorldContextObject, const class UObject* optionalInstigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "SetNPCKidFollowState");

	Params::EverholmAIBlueprintLibrary_SetNPCKidFollowState Parms{};

	Parms.bShouldFollow = bShouldFollow;
	Parms.pawnType = pawnType;
	Parms.WorldContextObject = WorldContextObject;
	Parms.optionalInstigator = optionalInstigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.StopCurrentActionOrder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::StopCurrentActionOrder(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "StopCurrentActionOrder");

	Params::EverholmAIBlueprintLibrary_StopCurrentActionOrder Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.StopStartAction
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAIChalkboardWrapper*             BrainChalkboard                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::StopStartAction(class APawn* Pawn, class UAIChalkboardWrapper* BrainChalkboard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "StopStartAction");

	Params::EverholmAIBlueprintLibrary_StopStartAction Parms{};

	Parms.Pawn = Pawn;
	Parms.BrainChalkboard = BrainChalkboard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAIBlueprintLibrary.TryDropPickup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAIChalkboardWrapper*             BrainChalkboard                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAIBlueprintLibrary::TryDropPickup(class APawn* Pawn, class UAIChalkboardWrapper* BrainChalkboard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmAIBlueprintLibrary", "TryDropPickup");

	Params::EverholmAIBlueprintLibrary_TryDropPickup Parms{};

	Parms.Pawn = Pawn;
	Parms.BrainChalkboard = BrainChalkboard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UseItemAbilityComponent.OnAbortAbility
// (Native, Event, Public, BlueprintEvent)

void UUseItemAbilityComponent::OnAbortAbility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UseItemAbilityComponent", "OnAbortAbility");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UseItemAbilityComponent.OnLedgeClimbingChanged
// (Final, Native, Protected)
// Parameters:
// bool                                    bIsClimbing                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ledgeHeightAfterAlignment                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUseItemAbilityComponent::OnLedgeClimbingChanged(bool bIsClimbing, float ledgeHeightAfterAlignment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UseItemAbilityComponent", "OnLedgeClimbingChanged");

	Params::UseItemAbilityComponent_OnLedgeClimbingChanged Parms{};

	Parms.bIsClimbing = bIsClimbing;
	Parms.ledgeHeightAfterAlignment = ledgeHeightAfterAlignment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UseItemAbilityComponent.OnPickupStateChanged
// (Native, Protected)
// Parameters:
// EPickupState                            PreviousPickupState                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPickupState                            NewPickupState                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUseItemAbilityComponent::OnPickupStateChanged(EPickupState PreviousPickupState, EPickupState NewPickupState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UseItemAbilityComponent", "OnPickupStateChanged");

	Params::UseItemAbilityComponent_OnPickupStateChanged Parms{};

	Parms.PreviousPickupState = PreviousPickupState;
	Parms.NewPickupState = NewPickupState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UseItemAbilityComponent.OnStartUsingItem
// (Native, Event, Public, BlueprintEvent)

void UUseItemAbilityComponent::OnStartUsingItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UseItemAbilityComponent", "OnStartUsingItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UseItemAbilityComponent.OnStopUsingItem
// (Native, Event, Public, BlueprintEvent)

void UUseItemAbilityComponent::OnStopUsingItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UseItemAbilityComponent", "OnStopUsingItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UseItemAbilityComponent.OnSurfaceClimbingChanged
// (Final, Native, Protected)
// Parameters:
// bool                                    bIsClimbing                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUseItemAbilityComponent::OnSurfaceClimbingChanged(bool bIsClimbing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UseItemAbilityComponent", "OnSurfaceClimbingChanged");

	Params::UseItemAbilityComponent_OnSurfaceClimbingChanged Parms{};

	Parms.bIsClimbing = bIsClimbing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UseItemAbilityComponent.GetPickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UUseItemAbilityComponent::GetPickup() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UseItemAbilityComponent", "GetPickup");

	Params::UseItemAbilityComponent_GetPickup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowItemAbilityComponent.HandleImpactFieldSpawned
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AFieldSystemActor*                impactField                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::HandleImpactFieldSpawned(class AFieldSystemActor* impactField)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "HandleImpactFieldSpawned");

	Params::ThrowItemAbilityComponent_HandleImpactFieldSpawned Parms{};

	Parms.impactField = impactField;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ThrowItemAbilityComponent.HandleMeshAnimInitialized
// (Final, Native, Private)

void UThrowItemAbilityComponent::HandleMeshAnimInitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "HandleMeshAnimInitialized");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.HandlePickupHolderChanged
// (Final, Native, Private)
// Parameters:
// class AActor*                           newHolder                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::HandlePickupHolderChanged(class AActor* newHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "HandlePickupHolderChanged");

	Params::ThrowItemAbilityComponent_HandlePickupHolderChanged Parms{};

	Parms.newHolder = newHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.HandlePickupLanded
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AEverholmCharacter*               throwInitiator                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::HandlePickupLanded(class AEverholmCharacter* throwInitiator, class APickupBase* pickup, const struct FHitResult& ImpactResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "HandlePickupLanded");

	Params::ThrowItemAbilityComponent_HandlePickupLanded Parms{};

	Parms.throwInitiator = throwInitiator;
	Parms.pickup = pickup;
	Parms.ImpactResult = std::move(ImpactResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.HandlePickupPhysicsSettled
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               throwInitiator                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::HandlePickupPhysicsSettled(class AEverholmCharacter* throwInitiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "HandlePickupPhysicsSettled");

	Params::ThrowItemAbilityComponent_HandlePickupPhysicsSettled Parms{};

	Parms.throwInitiator = throwInitiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.HandlePickupThrown
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               throwInitiator                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::HandlePickupThrown(class AEverholmCharacter* throwInitiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "HandlePickupThrown");

	Params::ThrowItemAbilityComponent_HandlePickupThrown Parms{};

	Parms.throwInitiator = throwInitiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.OnThrowOverlap
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::OnThrowOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "OnThrowOverlap");

	Params::ThrowItemAbilityComponent_OnThrowOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.ResetOverrideThrowDirection
// (Final, Native, Public, BlueprintCallable)

void UThrowItemAbilityComponent::ResetOverrideThrowDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "ResetOverrideThrowDirection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.SetOverrideThrowDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   throwVec                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::SetOverrideThrowDirection(const struct FVector& throwVec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "SetOverrideThrowDirection");

	Params::ThrowItemAbilityComponent_SetOverrideThrowDirection Parms{};

	Parms.throwVec = std::move(throwVec);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowItemAbilityComponent.SpawnWaterImpact
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   ImpactLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowItemAbilityComponent::SpawnWaterImpact(const struct FVector& ImpactLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "SpawnWaterImpact");

	Params::ThrowItemAbilityComponent_SpawnWaterImpact Parms{};

	Parms.ImpactLocation = std::move(ImpactLocation);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ThrowItemAbilityComponent.CalculateThrowStartPosition
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UThrowItemAbilityComponent::CalculateThrowStartPosition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "CalculateThrowStartPosition");

	Params::ThrowItemAbilityComponent_CalculateThrowStartPosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowItemAbilityComponent.GetLastFoundThrowTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              bCallFindTarget                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTargetComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTargetComponent* UThrowItemAbilityComponent::GetLastFoundThrowTarget(const bool bCallFindTarget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "GetLastFoundThrowTarget");

	Params::ThrowItemAbilityComponent_GetLastFoundThrowTarget Parms{};

	Parms.bCallFindTarget = bCallFindTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowItemAbilityComponent.GetThrowInstigator
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmCharacter*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmCharacter* UThrowItemAbilityComponent::GetThrowInstigator() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "GetThrowInstigator");

	Params::ThrowItemAbilityComponent_GetThrowInstigator Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowItemAbilityComponent.GetThrowPositionOffset
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UThrowItemAbilityComponent::GetThrowPositionOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "GetThrowPositionOffset");

	Params::ThrowItemAbilityComponent_GetThrowPositionOffset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowItemAbilityComponent.IsPickupHarpoon
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UThrowItemAbilityComponent::IsPickupHarpoon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "IsPickupHarpoon");

	Params::ThrowItemAbilityComponent_IsPickupHarpoon Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowItemAbilityComponent.IsThrowObstructed
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UThrowItemAbilityComponent::IsThrowObstructed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowItemAbilityComponent", "IsThrowObstructed");

	Params::ThrowItemAbilityComponent_IsThrowObstructed Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAISystem.OverrideCompanionFollowDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DesiredDistance                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::OverrideCompanionFollowDistance(EPlayerPawnType pawnType, float DesiredDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "OverrideCompanionFollowDistance");

	Params::EverholmAISystem_OverrideCompanionFollowDistance Parms{};

	Parms.pawnType = pawnType;
	Parms.DesiredDistance = DesiredDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.OverrideCompanionFollowYawOffset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   desiredYawOffset                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::OverrideCompanionFollowYawOffset(EPlayerPawnType pawnType, float desiredYawOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "OverrideCompanionFollowYawOffset");

	Params::EverholmAISystem_OverrideCompanionFollowYawOffset Parms{};

	Parms.pawnType = pawnType;
	Parms.desiredYawOffset = desiredYawOffset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.OverrideFixedFollowSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   desiredFixedFollowSpeed                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::OverrideFixedFollowSpeed(EPlayerPawnType pawnType, float desiredFixedFollowSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "OverrideFixedFollowSpeed");

	Params::EverholmAISystem_OverrideFixedFollowSpeed Parms{};

	Parms.pawnType = pawnType;
	Parms.desiredFixedFollowSpeed = desiredFixedFollowSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.OverrideStandStillLeewayDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   desiredLeewayDistance                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::OverrideStandStillLeewayDistance(EPlayerPawnType pawnType, float desiredLeewayDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "OverrideStandStillLeewayDistance");

	Params::EverholmAISystem_OverrideStandStillLeewayDistance Parms{};

	Parms.pawnType = pawnType;
	Parms.desiredLeewayDistance = desiredLeewayDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.ResetCompanionFollowDistanceOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::ResetCompanionFollowDistanceOverride(EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "ResetCompanionFollowDistanceOverride");

	Params::EverholmAISystem_ResetCompanionFollowDistanceOverride Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.ResetCompanionFollowYawOffsetOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::ResetCompanionFollowYawOffsetOverride(EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "ResetCompanionFollowYawOffsetOverride");

	Params::EverholmAISystem_ResetCompanionFollowYawOffsetOverride Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.ResetFixedFollowSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::ResetFixedFollowSpeed(EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "ResetFixedFollowSpeed");

	Params::EverholmAISystem_ResetFixedFollowSpeed Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.ResetStandStillLeewayDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAISystem::ResetStandStillLeewayDistance(EPlayerPawnType pawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "ResetStandStillLeewayDistance");

	Params::EverholmAISystem_ResetStandStillLeewayDistance Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAISystem.GetCompanionFixedFollowSpeedOverride
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TOptional<float>                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TOptional<float> UEverholmAISystem::GetCompanionFixedFollowSpeedOverride(EPlayerPawnType pawnType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "GetCompanionFixedFollowSpeedOverride");

	Params::EverholmAISystem_GetCompanionFixedFollowSpeedOverride Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAISystem.GetCompanionFollowDistance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAISystem::GetCompanionFollowDistance(EPlayerPawnType pawnType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "GetCompanionFollowDistance");

	Params::EverholmAISystem_GetCompanionFollowDistance Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAISystem.GetCompanionFollowYawOffset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAISystem::GetCompanionFollowYawOffset(EPlayerPawnType pawnType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "GetCompanionFollowYawOffset");

	Params::EverholmAISystem_GetCompanionFollowYawOffset Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAISystem.GetCompanionFollowYawOffsetOverride
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TOptional<float>                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TOptional<float> UEverholmAISystem::GetCompanionFollowYawOffsetOverride(EPlayerPawnType pawnType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "GetCompanionFollowYawOffsetOverride");

	Params::EverholmAISystem_GetCompanionFollowYawOffsetOverride Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAISystem.GetStandStillLeewayDistance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         pawnType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmAISystem::GetStandStillLeewayDistance(EPlayerPawnType pawnType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAISystem", "GetStandStillLeewayDistance");

	Params::EverholmAISystem_GetStandStillLeewayDistance Parms{};

	Parms.pawnType = pawnType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmAnimationRelayComponent.ApplyAnimationSet
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// const class UAnimationSet*              AnimationSet                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAnimationRelayComponent::ApplyAnimationSet(const class UAnimationSet* AnimationSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAnimationRelayComponent", "ApplyAnimationSet");

	Params::EverholmAnimationRelayComponent_ApplyAnimationSet Parms{};

	Parms.AnimationSet = AnimationSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmAnimationRelayComponent.RemoveAnimationSet
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// const class UAnimationSet*              AnimationSet                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmAnimationRelayComponent::RemoveAnimationSet(const class UAnimationSet* AnimationSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmAnimationRelayComponent", "RemoveAnimationSet");

	Params::EverholmAnimationRelayComponent_RemoveAnimationSet Parms{};

	Parms.AnimationSet = AnimationSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TelemetrySubsystem.CanLog
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::CanLog()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TelemetrySubsystem", "CanLog");

	Params::TelemetrySubsystem_CanLog Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.IsTelemetryInitialized
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::IsTelemetryInitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TelemetrySubsystem", "IsTelemetryInitialized");

	Params::TelemetrySubsystem_IsTelemetryInitialized Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.IsTelemetryUserEnabled
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::IsTelemetryUserEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TelemetrySubsystem", "IsTelemetryUserEnabled");

	Params::TelemetrySubsystem_IsTelemetryUserEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogBoatCollided
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    collidedWith                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogBoatCollided(const class FString& collidedWith, const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogBoatCollided");

	Params::TelemetrySubsystem_LogBoatCollided Parms{};

	Parms.collidedWith = std::move(collidedWith);
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogCallInvoked
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogCallInvoked(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogCallInvoked");

	Params::TelemetrySubsystem_LogCallInvoked Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogClimbedLedge
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ledgeName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogClimbedLedge(const class FString& ledgeName, const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogClimbedLedge");

	Params::TelemetrySubsystem_LogClimbedLedge Parms{};

	Parms.ledgeName = std::move(ledgeName);
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogCompanionAntiStuck
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogCompanionAntiStuck(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogCompanionAntiStuck");

	Params::TelemetrySubsystem_LogCompanionAntiStuck Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogCrouchStarted
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogCrouchStarted(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogCrouchStarted");

	Params::TelemetrySubsystem_LogCrouchStarted Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogDisconnect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   disconnectReason                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogDisconnect(const struct FLogEventLocation& Location, int32 disconnectReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogDisconnect");

	Params::TelemetrySubsystem_LogDisconnect Parms{};

	Parms.Location = std::move(Location);
	Parms.disconnectReason = disconnectReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogFallOffPrevented
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogFallOffPrevented(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogFallOffPrevented");

	Params::TelemetrySubsystem_LogFallOffPrevented Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogFinishedDemo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogFinishedDemo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogFinishedDemo");

	Params::TelemetrySubsystem_LogFinishedDemo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogFoundMask
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    maskName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogFoundMask(const class FString& maskName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogFoundMask");

	Params::TelemetrySubsystem_LogFoundMask Parms{};

	Parms.maskName = std::move(maskName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogInvokedPauseMenu
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogInvokedPauseMenu(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogInvokedPauseMenu");

	Params::TelemetrySubsystem_LogInvokedPauseMenu Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogJumped
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogJumped(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogJumped");

	Params::TelemetrySubsystem_LogJumped Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogLanded
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogLanded(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogLanded");

	Params::TelemetrySubsystem_LogLanded Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogLongIdled
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogLongIdled(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogLongIdled");

	Params::TelemetrySubsystem_LogLongIdled Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogMapAccessed
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogMapAccessed(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogMapAccessed");

	Params::TelemetrySubsystem_LogMapAccessed Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogPlayerDied
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    deathReason                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    killer                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class ACharacter*                 Character                                              (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogPlayerDied(const class FString& deathReason, const class FString& killer, const class ACharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogPlayerDied");

	Params::TelemetrySubsystem_LogPlayerDied Parms{};

	Parms.deathReason = std::move(deathReason);
	Parms.killer = std::move(killer);
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogReloadedCheckpoint
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogReloadedCheckpoint(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogReloadedCheckpoint");

	Params::TelemetrySubsystem_LogReloadedCheckpoint Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogSessionHeartbeat
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogSessionHeartbeat(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogSessionHeartbeat");

	Params::TelemetrySubsystem_LogSessionHeartbeat Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogSessionStart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const ESessionMode                      SessionMode                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              crossPlay                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogSessionStart(const ESessionMode SessionMode, const bool crossPlay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogSessionStart");

	Params::TelemetrySubsystem_LogSessionStart Parms{};

	Parms.SessionMode = SessionMode;
	Parms.crossPlay = crossPlay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogSlideStarted
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogSlideStarted(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogSlideStarted");

	Params::TelemetrySubsystem_LogSlideStarted Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogSprintStarted
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogSprintStarted(const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogSprintStarted");

	Params::TelemetrySubsystem_LogSprintStarted Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogStashedItem
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ItemName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogStashedItem(const class FString& ItemName, const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogStashedItem");

	Params::TelemetrySubsystem_LogStashedItem Parms{};

	Parms.ItemName = std::move(ItemName);
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogTestInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    TestString                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogTestInfo(const class FString& TestString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogTestInfo");

	Params::TelemetrySubsystem_LogTestInfo Parms{};

	Parms.TestString = std::move(TestString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogUnstashedItem
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ItemName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogUnstashedItem(const class FString& ItemName, const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogUnstashedItem");

	Params::TelemetrySubsystem_LogUnstashedItem Parms{};

	Parms.ItemName = std::move(ItemName);
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.LogWeaponUsed
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    weaponName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    TargetName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLogEventLocation&         Location                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UTelemetrySubsystem::LogWeaponUsed(const class FString& weaponName, const class FString& TargetName, const struct FLogEventLocation& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "LogWeaponUsed");

	Params::TelemetrySubsystem_LogWeaponUsed Parms{};

	Parms.weaponName = std::move(weaponName);
	Parms.TargetName = std::move(TargetName);
	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TelemetrySubsystem.OnNetworkSessionManagerFailure
// (Final, Native, Private)
// Parameters:
// ENetworkSessionManagerFailType          FailureType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTelemetrySubsystem::OnNetworkSessionManagerFailure(ENetworkSessionManagerFailType FailureType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TelemetrySubsystem", "OnNetworkSessionManagerFailure");

	Params::TelemetrySubsystem_OnNetworkSessionManagerFailure Parms{};

	Parms.FailureType = FailureType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.BP_OnPauseMenuStateChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    showing                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::BP_OnPauseMenuStateChanged(bool showing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "BP_OnPauseMenuStateChanged");

	Params::EverholmBaseHUD_BP_OnPauseMenuStateChanged Parms{};

	Parms.showing = showing;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmBaseHUD.BP_ShowControllerDisconnectMessage
// (Event, Public, BlueprintEvent)
// Parameters:
// const struct FInputDeviceId&            DeviceID                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::BP_ShowControllerDisconnectMessage(const struct FInputDeviceId& DeviceID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "BP_ShowControllerDisconnectMessage");

	Params::EverholmBaseHUD_BP_ShowControllerDisconnectMessage Parms{};

	Parms.DeviceID = std::move(DeviceID);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmBaseHUD.CheckMessageQueue
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::CheckMessageQueue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "CheckMessageQueue");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.ClearTutorialPrompt
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::ClearTutorialPrompt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ClearTutorialPrompt");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.ClearUIOnScreen
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::ClearUIOnScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ClearUIOnScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.HideLobbyMenu
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::HideLobbyMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "HideLobbyMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.HidePauseMenuWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerState*                     pausingPlayerState                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::HidePauseMenuWidget(class APlayerState* pausingPlayerState, EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "HidePauseMenuWidget");

	Params::EverholmBaseHUD_HidePauseMenuWidget Parms{};

	Parms.pausingPlayerState = pausingPlayerState;
	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.HideTutorialPrompt
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::HideTutorialPrompt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "HideTutorialPrompt");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.LaunchStoreFront
// (Final, Native, Private, BlueprintCallable)

void AEverholmBaseHUD::LaunchStoreFront()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "LaunchStoreFront");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.LoadingScreenDeactivated
// (Final, Native, Private)

void AEverholmBaseHUD::LoadingScreenDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "LoadingScreenDeactivated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.OnMessageClosed
// (Final, Native, Private)

void AEverholmBaseHUD::OnMessageClosed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "OnMessageClosed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.OnNotificationClosed
// (Final, Native, Private)

void AEverholmBaseHUD::OnNotificationClosed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "OnNotificationClosed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.OnPlayerSpawned
// (Event, Public, BlueprintEvent)
// Parameters:
// class APlayerController*                NewController                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::OnPlayerSpawned(class APlayerController* NewController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "OnPlayerSpawned");

	Params::EverholmBaseHUD_OnPlayerSpawned Parms{};

	Parms.NewController = NewController;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmBaseHUD.OnPossessedPawnChanged
// (Final, Native, Private)
// Parameters:
// class APawn*                            OldPawn                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            NewPawn                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::OnPossessedPawnChanged(class APawn* OldPawn, class APawn* NewPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "OnPossessedPawnChanged");

	Params::EverholmBaseHUD_OnPossessedPawnChanged Parms{};

	Parms.OldPawn = OldPawn;
	Parms.NewPawn = NewPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.OnPromptSelected
// (Final, Native, Private)
// Parameters:
// bool                                    Selected                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::OnPromptSelected(bool Selected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "OnPromptSelected");

	Params::EverholmBaseHUD_OnPromptSelected Parms{};

	Parms.Selected = Selected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.PopCurrentWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EUILayer                                Layer                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::PopCurrentWidget(EUILayer Layer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "PopCurrentWidget");

	Params::EverholmBaseHUD_PopCurrentWidget Parms{};

	Parms.Layer = Layer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.PopWaitingScreen
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::PopWaitingScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "PopWaitingScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.PushWaitingScreen
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::PushWaitingScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "PushWaitingScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.ShouldShowDebugHUD
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const bool                              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const bool AEverholmBaseHUD::ShouldShowDebugHUD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShouldShowDebugHUD");

	Params::EverholmBaseHUD_ShouldShowDebugHUD Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowErrorMessage
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EEverholmErrorMessageType               Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::ShowErrorMessage(EEverholmErrorMessageType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowErrorMessage");

	Params::EverholmBaseHUD_ShowErrorMessage Parms{};

	Parms.Type = Type;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmBaseHUD.ShowGameshareLostMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      PromptText                                             (Parm, NativeAccessSpecifierPublic)
// int32                                   ControllerIndex                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGenericControllerMessage*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGenericControllerMessage* AEverholmBaseHUD::ShowGameshareLostMessage(const class FText& PromptText, int32 ControllerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowGameshareLostMessage");

	Params::EverholmBaseHUD_ShowGameshareLostMessage Parms{};

	Parms.PromptText = std::move(PromptText);
	Parms.ControllerIndex = ControllerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowGenericControllerDisconnectedMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      PromptText                                             (Parm, NativeAccessSpecifierPublic)
// class UGenericControllerDisconnectedMessage*ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGenericControllerDisconnectedMessage* AEverholmBaseHUD::ShowGenericControllerDisconnectedMessage(const class FText& PromptText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowGenericControllerDisconnectedMessage");

	Params::EverholmBaseHUD_ShowGenericControllerDisconnectedMessage Parms{};

	Parms.PromptText = std::move(PromptText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowGenericControllerMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      PromptText                                             (Parm, NativeAccessSpecifierPublic)
// int32                                   ControllerIndex                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGenericControllerMessage*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGenericControllerMessage* AEverholmBaseHUD::ShowGenericControllerMessage(const class FText& PromptText, int32 ControllerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowGenericControllerMessage");

	Params::EverholmBaseHUD_ShowGenericControllerMessage Parms{};

	Parms.PromptText = std::move(PromptText);
	Parms.ControllerIndex = ControllerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowGenericMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      PromptText                                             (Parm, NativeAccessSpecifierPublic)
// class UGenericMessage*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGenericMessage* AEverholmBaseHUD::ShowGenericMessage(const class FText& PromptText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowGenericMessage");

	Params::EverholmBaseHUD_ShowGenericMessage Parms{};

	Parms.PromptText = std::move(PromptText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowGenericPrompt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      PromptText                                             (Parm, NativeAccessSpecifierPublic)
// class UGenericPrompt*                   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGenericPrompt* AEverholmBaseHUD::ShowGenericPrompt(const class FText& PromptText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowGenericPrompt");

	Params::EverholmBaseHUD_ShowGenericPrompt Parms{};

	Parms.PromptText = std::move(PromptText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowLobbyMenu
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::ShowLobbyMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowLobbyMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.ShowNotification
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      PromptText                                             (Parm, NativeAccessSpecifierPublic)
// class UGenericMessage*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGenericMessage* AEverholmBaseHUD::ShowNotification(const class FText& PromptText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowNotification");

	Params::EverholmBaseHUD_ShowNotification Parms{};

	Parms.PromptText = std::move(PromptText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowPauseMenuWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerState*                     pausingPlayerState                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPauseMenuUI*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPauseMenuUI* AEverholmBaseHUD::ShowPauseMenuWidget(class APlayerState* pausingPlayerState, EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowPauseMenuWidget");

	Params::EverholmBaseHUD_ShowPauseMenuWidget Parms{};

	Parms.pausingPlayerState = pausingPlayerState;
	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowPrompt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UTarsierActivatableWidget>WidgetClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      PromptText                                             (Parm, NativeAccessSpecifierPublic)
// class UTarsierActivatableWidget*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTarsierActivatableWidget* AEverholmBaseHUD::ShowPrompt(TSubclassOf<class UTarsierActivatableWidget> WidgetClass, const class FText& PromptText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowPrompt");

	Params::EverholmBaseHUD_ShowPrompt Parms{};

	Parms.WidgetClass = WidgetClass;
	Parms.PromptText = std::move(PromptText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ShowTutorialPrompt
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class FText*                            tutorialText                                           (Parm, OutParm, NativeAccessSpecifierPublic)
// float                                   MinDuration                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmBaseHUD::ShowTutorialPrompt(class FText* tutorialText, float MinDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowTutorialPrompt");

	Params::EverholmBaseHUD_ShowTutorialPrompt Parms{};

	Parms.MinDuration = MinDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (tutorialText != nullptr)
		*tutorialText = std::move(Parms.tutorialText);
}


// Function Everholm.EverholmBaseHUD.ShowWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UTarsierActivatableWidget>WidgetClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EUILayer                                EUILayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTarsierActivatableWidget*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTarsierActivatableWidget* AEverholmBaseHUD::ShowWidget(TSubclassOf<class UTarsierActivatableWidget> WidgetClass, EUILayer EUILayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ShowWidget");

	Params::EverholmBaseHUD_ShowWidget Parms{};

	Parms.WidgetClass = WidgetClass;
	Parms.EUILayer = EUILayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.ToggleLobbyMenu
// (Final, Native, Public, BlueprintCallable)

void AEverholmBaseHUD::ToggleLobbyMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "ToggleLobbyMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmBaseHUD.GetBuildRevision
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString                     ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class FString AEverholmBaseHUD::GetBuildRevision() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "GetBuildRevision");

	Params::EverholmBaseHUD_GetBuildRevision Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.GetCommonSessionMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECommonSessionOnlineMode                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECommonSessionOnlineMode AEverholmBaseHUD::GetCommonSessionMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "GetCommonSessionMode");

	Params::EverholmBaseHUD_GetCommonSessionMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.GetLayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EUILayer                                LayerType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UUILayer*                         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UUILayer* AEverholmBaseHUD::GetLayer(EUILayer LayerType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "GetLayer");

	Params::EverholmBaseHUD_GetLayer Parms{};

	Parms.LayerType = LayerType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.GetSelectedGameMode
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EEverholmSessionMode                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EEverholmSessionMode AEverholmBaseHUD::GetSelectedGameMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "GetSelectedGameMode");

	Params::EverholmBaseHUD_GetSelectedGameMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.HasAnyWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EUILayer                                UILayer                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmBaseHUD::HasAnyWidget(EUILayer UILayer) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "HasAnyWidget");

	Params::EverholmBaseHUD_HasAnyWidget Parms{};

	Parms.UILayer = UILayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.IsAnyMenuOpen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmBaseHUD::IsAnyMenuOpen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "IsAnyMenuOpen");

	Params::EverholmBaseHUD_IsAnyMenuOpen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.IsShowingPauseScreen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmBaseHUD::IsShowingPauseScreen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "IsShowingPauseScreen");

	Params::EverholmBaseHUD_IsShowingPauseScreen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmBaseHUD.IsShowingWaitScreen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmBaseHUD::IsShowingWaitScreen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmBaseHUD", "IsShowingWaitScreen");

	Params::EverholmBaseHUD_IsShowingWaitScreen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCallComponent.ClearCallExpressionOverride
// (Final, Native, Public, BlueprintCallable)

void UEverholmCallComponent::ClearCallExpressionOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "ClearCallExpressionOverride");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.HandleMeshAnimInitialized
// (Final, Native, Private)

void UEverholmCallComponent::HandleMeshAnimInitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "HandleMeshAnimInitialized");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.Multicast_ExecuteBeingCalled
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const class AActor*                     Caller                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USceneComponent*            Target                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCallComponent::Multicast_ExecuteBeingCalled(const class AActor* Caller, const class USceneComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "Multicast_ExecuteBeingCalled");

	Params::EverholmCallComponent_Multicast_ExecuteBeingCalled Parms{};

	Parms.Caller = Caller;
	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.Multicast_ExecuteCall
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UEverholmCallComponent::Multicast_ExecuteCall()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "Multicast_ExecuteCall");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.OnGestureFinished
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UEverholmCallComponent::OnGestureFinished(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "OnGestureFinished");

	Params::EverholmCallComponent_OnGestureFinished Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.OnGestureStarted
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UEverholmCallComponent::OnGestureStarted(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "OnGestureStarted");

	Params::EverholmCallComponent_OnGestureStarted Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.Server_ExecuteBeingCalled
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// const class AActor*                     Caller                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USceneComponent*            Target                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCallComponent::Server_ExecuteBeingCalled(const class AActor* Caller, const class USceneComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "Server_ExecuteBeingCalled");

	Params::EverholmCallComponent_Server_ExecuteBeingCalled Parms{};

	Parms.Caller = Caller;
	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.Server_ExecuteCall
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UEverholmCallComponent::Server_ExecuteCall()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "Server_ExecuteCall");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.SetCallExpressionOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECallExpressionType                     ExpressionType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCallComponent::SetCallExpressionOverride(ECallExpressionType ExpressionType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "SetCallExpressionOverride");

	Params::EverholmCallComponent_SetCallExpressionOverride Parms{};

	Parms.ExpressionType = ExpressionType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCallComponent.TryBeingCalled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     Caller                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USceneComponent*            Target                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCallComponent::TryBeingCalled(const class AActor* Caller, const class USceneComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCallComponent", "TryBeingCalled");

	Params::EverholmCallComponent_TryBeingCalled Parms{};

	Parms.Caller = Caller;
	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SurfaceClimbMovementMode.SetAllowsClimbSteps
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldAllow                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USurfaceClimbMovementMode::SetAllowsClimbSteps(bool bShouldAllow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "SetAllowsClimbSteps");

	Params::SurfaceClimbMovementMode_SetAllowsClimbSteps Parms{};

	Parms.bShouldAllow = bShouldAllow;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SurfaceClimbMovementMode.SetClimbingPose
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EClimbingPose                           Pose                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USurfaceClimbMovementMode::SetClimbingPose(EClimbingPose Pose)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "SetClimbingPose");

	Params::SurfaceClimbMovementMode_SetClimbingPose Parms{};

	Parms.Pose = Pose;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SurfaceClimbMovementMode.SetVerticalDirection
// (Native, Public, BlueprintCallable)
// Parameters:
// const EClimbingDirectionVertical        newVerticalDirection                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USurfaceClimbMovementMode::SetVerticalDirection(const EClimbingDirectionVertical newVerticalDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "SetVerticalDirection");

	Params::SurfaceClimbMovementMode_SetVerticalDirection Parms{};

	Parms.newVerticalDirection = newVerticalDirection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SurfaceClimbMovementMode.UpdateIKTargets
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          Object                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USurfaceClimbMovementMode::UpdateIKTargets(class UObject* Object, const struct FTransform& Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "UpdateIKTargets");

	Params::SurfaceClimbMovementMode_UpdateIKTargets Parms{};

	Parms.Object = Object;
	Parms.Transform = std::move(Transform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SurfaceClimbMovementMode.AllowsClimbSteps
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USurfaceClimbMovementMode::AllowsClimbSteps() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "AllowsClimbSteps");

	Params::SurfaceClimbMovementMode_AllowsClimbSteps Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.GetClimbingPose
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EClimbingPose                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EClimbingPose USurfaceClimbMovementMode::GetClimbingPose() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "GetClimbingPose");

	Params::SurfaceClimbMovementMode_GetClimbingPose Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.GetClimbingReference_UObject
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UObject* USurfaceClimbMovementMode::GetClimbingReference_UObject() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "GetClimbingReference_UObject");

	Params::SurfaceClimbMovementMode_GetClimbingReference_UObject Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.GetClimbingTransitionState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInitClimbingState                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInitClimbingState USurfaceClimbMovementMode::GetClimbingTransitionState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "GetClimbingTransitionState");

	Params::SurfaceClimbMovementMode_GetClimbingTransitionState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.GetClimbStepData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FClimbStepData             ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FClimbStepData USurfaceClimbMovementMode::GetClimbStepData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "GetClimbStepData");

	Params::SurfaceClimbMovementMode_GetClimbStepData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.GetIsClimbTransitionFullyBlended
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USurfaceClimbMovementMode::GetIsClimbTransitionFullyBlended() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "GetIsClimbTransitionFullyBlended");

	Params::SurfaceClimbMovementMode_GetIsClimbTransitionFullyBlended Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.GetIsSurfaceClimbing
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USurfaceClimbMovementMode::GetIsSurfaceClimbing() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "GetIsSurfaceClimbing");

	Params::SurfaceClimbMovementMode_GetIsSurfaceClimbing Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.IsInClimbingMode
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USurfaceClimbMovementMode::IsInClimbingMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "IsInClimbingMode");

	Params::SurfaceClimbMovementMode_IsInClimbingMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SurfaceClimbMovementMode.IsInReach
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FClimbablePointData&       Point                                                  (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USurfaceClimbMovementMode::IsInReach(const struct FClimbablePointData& Point) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbMovementMode", "IsInReach");

	Params::SurfaceClimbMovementMode_IsInReach Parms{};

	Parms.Point = std::move(Point);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterAudio.OnCharacterLanded
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFallData&                 FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UEverholmCharacterAudio::OnCharacterLanded(const struct FFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterAudio", "OnCharacterLanded");

	Params::EverholmCharacterAudio_OnCharacterLanded Parms{};

	Parms.FallData = std::move(FallData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmCharacterMovementComponent.AddDesiredMovement
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Movement                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::AddDesiredMovement(const struct FVector& Movement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "AddDesiredMovement");

	Params::EverholmCharacterMovementComponent_AddDesiredMovement Parms{};

	Parms.Movement = std::move(Movement);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.AddVelocity
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   velocityToAdd                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bClampToMaxSpeed                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::AddVelocity(const struct FVector& velocityToAdd, const bool bClampToMaxSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "AddVelocity");

	Params::EverholmCharacterMovementComponent_AddVelocity Parms{};

	Parms.velocityToAdd = std::move(velocityToAdd);
	Parms.bClampToMaxSpeed = bClampToMaxSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.AutoJumpTo
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FJumpParams&               jumpParameters                                         (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::AutoJumpTo(const struct FJumpParams& jumpParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "AutoJumpTo");

	Params::EverholmCharacterMovementComponent_AutoJumpTo Parms{};

	Parms.jumpParameters = std::move(jumpParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.HandleOnSurfaceClimbChanged
// (Final, Native, Public)
// Parameters:
// bool                                    bShouldStart                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::HandleOnSurfaceClimbChanged(bool bShouldStart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "HandleOnSurfaceClimbChanged");

	Params::EverholmCharacterMovementComponent_HandleOnSurfaceClimbChanged Parms{};

	Parms.bShouldStart = bShouldStart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.HasLocomotionProfile
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class ULocomotionProfileAsset*    locomotionProfile                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::HasLocomotionProfile(const class ULocomotionProfileAsset* locomotionProfile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "HasLocomotionProfile");

	Params::EverholmCharacterMovementComponent_HasLocomotionProfile Parms{};

	Parms.locomotionProfile = locomotionProfile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.OnBaseCharacterLanded
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::OnBaseCharacterLanded(const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OnBaseCharacterLanded");

	Params::EverholmCharacterMovementComponent_OnBaseCharacterLanded Parms{};

	Parms.HitResult = std::move(HitResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.OnJumpEnded
// (Final, Native, Public)

void UEverholmCharacterMovementComponent::OnJumpEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OnJumpEnded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.OnMotionWarpingEnded
// (Final, Native, Protected)
// Parameters:
// class UMotionWarpingComponent*          MotionWarpingComp                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class URootMotionModifier*              modifier                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::OnMotionWarpingEnded(class UMotionWarpingComponent* MotionWarpingComp, class URootMotionModifier* modifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OnMotionWarpingEnded");

	Params::EverholmCharacterMovementComponent_OnMotionWarpingEnded Parms{};

	Parms.MotionWarpingComp = MotionWarpingComp;
	Parms.modifier = modifier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.OnRep_ReplicatedIdleState
// (Native, Protected)

void UEverholmCharacterMovementComponent::OnRep_ReplicatedIdleState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OnRep_ReplicatedIdleState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.OnRep_ReplicatedMovementModeData
// (Native, Protected)

void UEverholmCharacterMovementComponent::OnRep_ReplicatedMovementModeData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OnRep_ReplicatedMovementModeData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.OnRep_ReplicatedRootMovementValues
// (Native, Protected)

void UEverholmCharacterMovementComponent::OnRep_ReplicatedRootMovementValues()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OnRep_ReplicatedRootMovementValues");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.OnRep_ReplicatedSmoothTurningDirection
// (Native, Protected)

void UEverholmCharacterMovementComponent::OnRep_ReplicatedSmoothTurningDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OnRep_ReplicatedSmoothTurningDirection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.OverrideNewestValidDesiredMovementDir
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::OverrideNewestValidDesiredMovementDir(const struct FVector& Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "OverrideNewestValidDesiredMovementDir");

	Params::EverholmCharacterMovementComponent_OverrideNewestValidDesiredMovementDir Parms{};

	Parms.Direction = std::move(Direction);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.PlayAnimMontage_Replicated
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FEverholmMotionWarpingTarget>&motionWarpingTargets                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   PlayRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartSectionName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmCharacterMovementComponent::PlayAnimMontage_Replicated(class UAnimMontage* AnimMontage, const TArray<struct FEverholmMotionWarpingTarget>& motionWarpingTargets, float PlayRate, class FName StartSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "PlayAnimMontage_Replicated");

	Params::EverholmCharacterMovementComponent_PlayAnimMontage_Replicated Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.motionWarpingTargets = std::move(motionWarpingTargets);
	Parms.PlayRate = PlayRate;
	Parms.StartSectionName = StartSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.PlayRootMovementMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PlaybackSpeed                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             startSection                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmCharacterMovementComponent::PlayRootMovementMontage(class UAnimMontage* Montage, float PlaybackSpeed, class FName startSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "PlayRootMovementMontage");

	Params::EverholmCharacterMovementComponent_PlayRootMovementMontage Parms{};

	Parms.Montage = Montage;
	Parms.PlaybackSpeed = PlaybackSpeed;
	Parms.startSection = startSection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.RemoveAllLocomotionProfiles
// (Final, Native, Public, BlueprintCallable)

void UEverholmCharacterMovementComponent::RemoveAllLocomotionProfiles()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "RemoveAllLocomotionProfiles");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.RequestMovementMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EEverholmCharacterMovementMode          requestedMovementMode                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          requester                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::RequestMovementMode(EEverholmCharacterMovementMode requestedMovementMode, class UObject* requester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "RequestMovementMode");

	Params::EverholmCharacterMovementComponent_RequestMovementMode Parms{};

	Parms.requestedMovementMode = requestedMovementMode;
	Parms.requester = requester;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.Server_ClientFinishedAligning
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// EEndAlignmentResult                     endResult                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::Server_ClientFinishedAligning(EEndAlignmentResult endResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "Server_ClientFinishedAligning");

	Params::EverholmCharacterMovementComponent_Server_ClientFinishedAligning Parms{};

	Parms.endResult = endResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.SetDesiredMovement
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Movement                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::SetDesiredMovement(const struct FVector& Movement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "SetDesiredMovement");

	Params::EverholmCharacterMovementComponent_SetDesiredMovement Parms{};

	Parms.Movement = std::move(Movement);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.SetDesiredRotation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  desiredRot                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::SetDesiredRotation(const struct FRotator& desiredRot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "SetDesiredRotation");

	Params::EverholmCharacterMovementComponent_SetDesiredRotation Parms{};

	Parms.desiredRot = std::move(desiredRot);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.SetUseAccelerationForPathFollowing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUseAccel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::SetUseAccelerationForPathFollowing(bool bUseAccel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "SetUseAccelerationForPathFollowing");

	Params::EverholmCharacterMovementComponent_SetUseAccelerationForPathFollowing Parms{};

	Parms.bUseAccel = bUseAccel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.SetUseDesiredRotation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUseDesiredRot                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::SetUseDesiredRotation(bool bUseDesiredRot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "SetUseDesiredRotation");

	Params::EverholmCharacterMovementComponent_SetUseDesiredRotation Parms{};

	Parms.bUseDesiredRot = bUseDesiredRot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.SetVelocity
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   NewVelocity                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bClampToMaxSpeed                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::SetVelocity(const struct FVector& NewVelocity, const bool bClampToMaxSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "SetVelocity");

	Params::EverholmCharacterMovementComponent_SetVelocity Parms{};

	Parms.NewVelocity = std::move(NewVelocity);
	Parms.bClampToMaxSpeed = bClampToMaxSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.StopAllAnimMontages_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             BlendOutTime                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::StopAllAnimMontages_Replicated(const float BlendOutTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "StopAllAnimMontages_Replicated");

	Params::EverholmCharacterMovementComponent_StopAllAnimMontages_Replicated Parms{};

	Parms.BlendOutTime = BlendOutTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.StopAnimMontage_Replicated
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             BlendOutTime                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::StopAnimMontage_Replicated(const float BlendOutTime, class UAnimMontage* AnimMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "StopAnimMontage_Replicated");

	Params::EverholmCharacterMovementComponent_StopAnimMontage_Replicated Parms{};

	Parms.BlendOutTime = BlendOutTime;
	Parms.AnimMontage = AnimMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.StopRootMovementMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     montageToStop                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::StopRootMovementMontage(class UAnimMontage* montageToStop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "StopRootMovementMontage");

	Params::EverholmCharacterMovementComponent_StopRootMovementMontage Parms{};

	Parms.montageToStop = montageToStop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.TranslateMotionWarpingTarget
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Delta                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      motionWarpingTargetName                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::TranslateMotionWarpingTarget(const struct FVector& Delta, const class FName& motionWarpingTargetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "TranslateMotionWarpingTarget");

	Params::EverholmCharacterMovementComponent_TranslateMotionWarpingTarget Parms{};

	Parms.Delta = std::move(Delta);
	Parms.motionWarpingTargetName = motionWarpingTargetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.UnrequestMovementMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          requester                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmCharacterMovementComponent::UnrequestMovementMode(class UObject* requester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "UnrequestMovementMode");

	Params::EverholmCharacterMovementComponent_UnrequestMovementMode Parms{};

	Parms.requester = requester;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacterMovementComponent.GetActualRootMovementMontage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UEverholmCharacterMovementComponent::GetActualRootMovementMontage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetActualRootMovementMontage");

	Params::EverholmCharacterMovementComponent_GetActualRootMovementMontage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetClimbingData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FSurfaceClimbingData       ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FSurfaceClimbingData UEverholmCharacterMovementComponent::GetClimbingData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetClimbingData");

	Params::EverholmCharacterMovementComponent_GetClimbingData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetCurrentGait
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EMovementGait                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMovementGait UEverholmCharacterMovementComponent::GetCurrentGait() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetCurrentGait");

	Params::EverholmCharacterMovementComponent_GetCurrentGait Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetCurrentMovementMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EEverholmCharacterMovementMode          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EEverholmCharacterMovementMode UEverholmCharacterMovementComponent::GetCurrentMovementMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetCurrentMovementMode");

	Params::EverholmCharacterMovementComponent_GetCurrentMovementMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetCurrentSlopeAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FEverholmSlopeDetails            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FEverholmSlopeDetails UEverholmCharacterMovementComponent::GetCurrentSlopeAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetCurrentSlopeAngle");

	Params::EverholmCharacterMovementComponent_GetCurrentSlopeAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetCurrentSpeed2D
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bIsActualVelocity                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmCharacterMovementComponent::GetCurrentSpeed2D(bool bIsActualVelocity) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetCurrentSpeed2D");

	Params::EverholmCharacterMovementComponent_GetCurrentSpeed2D Parms{};

	Parms.bIsActualVelocity = bIsActualVelocity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetDesiredCapsuleDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterMovementComponent::GetDesiredCapsuleDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetDesiredCapsuleDirection");

	Params::EverholmCharacterMovementComponent_GetDesiredCapsuleDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetDesiredMovement
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterMovementComponent::GetDesiredMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetDesiredMovement");

	Params::EverholmCharacterMovementComponent_GetDesiredMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetDesiredRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UEverholmCharacterMovementComponent::GetDesiredRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetDesiredRotation");

	Params::EverholmCharacterMovementComponent_GetDesiredRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetFavoredSmoothTurningAngle
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   ForwardVector                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InputVector                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        FavoredAngle                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// ESmoothTurningFavoredDirection          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESmoothTurningFavoredDirection UEverholmCharacterMovementComponent::GetFavoredSmoothTurningAngle(const struct FVector& ForwardVector, const struct FVector& InputVector, struct FRotator* FavoredAngle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetFavoredSmoothTurningAngle");

	Params::EverholmCharacterMovementComponent_GetFavoredSmoothTurningAngle Parms{};

	Parms.ForwardVector = std::move(ForwardVector);
	Parms.InputVector = std::move(InputVector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (FavoredAngle != nullptr)
		*FavoredAngle = std::move(Parms.FavoredAngle);

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetFeetLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterMovementComponent::GetFeetLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetFeetLocation");

	Params::EverholmCharacterMovementComponent_GetFeetLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetGaitForDiscreetMaxSpeed
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   maxSpeedToCheck                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMovementGait                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMovementGait UEverholmCharacterMovementComponent::GetGaitForDiscreetMaxSpeed(float maxSpeedToCheck) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetGaitForDiscreetMaxSpeed");

	Params::EverholmCharacterMovementComponent_GetGaitForDiscreetMaxSpeed Parms{};

	Parms.maxSpeedToCheck = maxSpeedToCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetHasCrouchIntent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::GetHasCrouchIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetHasCrouchIntent");

	Params::EverholmCharacterMovementComponent_GetHasCrouchIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetHasWalkIntent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::GetHasWalkIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetHasWalkIntent");

	Params::EverholmCharacterMovementComponent_GetHasWalkIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetIsJumping
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::GetIsJumping() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetIsJumping");

	Params::EverholmCharacterMovementComponent_GetIsJumping Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetIsLedgeClimbing
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::GetIsLedgeClimbing() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetIsLedgeClimbing");

	Params::EverholmCharacterMovementComponent_GetIsLedgeClimbing Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetIsSprinting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::GetIsSprinting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetIsSprinting");

	Params::EverholmCharacterMovementComponent_GetIsSprinting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetJumpDestination
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterMovementComponent::GetJumpDestination() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetJumpDestination");

	Params::EverholmCharacterMovementComponent_GetJumpDestination Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetJumpSettings
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FJumpMovementSettings            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FJumpMovementSettings UEverholmCharacterMovementComponent::GetJumpSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetJumpSettings");

	Params::EverholmCharacterMovementComponent_GetJumpSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetLastConsumedDesiredMovement
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterMovementComponent::GetLastConsumedDesiredMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetLastConsumedDesiredMovement");

	Params::EverholmCharacterMovementComponent_GetLastConsumedDesiredMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetLastTickLocation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterMovementComponent::GetLastTickLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetLastTickLocation");

	Params::EverholmCharacterMovementComponent_GetLastTickLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetLastTickRotation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UEverholmCharacterMovementComponent::GetLastTickRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetLastTickRotation");

	Params::EverholmCharacterMovementComponent_GetLastTickRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetLocomotionData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGeneralLocomotionData     ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FGeneralLocomotionData UEverholmCharacterMovementComponent::GetLocomotionData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetLocomotionData");

	Params::EverholmCharacterMovementComponent_GetLocomotionData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetMotionMatchingChooserTable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UChooserTable*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UChooserTable* UEverholmCharacterMovementComponent::GetMotionMatchingChooserTable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetMotionMatchingChooserTable");

	Params::EverholmCharacterMovementComponent_GetMotionMatchingChooserTable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetMovementAccelerations
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FEverholmMovementAcceleration    ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FEverholmMovementAcceleration UEverholmCharacterMovementComponent::GetMovementAccelerations() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetMovementAccelerations");

	Params::EverholmCharacterMovementComponent_GetMovementAccelerations Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetMovementDelta
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmCharacterMovementComponent::GetMovementDelta() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetMovementDelta");

	Params::EverholmCharacterMovementComponent_GetMovementDelta Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetMovementModeObject
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TSubclassOf<class UMovementMode>  movementModeClass                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UEverholmCharacterMovementComponent::GetMovementModeObject(const TSubclassOf<class UMovementMode> movementModeClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetMovementModeObject");

	Params::EverholmCharacterMovementComponent_GetMovementModeObject Parms{};

	Parms.movementModeClass = movementModeClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetMovementSpeeds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FEverholmMovementSpeeds          ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FEverholmMovementSpeeds UEverholmCharacterMovementComponent::GetMovementSpeeds() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetMovementSpeeds");

	Params::EverholmCharacterMovementComponent_GetMovementSpeeds Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetRootMovementMontage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* UEverholmCharacterMovementComponent::GetRootMovementMontage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetRootMovementMontage");

	Params::EverholmCharacterMovementComponent_GetRootMovementMontage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetShouldFootIK
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::GetShouldFootIK() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetShouldFootIK");

	Params::EverholmCharacterMovementComponent_GetShouldFootIK Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetSmoothTurningParameters
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FSmoothTurningData               ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FSmoothTurningData UEverholmCharacterMovementComponent::GetSmoothTurningParameters() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetSmoothTurningParameters");

	Params::EverholmCharacterMovementComponent_GetSmoothTurningParameters Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.GetUseAccelerationForPathFollowing
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::GetUseAccelerationForPathFollowing() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "GetUseAccelerationForPathFollowing");

	Params::EverholmCharacterMovementComponent_GetUseAccelerationForPathFollowing Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsAboutToOrIsPlayingRootMotionMontage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsAboutToOrIsPlayingRootMotionMontage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsAboutToOrIsPlayingRootMotionMontage");

	Params::EverholmCharacterMovementComponent_IsAboutToOrIsPlayingRootMotionMontage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsAligning
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsAligning() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsAligning");

	Params::EverholmCharacterMovementComponent_IsAligning Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsHandholding
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsHandholding() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsHandholding");

	Params::EverholmCharacterMovementComponent_IsHandholding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsHandholdingDriver
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsHandholdingDriver() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsHandholdingDriver");

	Params::EverholmCharacterMovementComponent_IsHandholdingDriver Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsHandholdingPassenger
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsHandholdingPassenger() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsHandholdingPassenger");

	Params::EverholmCharacterMovementComponent_IsHandholdingPassenger Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsIdle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsIdle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsIdle");

	Params::EverholmCharacterMovementComponent_IsIdle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsInputAbusePreventionActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsInputAbusePreventionActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsInputAbusePreventionActive");

	Params::EverholmCharacterMovementComponent_IsInputAbusePreventionActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsLongIdle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsLongIdle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsLongIdle");

	Params::EverholmCharacterMovementComponent_IsLongIdle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsMovementModeActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EEverholmCharacterMovementMode          characterMovementMode                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsMovementModeActive(EEverholmCharacterMovementMode characterMovementMode) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsMovementModeActive");

	Params::EverholmCharacterMovementComponent_IsMovementModeActive Parms{};

	Parms.characterMovementMode = characterMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsPlayingRootMotionMontage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsPlayingRootMotionMontage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsPlayingRootMotionMontage");

	Params::EverholmCharacterMovementComponent_IsPlayingRootMotionMontage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsRootMovementMontagePlaying
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UAnimMontage*               Montage                                                (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsRootMovementMontagePlaying(const class UAnimMontage* Montage) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsRootMovementMontagePlaying");

	Params::EverholmCharacterMovementComponent_IsRootMovementMontagePlaying Parms{};

	Parms.Montage = Montage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsRootMovementPlaying
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsRootMovementPlaying() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsRootMovementPlaying");

	Params::EverholmCharacterMovementComponent_IsRootMovementPlaying Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsSurfaceClimbing
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsSurfaceClimbing() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsSurfaceClimbing");

	Params::EverholmCharacterMovementComponent_IsSurfaceClimbing Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.IsTiedTogether
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::IsTiedTogether() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "IsTiedTogether");

	Params::EverholmCharacterMovementComponent_IsTiedTogether Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.ShouldMovementModeUseMotionMatching
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::ShouldMovementModeUseMotionMatching() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "ShouldMovementModeUseMotionMatching");

	Params::EverholmCharacterMovementComponent_ShouldMovementModeUseMotionMatching Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacterMovementComponent.SupportsMotionMatching
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmCharacterMovementComponent::SupportsMotionMatching() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacterMovementComponent", "SupportsMotionMatching");

	Params::EverholmCharacterMovementComponent_SupportsMotionMatching Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.Explode
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AEverholmCharacter_CrawlingSoldier::Explode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "Explode");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.OnAnyDamageTaken
// (Final, Native, Protected)
// Parameters:
// class AActor*                           DamagedActor                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDamageType*                DamageType                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_CrawlingSoldier::OnAnyDamageTaken(class AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "OnAnyDamageTaken");

	Params::EverholmCharacter_CrawlingSoldier_OnAnyDamageTaken Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.DamageType = DamageType;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.OnRep_CurrentState
// (Final, Native, Protected)

void AEverholmCharacter_CrawlingSoldier::OnRep_CurrentState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "OnRep_CurrentState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.OnRep_CurrentSubState
// (Final, Native, Protected)

void AEverholmCharacter_CrawlingSoldier::OnRep_CurrentSubState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "OnRep_CurrentSubState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.PlayExplosionFX
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void AEverholmCharacter_CrawlingSoldier::PlayExplosionFX()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "PlayExplosionFX");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.SetState
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// ECrawlingSoldierState                   NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_CrawlingSoldier::SetState(ECrawlingSoldierState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "SetState");

	Params::EverholmCharacter_CrawlingSoldier_SetState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.SetSubstate
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// ECrawlingSoldierSubstate                newSubstate                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_CrawlingSoldier::SetSubstate(ECrawlingSoldierSubstate newSubstate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "SetSubstate");

	Params::EverholmCharacter_CrawlingSoldier_SetSubstate Parms{};

	Parms.newSubstate = newSubstate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.IsCurrentState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECrawlingSoldierState                   State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter_CrawlingSoldier::IsCurrentState(ECrawlingSoldierState State) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "IsCurrentState");

	Params::EverholmCharacter_CrawlingSoldier_IsCurrentState Parms{};

	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_CrawlingSoldier.IsCurrentSubstate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECrawlingSoldierSubstate                substate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter_CrawlingSoldier::IsCurrentSubstate(ECrawlingSoldierSubstate substate) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_CrawlingSoldier", "IsCurrentSubstate");

	Params::EverholmCharacter_CrawlingSoldier_IsCurrentSubstate Parms{};

	Parms.substate = substate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_SheepBeast.AllowLeavingArea
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              isAllowedToLeaveArea                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_SheepBeast::AllowLeavingArea(const bool isAllowedToLeaveArea)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "AllowLeavingArea");

	Params::EverholmCharacter_SheepBeast_AllowLeavingArea Parms{};

	Parms.isAllowedToLeaveArea = isAllowedToLeaveArea;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_SheepBeast.OnRep_CurrentState
// (Final, Native, Protected)

void AEverholmCharacter_SheepBeast::OnRep_CurrentState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "OnRep_CurrentState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_SheepBeast.OnRep_GrabArea
// (Final, Native, Protected)

void AEverholmCharacter_SheepBeast::OnRep_GrabArea()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "OnRep_GrabArea");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_SheepBeast.OnStateEntered
// (Event, Public, BlueprintEvent)
// Parameters:
// const ESheepBeastState                  previousState                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ESheepBeastState                  NewState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_SheepBeast::OnStateEntered(const ESheepBeastState previousState, const ESheepBeastState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "OnStateEntered");

	Params::EverholmCharacter_SheepBeast_OnStateEntered Parms{};

	Parms.previousState = previousState;
	Parms.NewState = NewState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmCharacter_SheepBeast.SetState
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const ESheepBeastState                  NewState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const uint8                             customSheepBeastState                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_SheepBeast::SetState(const ESheepBeastState NewState, const uint8 customSheepBeastState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "SetState");

	Params::EverholmCharacter_SheepBeast_SetState Parms{};

	Parms.NewState = NewState;
	Parms.customSheepBeastState = customSheepBeastState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_SheepBeast.GetSuspiciousAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AEverholmCharacter_SheepBeast::GetSuspiciousAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "GetSuspiciousAngle");

	Params::EverholmCharacter_SheepBeast_GetSuspiciousAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_SheepBeast.GetTargetLocationProjectedToGrabArea
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              bNormalize                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bInvertXAxis                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector2D                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector2D AEverholmCharacter_SheepBeast::GetTargetLocationProjectedToGrabArea(const bool bNormalize, const bool bInvertXAxis) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "GetTargetLocationProjectedToGrabArea");

	Params::EverholmCharacter_SheepBeast_GetTargetLocationProjectedToGrabArea Parms{};

	Parms.bNormalize = bNormalize;
	Parms.bInvertXAxis = bInvertXAxis;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_SheepBeast.IsCustomState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const uint8                             customState                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter_SheepBeast::IsCustomState(const uint8 customState) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_SheepBeast", "IsCustomState");

	Params::EverholmCharacter_SheepBeast_IsCustomState Parms{};

	Parms.customState = customState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_Sniffer.OnSnifferMovementModeChangedEvent
// (Event, Public, BlueprintEvent)
// Parameters:
// const ESnifferMovementMode              NewMovementMode                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_Sniffer::OnSnifferMovementModeChangedEvent(const ESnifferMovementMode NewMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Sniffer", "OnSnifferMovementModeChangedEvent");

	Params::EverholmCharacter_Sniffer_OnSnifferMovementModeChangedEvent Parms{};

	Parms.NewMovementMode = NewMovementMode;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmCharacter_Sniffer.SetSnifferMovementMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const ESnifferMovementMode              snifferMovementMode                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              forceTransition                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              skipTransitionAnim                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_Sniffer::SetSnifferMovementMode(const ESnifferMovementMode snifferMovementMode, const bool forceTransition, const bool skipTransitionAnim)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Sniffer", "SetSnifferMovementMode");

	Params::EverholmCharacter_Sniffer_SetSnifferMovementMode Parms{};

	Parms.snifferMovementMode = snifferMovementMode;
	Parms.forceTransition = forceTransition;
	Parms.skipTransitionAnim = skipTransitionAnim;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Sniffer.SetVisualSensorLocalOffset
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   LocalOffset                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_Sniffer::SetVisualSensorLocalOffset(float LocalOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Sniffer", "SetVisualSensorLocalOffset");

	Params::EverholmCharacter_Sniffer_SetVisualSensorLocalOffset Parms{};

	Parms.LocalOffset = LocalOffset;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmCharacter_Sniffer.CanTransitionToQuad
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAILocationUnion&          locationToCheck                                        (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmCharacter_Sniffer::CanTransitionToQuad(const struct FAILocationUnion& locationToCheck) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Sniffer", "CanTransitionToQuad");

	Params::EverholmCharacter_Sniffer_CanTransitionToQuad Parms{};

	Parms.locationToCheck = std::move(locationToCheck);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_Sniffer.GetSnifferMovementMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ESnifferMovementMode                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESnifferMovementMode AEverholmCharacter_Sniffer::GetSnifferMovementMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Sniffer", "GetSnifferMovementMode");

	Params::EverholmCharacter_Sniffer_GetSnifferMovementMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_Spiderkid.Despawn
// (Final, Native, Public, BlueprintCallable)

void AEverholmCharacter_Spiderkid::Despawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "Despawn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Spiderkid.OnAIAlertStateChanged
// (Final, Native, Private)
// Parameters:
// EAIAlertState                           currentState                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIAlertState                           previousState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_Spiderkid::OnAIAlertStateChanged(EAIAlertState currentState, EAIAlertState previousState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "OnAIAlertStateChanged");

	Params::EverholmCharacter_Spiderkid_OnAIAlertStateChanged Parms{};

	Parms.currentState = currentState;
	Parms.previousState = previousState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Spiderkid.OnAnalyzersInitialized
// (Final, Native, Private)

void AEverholmCharacter_Spiderkid::OnAnalyzersInitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "OnAnalyzersInitialized");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Spiderkid.OnPetrificationBegin
// (Event, Public, BlueprintEvent)

void AEverholmCharacter_Spiderkid::OnPetrificationBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "OnPetrificationBegin");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmCharacter_Spiderkid.OnPetrificationEnded
// (Event, Public, BlueprintEvent)

void AEverholmCharacter_Spiderkid::OnPetrificationEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "OnPetrificationEnded");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmCharacter_Spiderkid.OnSpiderkidIlluminationStateChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// const ESpiderkidIlluminationState       newIlluminationState                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_Spiderkid::OnSpiderkidIlluminationStateChanged(const ESpiderkidIlluminationState newIlluminationState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "OnSpiderkidIlluminationStateChanged");

	Params::EverholmCharacter_Spiderkid_OnSpiderkidIlluminationStateChanged Parms{};

	Parms.newIlluminationState = newIlluminationState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmCharacter_Spiderkid.Petrify
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bAlsoDestroyController                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_Spiderkid::Petrify(const bool bAlsoDestroyController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "Petrify");

	Params::EverholmCharacter_Spiderkid_Petrify Parms{};

	Parms.bAlsoDestroyController = bAlsoDestroyController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Spiderkid.SetIlluminationState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const ESpiderkidIlluminationState       newIlluminationState                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmCharacter_Spiderkid::SetIlluminationState(const ESpiderkidIlluminationState newIlluminationState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "SetIlluminationState");

	Params::EverholmCharacter_Spiderkid_SetIlluminationState Parms{};

	Parms.newIlluminationState = newIlluminationState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmCharacter_Spiderkid.GetIlluminationState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ESpiderkidIlluminationState             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESpiderkidIlluminationState AEverholmCharacter_Spiderkid::GetIlluminationState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "GetIlluminationState");

	Params::EverholmCharacter_Spiderkid_GetIlluminationState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmCharacter_Spiderkid.GetTimeSinceCombatStarted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AEverholmCharacter_Spiderkid::GetTimeSinceCombatStarted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmCharacter_Spiderkid", "GetTimeSinceCombatStarted");

	Params::EverholmCharacter_Spiderkid_GetTimeSinceCombatStarted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmClientViewport.GetEverholmViewportClient
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmClientViewport*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmClientViewport* UEverholmClientViewport::GetEverholmViewportClient(const class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmClientViewport", "GetEverholmViewportClient");

	Params::EverholmClientViewport_GetEverholmViewportClient Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmClientViewport.SetPlayerViewRect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FViewRect&                 ViewRect                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UEverholmClientViewport::SetPlayerViewRect(int32 LocalPlayerIndex, const struct FViewRect& ViewRect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmClientViewport", "SetPlayerViewRect");

	Params::EverholmClientViewport_SetPlayerViewRect Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;
	Parms.ViewRect = std::move(ViewRect);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmClientViewport.GetPlayerFovMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFovLockAxis                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFovLockAxis UEverholmClientViewport::GetPlayerFovMode(int32 LocalPlayerIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmClientViewport", "GetPlayerFovMode");

	Params::EverholmClientViewport_GetPlayerFovMode Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmClientViewport.GetPlayerViewRect
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FViewRect                        ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FViewRect UEverholmClientViewport::GetPlayerViewRect(int32 LocalPlayerIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmClientViewport", "GetPlayerViewRect");

	Params::EverholmClientViewport_GetPlayerViewRect Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmClientViewport.SetPlayerFovMode
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFovLockAxis                            Mode                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmClientViewport::SetPlayerFovMode(int32 LocalPlayerIndex, EFovLockAxis Mode) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmClientViewport", "SetPlayerFovMode");

	Params::EverholmClientViewport_SetPlayerFovMode Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;
	Parms.Mode = Mode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleTrackingSubsystem.EnterVehicle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         PlayerPawnType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class AVehicleActor>     Vehicle                                                (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerRoleInVehicle                    RoleInVehicle                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleTrackingSubsystem::EnterVehicle(EPlayerPawnType PlayerPawnType, TSoftObjectPtr<class AVehicleActor> Vehicle, EPlayerRoleInVehicle RoleInVehicle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleTrackingSubsystem", "EnterVehicle");

	Params::VehicleTrackingSubsystem_EnterVehicle Parms{};

	Parms.PlayerPawnType = PlayerPawnType;
	Parms.Vehicle = Vehicle;
	Parms.RoleInVehicle = RoleInVehicle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleTrackingSubsystem.TeleportAndEnterVehicle
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// EPlayerPawnType                         PlayerPawnType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class AVehicleActor>     Vehicle                                                (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerRoleInVehicle                    RoleInVehicle                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTeleport                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                teleportTo                                             (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSaveRestore                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleTrackingSubsystem::TeleportAndEnterVehicle(EPlayerPawnType PlayerPawnType, TSoftObjectPtr<class AVehicleActor> Vehicle, EPlayerRoleInVehicle RoleInVehicle, bool bTeleport, const struct FTransform& teleportTo, bool bSaveRestore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleTrackingSubsystem", "TeleportAndEnterVehicle");

	Params::VehicleTrackingSubsystem_TeleportAndEnterVehicle Parms{};

	Parms.PlayerPawnType = PlayerPawnType;
	Parms.Vehicle = Vehicle;
	Parms.RoleInVehicle = RoleInVehicle;
	Parms.bTeleport = bTeleport;
	Parms.teleportTo = std::move(teleportTo);
	Parms.bSaveRestore = bSaveRestore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameEventBlueprintLibrary.BroadcastOrientedWorldEvent
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EventLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   eventDirection                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             customEventID                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   maxRange                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     ignoredActor                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEventDispatchMode                      dispatchMode                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameEventBlueprintLibrary::BroadcastOrientedWorldEvent(const class UObject* WorldContext, const struct FVector& EventLocation, const struct FVector& eventDirection, class FName customEventID, float maxRange, const class AActor* ignoredActor, EEventDispatchMode dispatchMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameEventBlueprintLibrary", "BroadcastOrientedWorldEvent");

	Params::EverholmGameEventBlueprintLibrary_BroadcastOrientedWorldEvent Parms{};

	Parms.WorldContext = WorldContext;
	Parms.EventLocation = std::move(EventLocation);
	Parms.eventDirection = std::move(eventDirection);
	Parms.customEventID = customEventID;
	Parms.maxRange = maxRange;
	Parms.ignoredActor = ignoredActor;
	Parms.dispatchMode = dispatchMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuContainer.AddMainMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UMenuItems>           WidgetClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMenuContainer::AddMainMenu(TSubclassOf<class UMenuItems> WidgetClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuContainer", "AddMainMenu");

	Params::MenuContainer_AddMainMenu Parms{};

	Parms.WidgetClass = WidgetClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuContainer.GetMainSlotWidgetClass
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UClass*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UClass* UMenuContainer::GetMainSlotWidgetClass()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuContainer", "GetMainSlotWidgetClass");

	Params::MenuContainer_GetMainSlotWidgetClass Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MenuContainer.MainSlotAnimInFinished
// (Final, Native, Protected)

void UMenuContainer::MainSlotAnimInFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuContainer", "MainSlotAnimInFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuContainer.MainSlotAnimOutFinished
// (Final, Native, Protected)

void UMenuContainer::MainSlotAnimOutFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuContainer", "MainSlotAnimOutFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuContainer.RemoveMainMenu
// (Final, Native, Public, BlueprintCallable)

void UMenuContainer::RemoveMainMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuContainer", "RemoveMainMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuContainer.HasMainMenu
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMenuContainer::HasMainMenu() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuContainer", "HasMainMenu");

	Params::MenuContainer_HasMainMenu Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadialInwardSphereHint.DebugHint
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// float                                   yawEffectAlpha                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadialInwardSphereHint::DebugHint(float yawEffectAlpha) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadialInwardSphereHint", "DebugHint");

	Params::RadialInwardSphereHint_DebugHint Parms{};

	Parms.yawEffectAlpha = yawEffectAlpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.EverholmReadyToStart
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameModeBase::EverholmReadyToStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "EverholmReadyToStart");

	Params::EverholmGameModeBase_EverholmReadyToStart Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameModeBase.OnGameplayTagCountChanged
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              GameplayTag                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameModeBase::OnGameplayTagCountChanged(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& GameplayTag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "OnGameplayTagCountChanged");

	Params::EverholmGameModeBase_OnGameplayTagCountChanged Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.GameplayTag = std::move(GameplayTag);
	Parms.bWasAdded = bWasAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.OnPlayerDisconnect
// (Native, Event, Protected, BlueprintEvent)

void AEverholmGameModeBase::OnPlayerDisconnect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "OnPlayerDisconnect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.OnPlayerLogin
// (Native, Event, Protected, BlueprintEvent)

void AEverholmGameModeBase::OnPlayerLogin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "OnPlayerLogin");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.OnPlayerLogout
// (Native, Event, Protected, BlueprintEvent)

void AEverholmGameModeBase::OnPlayerLogout()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "OnPlayerLogout");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.OnRespawnPlayers
// (Final, Native, Protected)

void AEverholmGameModeBase::OnRespawnPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "OnRespawnPlayers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.OnRestartFlow_StartGameplayAndPickupLevelStreamIn
// (Final, Native, Private)

void AEverholmGameModeBase::OnRestartFlow_StartGameplayAndPickupLevelStreamIn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "OnRestartFlow_StartGameplayAndPickupLevelStreamIn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.RequestSwapCharacters
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         PlayerCharacter                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmGameModeBase::RequestSwapCharacters(class AEverholmPlayerCharacter* PlayerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "RequestSwapCharacters");

	Params::EverholmGameModeBase_RequestSwapCharacters Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.Respawn
// (Final, Native, Public, BlueprintCallable)

void AEverholmGameModeBase::Respawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "Respawn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.TravelToSelectedMap
// (Final, Native, Protected, BlueprintCallable)

void AEverholmGameModeBase::TravelToSelectedMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "TravelToSelectedMap");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameModeBase.TryExecuteSwap
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameModeBase::TryExecuteSwap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "TryExecuteSwap");

	Params::EverholmGameModeBase_TryExecuteSwap Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameModeBase.TryRemoveLocalCoPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameModeBase::TryRemoveLocalCoPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "TryRemoveLocalCoPlayer");

	Params::EverholmGameModeBase_TryRemoveLocalCoPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameModeBase.TrySpawnLocalCoPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameModeBase::TrySpawnLocalCoPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "TrySpawnLocalCoPlayer");

	Params::EverholmGameModeBase_TrySpawnLocalCoPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameModeBase.IsReloadingWorld
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameModeBase::IsReloadingWorld() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "IsReloadingWorld");

	Params::EverholmGameModeBase_IsReloadingWorld Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameModeBase.ShouldUseCompanionAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmGameModeBase::ShouldUseCompanionAI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameModeBase", "ShouldUseCompanionAI");

	Params::EverholmGameModeBase_ShouldUseCompanionAI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettings.ApplyCurrentUserSettings
// (Final, Native, Public, BlueprintCallable)

void UEverholmGameUserSettings::ApplyCurrentUserSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "ApplyCurrentUserSettings");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.OnEndPIE
// (Final, Native, Private)
// Parameters:
// bool                                    bIsSimulating                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::OnEndPIE(bool bIsSimulating)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "OnEndPIE");

	Params::EverholmGameUserSettings_OnEndPIE Parms{};

	Parms.bIsSimulating = bIsSimulating;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.OnGameInstanceStarted
// (Final, Native, Private)
// Parameters:
// class UGameInstance*                    GameInstance                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::OnGameInstanceStarted(class UGameInstance* GameInstance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "OnGameInstanceStarted");

	Params::EverholmGameUserSettings_OnGameInstanceStarted Parms{};

	Parms.GameInstance = GameInstance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.ResetGammaEngineDefault
// (Final, Native, Public, BlueprintCallable)

void UEverholmGameUserSettings::ResetGammaEngineDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "ResetGammaEngineDefault");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.SaveUserSettings
// (Final, Native, Public, BlueprintCallable)

void UEverholmGameUserSettings::SaveUserSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "SaveUserSettings");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.SetCrossplayEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::SetCrossplayEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "SetCrossplayEnabled");

	Params::EverholmGameUserSettings_SetCrossplayEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.SetCurrentCulture
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECulture                                Culture                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::SetCurrentCulture(ECulture Culture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "SetCurrentCulture");

	Params::EverholmGameUserSettings_SetCurrentCulture Parms{};

	Parms.Culture = Culture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.SetGamma
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// double                                  Gamma_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::SetGamma(double Gamma_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "SetGamma");

	Params::EverholmGameUserSettings_SetGamma Parms{};

	Parms.Gamma_0 = Gamma_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.SetMasterVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   masterVolume_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::SetMasterVolume(float masterVolume_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "SetMasterVolume");

	Params::EverholmGameUserSettings_SetMasterVolume Parms{};

	Parms.masterVolume_0 = masterVolume_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.SetPanningRule
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPanningRule                            PanningRule                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::SetPanningRule(EPanningRule PanningRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "SetPanningRule");

	Params::EverholmGameUserSettings_SetPanningRule Parms{};

	Parms.PanningRule = PanningRule;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.SetTelemetryEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmGameUserSettings::SetTelemetryEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "SetTelemetryEnabled");

	Params::EverholmGameUserSettings_SetTelemetryEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmGameUserSettings.GetCurrentCulture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECulture                                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECulture UEverholmGameUserSettings::GetCurrentCulture() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "GetCurrentCulture");

	Params::EverholmGameUserSettings_GetCurrentCulture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettings.GetCurrentGamma
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double                                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

double UEverholmGameUserSettings::GetCurrentGamma() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "GetCurrentGamma");

	Params::EverholmGameUserSettings_GetCurrentGamma Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettings.GetCurrentMasterVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmGameUserSettings::GetCurrentMasterVolume() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "GetCurrentMasterVolume");

	Params::EverholmGameUserSettings_GetCurrentMasterVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettings.GetEverholmGraphicMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ETarsierGraphicMode                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ETarsierGraphicMode UEverholmGameUserSettings::GetEverholmGraphicMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "GetEverholmGraphicMode");

	Params::EverholmGameUserSettings_GetEverholmGraphicMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettings.GetPanningRule
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPanningRule                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPanningRule UEverholmGameUserSettings::GetPanningRule() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "GetPanningRule");

	Params::EverholmGameUserSettings_GetPanningRule Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettings.IsCrossplayEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameUserSettings::IsCrossplayEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "IsCrossplayEnabled");

	Params::EverholmGameUserSettings_IsCrossplayEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettings.IsTelemetryEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmGameUserSettings::IsTelemetryEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmGameUserSettings", "IsTelemetryEnabled");

	Params::EverholmGameUserSettings_IsTelemetryEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmGameUserSettingsBlueprintLibrary.GetEverholmsGameUserSettings
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UEverholmGameUserSettings*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmGameUserSettings* UEverholmGameUserSettingsBlueprintLibrary::GetEverholmsGameUserSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmGameUserSettingsBlueprintLibrary", "GetEverholmsGameUserSettings");

	Params::EverholmGameUserSettingsBlueprintLibrary_GetEverholmsGameUserSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameMode.CancelEndDemoSession
// (Final, Native, Public, BlueprintCallable)

void AEverholmIngameGameMode::CancelEndDemoSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "CancelEndDemoSession");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.ClearSavedCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bClearAllLevels                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameMode::ClearSavedCheckpoint(bool bClearAllLevels)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "ClearSavedCheckpoint");

	Params::EverholmIngameGameMode_ClearSavedCheckpoint Parms{};

	Parms.bClearAllLevels = bClearAllLevels;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.DisableTrailerCamera
// (Final, Native, Public, BlueprintCallable)

void AEverholmIngameGameMode::DisableTrailerCamera()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "DisableTrailerCamera");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.EnableTrailerCamera
// (Final, Native, Public, BlueprintCallable)

void AEverholmIngameGameMode::EnableTrailerCamera()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "EnableTrailerCamera");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.EndDemoSession
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AEverholmIngameGameMode::EndDemoSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "EndDemoSession");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.HandleObjectsLoaded
// (Native, Event, Protected, BlueprintEvent)

void AEverholmIngameGameMode::HandleObjectsLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "HandleObjectsLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.OnPlayerStartLoaded
// (Final, Native, Private)

void AEverholmIngameGameMode::OnPlayerStartLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "OnPlayerStartLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.SaveBoatVehicleCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABoatVehicle*                     boat                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWriteToDisk                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameMode::SaveBoatVehicleCheckpoint(class ABoatVehicle* boat, bool bWriteToDisk)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "SaveBoatVehicleCheckpoint");

	Params::EverholmIngameGameMode_SaveBoatVehicleCheckpoint Parms{};

	Parms.boat = boat;
	Parms.bWriteToDisk = bWriteToDisk;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.SaveCheckpoint
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSoftObjectPtr<class AEverholmPlayerStart>&PlayerStart                                            (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWriteToDisk                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmIngameGameMode::SaveCheckpoint(const TSoftObjectPtr<class AEverholmPlayerStart>& PlayerStart, bool bWriteToDisk)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "SaveCheckpoint");

	Params::EverholmIngameGameMode_SaveCheckpoint Parms{};

	Parms.PlayerStart = PlayerStart;
	Parms.bWriteToDisk = bWriteToDisk;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.SaveToDisk
// (Final, Native, Public, BlueprintCallable)

void AEverholmIngameGameMode::SaveToDisk()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "SaveToDisk");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmIngameGameMode.GetCurrentPlayerStart
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSoftObjectPtr<class AEverholmPlayerStart>ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class AEverholmPlayerStart> AEverholmIngameGameMode::GetCurrentPlayerStart() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "GetCurrentPlayerStart");

	Params::EverholmIngameGameMode_GetCurrentPlayerStart Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameMode.GetSavedPlayerStart
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bSpawnBoatPLayerStartIfNotFound                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class AEverholmPlayerStart>ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class AEverholmPlayerStart> AEverholmIngameGameMode::GetSavedPlayerStart(bool bSpawnBoatPLayerStartIfNotFound) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "GetSavedPlayerStart");

	Params::EverholmIngameGameMode_GetSavedPlayerStart Parms{};

	Parms.bSpawnBoatPLayerStartIfNotFound = bSpawnBoatPLayerStartIfNotFound;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameMode.IsEndingDemoSession
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmIngameGameMode::IsEndingDemoSession() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "IsEndingDemoSession");

	Params::EverholmIngameGameMode_IsEndingDemoSession Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmIngameGameMode.IsStreamingLevelReady
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmIngameGameMode::IsStreamingLevelReady() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmIngameGameMode", "IsStreamingLevelReady");

	Params::EverholmIngameGameMode_IsStreamingLevelReady Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SignalActionPointActor.HIP_AbortOrder
// (Final, Native, Public)

void ASignalActionPointActor::HIP_AbortOrder()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_AbortOrder");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_ClearLinkedAIPawn
// (Final, Native, Public)

void ASignalActionPointActor::HIP_ClearLinkedAIPawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_ClearLinkedAIPawn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_DisableActionPoint
// (Final, Native, Public)

void ASignalActionPointActor::HIP_DisableActionPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_DisableActionPoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_EnableActionPoint
// (Final, Native, Public)

void ASignalActionPointActor::HIP_EnableActionPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_EnableActionPoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_JumpToNextMontageSection
// (Final, Native, Public)

void ASignalActionPointActor::HIP_JumpToNextMontageSection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_JumpToNextMontageSection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_NextAction
// (Final, Native, Public)

void ASignalActionPointActor::HIP_NextAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_NextAction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_NextActionIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActionPointActor::HIP_NextActionIndex(int32 Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_NextActionIndex");

	Params::SignalActionPointActor_HIP_NextActionIndex Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_RegisterLinkedAIPawn
// (Final, Native, Public)
// Parameters:
// const struct FHotWireTypeObjectRef&     objectToRegister                                       (Parm, NoDestructor, NativeAccessSpecifierPublic)

void ASignalActionPointActor::HIP_RegisterLinkedAIPawn(const struct FHotWireTypeObjectRef& objectToRegister)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_RegisterLinkedAIPawn");

	Params::SignalActionPointActor_HIP_RegisterLinkedAIPawn Parms{};

	Parms.objectToRegister = std::move(objectToRegister);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HIP_SendOrder
// (Final, Native, Public)

void ASignalActionPointActor::HIP_SendOrder()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HIP_SendOrder");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnActionAborted
// (Final, Native, Protected)

void ASignalActionPointActor::HOP_OnActionAborted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnActionAborted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnActionFinished
// (Final, Native, Protected)

void ASignalActionPointActor::HOP_OnActionFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnActionFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnActionStarted
// (Final, Native, Protected)

void ASignalActionPointActor::HOP_OnActionStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnActionStarted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnAnimNotify
// (Final, Native, Protected)
// Parameters:
// class FName                             Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActionPointActor::HOP_OnAnimNotify(class FName Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnAnimNotify");

	Params::SignalActionPointActor_HOP_OnAnimNotify Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnArrived
// (Final, Native, Protected)

void ASignalActionPointActor::HOP_OnArrived()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnArrived");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnChildActionCompleted
// (Final, Native, Protected)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActionPointActor::HOP_OnChildActionCompleted(int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnChildActionCompleted");

	Params::SignalActionPointActor_HOP_OnChildActionCompleted Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnFreed
// (Final, Native, Protected)

void ASignalActionPointActor::HOP_OnFreed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnFreed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.HOP_OnReserved
// (Final, Native, Protected)

void ASignalActionPointActor::HOP_OnReserved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "HOP_OnReserved");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.JumpToNextMontageSection
// (Final, Native, Public, BlueprintCallable)

void ASignalActionPointActor::JumpToNextMontageSection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "JumpToNextMontageSection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.OnOrderReceived
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    orderActivated                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActionPointActor::OnOrderReceived(bool orderActivated)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "OnOrderReceived");

	Params::SignalActionPointActor_OnOrderReceived Parms{};

	Parms.orderActivated = orderActivated;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.SignalActionPointActor.SendActionPointOrder
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    enableOrder                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActionPointActor::SendActionPointOrder(bool enableOrder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "SendActionPointOrder");

	Params::SignalActionPointActor_SendActionPointOrder Parms{};

	Parms.enableOrder = enableOrder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.SendUseActionPointOrderToPawn
// (Native, Protected, BlueprintCallable)
// Parameters:
// class APawn*                            orderedPawn                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActionPointActor::SendUseActionPointOrderToPawn(class APawn* orderedPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "SendUseActionPointOrderToPawn");

	Params::SignalActionPointActor_SendUseActionPointOrderToPawn Parms{};

	Parms.orderedPawn = orderedPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.SkipCurrentAction
// (Final, Native, Public, BlueprintCallable)

void ASignalActionPointActor::SkipCurrentAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "SkipCurrentAction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActionPointActor.SkipToAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   actionIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActionPointActor::SkipToAction(int32 actionIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActionPointActor", "SkipToAction");

	Params::SignalActionPointActor_SkipToAction Parms{};

	Parms.actionIndex = actionIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractionFunctionLibrary.InteractWithInteractable
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UEverholmInteractorComponent*     Target                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentActionInfo                                       (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)
// class UEverholmInteractionComponent*    Interaction                                            (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bOutWasSuccessful                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmInteractionComponent*    ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmInteractionComponent* UEverholmInteractionFunctionLibrary::InteractWithInteractable(class UEverholmInteractorComponent* Target, const struct FLatentActionInfo& LatentActionInfo, class UEverholmInteractionComponent* Interaction, bool* bOutWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmInteractionFunctionLibrary", "InteractWithInteractable");

	Params::EverholmInteractionFunctionLibrary_InteractWithInteractable Parms{};

	Parms.Target = Target;
	Parms.LatentActionInfo = std::move(LatentActionInfo);
	Parms.Interaction = Interaction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bOutWasSuccessful != nullptr)
		*bOutWasSuccessful = Parms.bOutWasSuccessful;

	return Parms.ReturnValue;
}


// Function Everholm.TeleportAbility.OnExitedTeleportMovement
// (Final, Native, Public)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTeleportAbility::OnExitedTeleportMovement(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TeleportAbility", "OnExitedTeleportMovement");

	Params::TeleportAbility_OnExitedTeleportMovement Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaveSyncManager.OnClientUpdate
// (Final, Native, Protected)

void AWaveSyncManager::OnClientUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaveSyncManager", "OnClientUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaveSyncManager.OnSyncTlFinished
// (Final, Native, Protected)

void AWaveSyncManager::OnSyncTlFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaveSyncManager", "OnSyncTlFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaveSyncManager.OnSyncTlUpdate
// (Final, Native, Protected)
// Parameters:
// float                                   InNewTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWaveSyncManager::OnSyncTlUpdate(float InNewTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaveSyncManager", "OnSyncTlUpdate");

	Params::WaveSyncManager_OnSyncTlUpdate Parms{};

	Parms.InNewTime = InNewTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastConfirmRequest
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FServerConfirmationRequest&confirmationRequest                                    (ConstParm, Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastConfirmRequest(const struct FServerConfirmationRequest& confirmationRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastConfirmRequest");

	Params::EverholmInteractorComponent_MulticastConfirmRequest Parms{};

	Parms.confirmationRequest = std::move(confirmationRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastOnCommittedToInteraction
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastOnCommittedToInteraction(class UEverholmInteractionComponent* InteractionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastOnCommittedToInteraction");

	Params::EverholmInteractorComponent_MulticastOnCommittedToInteraction Parms{};

	Parms.InteractionComponent = InteractionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastOnStopInteraction
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const EInteractEndReason                endReason                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastOnStopInteraction(const EInteractEndReason endReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastOnStopInteraction");

	Params::EverholmInteractorComponent_MulticastOnStopInteraction Parms{};

	Parms.endReason = endReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastOnTryStartInteraction
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasSuccessful                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    debugInteractionName                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastOnTryStartInteraction(class UEverholmInteractionComponent* InteractionComponent, const bool bWasSuccessful, const class FString& debugInteractionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastOnTryStartInteraction");

	Params::EverholmInteractorComponent_MulticastOnTryStartInteraction Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.bWasSuccessful = bWasSuccessful;
	Parms.debugInteractionName = std::move(debugInteractionName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastReleaseCommitFromInteraction
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastReleaseCommitFromInteraction(class UEverholmInteractionComponent* InteractionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastReleaseCommitFromInteraction");

	Params::EverholmInteractorComponent_MulticastReleaseCommitFromInteraction Parms{};

	Parms.InteractionComponent = InteractionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastRetryStartInteraction
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const bool                              bWasSuccessful                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastRetryStartInteraction(const bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastRetryStartInteraction");

	Params::EverholmInteractorComponent_MulticastRetryStartInteraction Parms{};

	Parms.bWasSuccessful = bWasSuccessful;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastSetInteractableInputValue
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ESharedInteractableValueID        ID                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Value                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastSetInteractableInputValue(class UEverholmInteractionComponent* InteractionComponent, const ESharedInteractableValueID ID, const int32 Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastSetInteractableInputValue");

	Params::EverholmInteractorComponent_MulticastSetInteractableInputValue Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.ID = ID;
	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.MulticastTriggerSharedInteractableEvent
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      EventName                                              (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::MulticastTriggerSharedInteractableEvent(class UEverholmInteractionComponent* InteractionComponent, const class FName& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "MulticastTriggerSharedInteractableEvent");

	Params::EverholmInteractorComponent_MulticastTriggerSharedInteractableEvent Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.EventName = EventName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.OnStartPlayingBlockingMontage
// (Event, Public, BlueprintEvent)

void UEverholmInteractorComponent::OnStartPlayingBlockingMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "OnStartPlayingBlockingMontage");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmInteractorComponent.OnStopPlayingBlockingMontage
// (Event, Public, BlueprintEvent)

void UEverholmInteractorComponent::OnStopPlayingBlockingMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "OnStopPlayingBlockingMontage");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmInteractorComponent.ServerOnCommittedToInteraction
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerOnCommittedToInteraction(class UEverholmInteractionComponent* InteractionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerOnCommittedToInteraction");

	Params::EverholmInteractorComponent_ServerOnCommittedToInteraction Parms{};

	Parms.InteractionComponent = InteractionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.ServerOnStopInteraction
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// const EInteractEndReason                endReason                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerOnStopInteraction(const EInteractEndReason endReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerOnStopInteraction");

	Params::EverholmInteractorComponent_ServerOnStopInteraction Parms{};

	Parms.endReason = endReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.ServerOnTryStartInteraction
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasSuccessful                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    debugInteractionName                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerOnTryStartInteraction(class UEverholmInteractionComponent* InteractionComponent, const bool bWasSuccessful, const class FString& debugInteractionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerOnTryStartInteraction");

	Params::EverholmInteractorComponent_ServerOnTryStartInteraction Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.bWasSuccessful = bWasSuccessful;
	Parms.debugInteractionName = std::move(debugInteractionName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.ServerReleaseCommitFromInteraction
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerReleaseCommitFromInteraction(class UEverholmInteractionComponent* InteractionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerReleaseCommitFromInteraction");

	Params::EverholmInteractorComponent_ServerReleaseCommitFromInteraction Parms{};

	Parms.InteractionComponent = InteractionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.ServerRequestConfirmation
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// const struct FServerConfirmationRequest&confirmationRequest                                    (Parm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerRequestConfirmation(const struct FServerConfirmationRequest& confirmationRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerRequestConfirmation");

	Params::EverholmInteractorComponent_ServerRequestConfirmation Parms{};

	Parms.confirmationRequest = std::move(confirmationRequest);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.ServerRetryStartInteraction
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class UEverholmInteractorComponent*     authorityComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasSuccessful                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerRetryStartInteraction(class UEverholmInteractorComponent* authorityComponent, const bool bWasSuccessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerRetryStartInteraction");

	Params::EverholmInteractorComponent_ServerRetryStartInteraction Parms{};

	Parms.authorityComponent = authorityComponent;
	Parms.bWasSuccessful = bWasSuccessful;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.ServerSetInteractableInputValue
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ESharedInteractableValueID        ID                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             Value                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerSetInteractableInputValue(class UEverholmInteractionComponent* InteractionComponent, const ESharedInteractableValueID ID, const int32 Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerSetInteractableInputValue");

	Params::EverholmInteractorComponent_ServerSetInteractableInputValue Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.ID = ID;
	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.ServerTriggerSharedInteractableEvent
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class UEverholmInteractionComponent*    InteractionComponent                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      EventName                                              (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInteractorComponent::ServerTriggerSharedInteractableEvent(class UEverholmInteractionComponent* InteractionComponent, const class FName& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ServerTriggerSharedInteractableEvent");

	Params::EverholmInteractorComponent_ServerTriggerSharedInteractableEvent Parms{};

	Parms.InteractionComponent = InteractionComponent;
	Parms.EventName = EventName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInteractorComponent.GetInteractionWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPlayerInteractionWidget*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPlayerInteractionWidget* UEverholmInteractorComponent::GetInteractionWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "GetInteractionWidget");

	Params::EverholmInteractorComponent_GetInteractionWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractorComponent.GetMaxSelectionDistance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmInteractorComponent::GetMaxSelectionDistance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "GetMaxSelectionDistance");

	Params::EverholmInteractorComponent_GetMaxSelectionDistance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInteractorComponent.ShouldShowInteractionUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInteractorComponent::ShouldShowInteractionUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInteractorComponent", "ShouldShowInteractionUI");

	Params::EverholmInteractorComponent_ShouldShowInteractionUI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetItemSection
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    itemObjectOrClass                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInventorySection UEverholmInventoryComponent::GetItemSection(const class UObject* itemObjectOrClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmInventoryComponent", "GetItemSection");

	Params::EverholmInventoryComponent_GetItemSection Parms{};

	Parms.itemObjectOrClass = itemObjectOrClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.TransferInventoryToPrimaryPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInventoryComponent::TransferInventoryToPrimaryPlayer(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmInventoryComponent", "TransferInventoryToPrimaryPlayer");

	Params::EverholmInventoryComponent_TransferInventoryToPrimaryPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInventoryComponent.AddToInventory
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FInventoryItem&            Item                                                   (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EInventoryAddResultType                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInventoryAddResultType UEverholmInventoryComponent::AddToInventory(const struct FInventoryItem& Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "AddToInventory");

	Params::EverholmInventoryComponent_AddToInventory Parms{};

	Parms.Item = std::move(Item);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.EquipMask
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AMaskPickup*                      maskItem                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInventoryComponent::EquipMask(class AMaskPickup* maskItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "EquipMask");

	Params::EverholmInventoryComponent_EquipMask Parms{};

	Parms.maskItem = maskItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetMaskFromRowHandle
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       CollectibleRowHandle                                   (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class AMaskPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AMaskPickup* UEverholmInventoryComponent::GetMaskFromRowHandle(const struct FDataTableRowHandle& CollectibleRowHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetMaskFromRowHandle");

	Params::EverholmInventoryComponent_GetMaskFromRowHandle Parms{};

	Parms.CollectibleRowHandle = std::move(CollectibleRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.OnProfileLoadedEquipMask
// (Final, Native, Private)
// Parameters:
// class UPlayerProfile*                   profile                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInventoryComponent::OnProfileLoadedEquipMask(class UPlayerProfile* profile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "OnProfileLoadedEquipMask");

	Params::EverholmInventoryComponent_OnProfileLoadedEquipMask Parms{};

	Parms.profile = profile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInventoryComponent.OnRep_EquippedMask
// (Final, Native, Protected)

void UEverholmInventoryComponent::OnRep_EquippedMask()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "OnRep_EquippedMask");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInventoryComponent.OnRep_Inventory
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const TArray<struct FInventoryEntry>&   oldInventory                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UEverholmInventoryComponent::OnRep_Inventory(const TArray<struct FInventoryEntry>& oldInventory)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "OnRep_Inventory");

	Params::EverholmInventoryComponent_OnRep_Inventory Parms{};

	Parms.oldInventory = std::move(oldInventory);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInventoryComponent.OnRep_MasksInventory
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const TArray<struct FInventoryEntry>&   oldInventory                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UEverholmInventoryComponent::OnRep_MasksInventory(const TArray<struct FInventoryEntry>& oldInventory)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "OnRep_MasksInventory");

	Params::EverholmInventoryComponent_OnRep_MasksInventory Parms{};

	Parms.oldInventory = std::move(oldInventory);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInventoryComponent.OnRep_StartingMaskName
// (Final, Native, Protected)

void UEverholmInventoryComponent::OnRep_StartingMaskName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "OnRep_StartingMaskName");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInventoryComponent.RemoveFromInventory
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FInventoryItem&            Item                                                   (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::RemoveFromInventory(const struct FInventoryItem& Item, EInventorySection Section)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "RemoveFromInventory");

	Params::EverholmInventoryComponent_RemoveFromInventory Parms{};

	Parms.Item = std::move(Item);
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.RemoveFromInventoryByName
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::RemoveFromInventoryByName(class FName Name_0, EInventorySection Section)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "RemoveFromInventoryByName");

	Params::EverholmInventoryComponent_RemoveFromInventoryByName Parms{};

	Parms.Name_0 = Name_0;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.RemoveFromInventoryByPickup
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class APickupBase*                      pickupToRemove                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::RemoveFromInventoryByPickup(class APickupBase* pickupToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "RemoveFromInventoryByPickup");

	Params::EverholmInventoryComponent_RemoveFromInventoryByPickup Parms{};

	Parms.pickupToRemove = pickupToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.ReserveMask
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AMaskPickup*                      maskItem                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmInventoryComponent::ReserveMask(class AMaskPickup* maskItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "ReserveMask");

	Params::EverholmInventoryComponent_ReserveMask Parms{};

	Parms.maskItem = maskItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmInventoryComponent.FindItemIndexByCollectibleName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::FindItemIndexByCollectibleName(class FName Name_0, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "FindItemIndexByCollectibleName");

	Params::EverholmInventoryComponent_FindItemIndexByCollectibleName Parms{};

	Parms.Name_0 = Name_0;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.FindItemIndexByInstance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Item                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::FindItemIndexByInstance(const class AActor* Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "FindItemIndexByInstance");

	Params::EverholmInventoryComponent_FindItemIndexByInstance Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.FindItemIndexByName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::FindItemIndexByName(class FName Name_0, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "FindItemIndexByName");

	Params::EverholmInventoryComponent_FindItemIndexByName Parms{};

	Parms.Name_0 = Name_0;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.FindItemIndexByTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::FindItemIndexByTag(const struct FGameplayTag& Tag, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "FindItemIndexByTag");

	Params::EverholmInventoryComponent_FindItemIndexByTag Parms{};

	Parms.Tag = std::move(Tag);
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.FindItemIndexesByTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<int32>                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<int32> UEverholmInventoryComponent::FindItemIndexesByTag(const struct FGameplayTag& Tag, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "FindItemIndexesByTag");

	Params::EverholmInventoryComponent_FindItemIndexesByTag Parms{};

	Parms.Tag = std::move(Tag);
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetDefaultStartingMask
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AMaskPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AMaskPickup* UEverholmInventoryComponent::GetDefaultStartingMask() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetDefaultStartingMask");

	Params::EverholmInventoryComponent_GetDefaultStartingMask Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetEquippedMask
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AMaskPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AMaskPickup* UEverholmInventoryComponent::GetEquippedMask() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetEquippedMask");

	Params::EverholmInventoryComponent_GetEquippedMask Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetInventory
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FInventoryEntry>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FInventoryEntry> UEverholmInventoryComponent::GetInventory(EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetInventory");

	Params::EverholmInventoryComponent_GetInventory Parms{};

	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetInventoryCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FInventoryItem&            Item                                                   (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::GetInventoryCount(const struct FInventoryItem& Item, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetInventoryCount");

	Params::EverholmInventoryComponent_GetInventoryCount Parms{};

	Parms.Item = std::move(Item);
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetInventoryCountByName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::GetInventoryCountByName(class FName Name_0, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetInventoryCountByName");

	Params::EverholmInventoryComponent_GetInventoryCountByName Parms{};

	Parms.Name_0 = Name_0;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetInventoryItemsCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmInventoryComponent::GetInventoryItemsCount(EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetInventoryItemsCount");

	Params::EverholmInventoryComponent_GetInventoryItemsCount Parms{};

	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetItemEntryByIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInventoryEntry                  ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FInventoryEntry UEverholmInventoryComponent::GetItemEntryByIndex(int32 Index_0, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetItemEntryByIndex");

	Params::EverholmInventoryComponent_GetItemEntryByIndex Parms{};

	Parms.Index_0 = Index_0;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.GetReservedMask
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AMaskPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AMaskPickup* UEverholmInventoryComponent::GetReservedMask() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "GetReservedMask");

	Params::EverholmInventoryComponent_GetReservedMask Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.HasItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FInventoryItem&            Item                                                   (Parm, NoDestructor, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInventoryComponent::HasItem(const struct FInventoryItem& Item, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "HasItem");

	Params::EverholmInventoryComponent_HasItem Parms{};

	Parms.Item = std::move(Item);
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.HasItemByClass
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class APickupBase>          pickupClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInventoryComponent::HasItemByClass(TSubclassOf<class APickupBase> pickupClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "HasItemByClass");

	Params::EverholmInventoryComponent_HasItemByClass Parms{};

	Parms.pickupClass = pickupClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.HasItemByName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInventorySection                       Section                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInventoryComponent::HasItemByName(class FName Name_0, EInventorySection Section) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "HasItemByName");

	Params::EverholmInventoryComponent_HasItemByName Parms{};

	Parms.Name_0 = Name_0;
	Parms.Section = Section;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmInventoryComponent.HasItemInstance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Item                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmInventoryComponent::HasItemInstance(const class AActor* Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmInventoryComponent", "HasItemInstance");

	Params::EverholmInventoryComponent_HasItemInstance Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmMainMenuGameMode.OnDeferredBeginPlay
// (Final, Native, Protected)

void AEverholmMainMenuGameMode::OnDeferredBeginPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmMainMenuGameMode", "OnDeferredBeginPlay");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmMainMenuGameMode.OnPrimaryUserInitialized
// (Final, Native, Protected)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Error                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmMainMenuGameMode::OnPrimaryUserInitialized(ELocalUserType localUserType, const class UCommonUserInfo* UserInfo, bool bSuccess, const class FString& Error)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmMainMenuGameMode", "OnPrimaryUserInitialized");

	Params::EverholmMainMenuGameMode_OnPrimaryUserInitialized Parms{};

	Parms.localUserType = localUserType;
	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmMainMenuGameMode.StartMainMenu
// (Event, Protected, BlueprintEvent)

void AEverholmMainMenuGameMode::StartMainMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmMainMenuGameMode", "StartMainMenu");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.PickupInteractionComponent.OnThrownPickupLanded
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                ImpactResult                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UPickupInteractionComponent::OnThrownPickupLanded(class AEverholmCharacter* Initiator, class APickupBase* pickup, const struct FHitResult& ImpactResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupInteractionComponent", "OnThrownPickupLanded");

	Params::PickupInteractionComponent_OnThrownPickupLanded Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;
	Parms.ImpactResult = std::move(ImpactResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupInteractionComponent.OnThrownPickupSettled
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPickupInteractionComponent::OnThrownPickupSettled(class AEverholmCharacter* Initiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupInteractionComponent", "OnThrownPickupSettled");

	Params::PickupInteractionComponent_OnThrownPickupSettled Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.CanUnpause
// (Final, Native, Private)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmPlayerController::CanUnpause()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "CanUnpause");

	Params::EverholmPlayerController_CanUnpause Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerController.GiveItem
// (Final, Exec, Native, Protected)
// Parameters:
// class FName                             pickupClassName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             characterName                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::GiveItem(class FName pickupClassName, class FName characterName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "GiveItem");

	Params::EverholmPlayerController_GiveItem Parms{};

	Parms.pickupClassName = pickupClassName;
	Parms.characterName = characterName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Kill
// (Final, Exec, Native, Protected)
// Parameters:
// class FName                             deathHandlerName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Kill(class FName deathHandlerName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Kill");

	Params::EverholmPlayerController_Kill Parms{};

	Parms.deathHandlerName = deathHandlerName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.RequestForceUnpause
// (Final, Native, Public, BlueprintCallable)

void AEverholmPlayerController::RequestForceUnpause()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "RequestForceUnpause");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.RequestPause
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::RequestPause(EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "RequestPause");

	Params::EverholmPlayerController_RequestPause Parms{};

	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_AckGameFlowState
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// uint8                                   ackState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Server_AckGameFlowState(uint8 ackState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_AckGameFlowState");

	Params::EverholmPlayerController_Server_AckGameFlowState Parms{};

	Parms.ackState = ackState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_DebugRespawnAtCheckpoint
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class AEverholmPlayerStart*             PlayerStart                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Server_DebugRespawnAtCheckpoint(class AEverholmPlayerStart* PlayerStart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_DebugRespawnAtCheckpoint");

	Params::EverholmPlayerController_Server_DebugRespawnAtCheckpoint Parms{};

	Parms.PlayerStart = PlayerStart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_ForceUnpauseGame
// (Net, NetReliable, Native, Event, Protected, NetServer)

void AEverholmPlayerController::Server_ForceUnpauseGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_ForceUnpauseGame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_HandlePlayersInitializedOnClient
// (Net, NetReliable, Native, Event, Public, NetServer)

void AEverholmPlayerController::Server_HandlePlayersInitializedOnClient()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_HandlePlayersInitializedOnClient");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_NotifyReadyToWakeFromSpawn
// (Net, NetReliable, Native, Event, Protected, NetServer)

void AEverholmPlayerController::Server_NotifyReadyToWakeFromSpawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_NotifyReadyToWakeFromSpawn");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_PauseGame
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Server_PauseGame(EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_PauseGame");

	Params::EverholmPlayerController_Server_PauseGame Parms{};

	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_QuitSession
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)

void AEverholmPlayerController::Server_QuitSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_QuitSession");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_QuitSessionSmoothly
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)

void AEverholmPlayerController::Server_QuitSessionSmoothly()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_QuitSessionSmoothly");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_RestartGame
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)

void AEverholmPlayerController::Server_RestartGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_RestartGame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_SetPlayerUniqueNetId
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FUniqueNetIdRepl&          UniqueNetId                                            (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Server_SetPlayerUniqueNetId(const struct FUniqueNetIdRepl& UniqueNetId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_SetPlayerUniqueNetId");

	Params::EverholmPlayerController_Server_SetPlayerUniqueNetId Parms{};

	Parms.UniqueNetId = std::move(UniqueNetId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_TeleportPawn
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Server_TeleportPawn(const struct FVector& targetLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_TeleportPawn");

	Params::EverholmPlayerController_Server_TeleportPawn Parms{};

	Parms.targetLocation = std::move(targetLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_UnPauseGame
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Server_UnPauseGame(EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_UnPauseGame");

	Params::EverholmPlayerController_Server_UnPauseGame Parms{};

	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.ServerGiveItem
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// class FName                             pickupClassName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             characterName                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::ServerGiveItem(class FName pickupClassName, class FName characterName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "ServerGiveItem");

	Params::EverholmPlayerController_ServerGiveItem Parms{};

	Parms.pickupClassName = pickupClassName;
	Parms.characterName = characterName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.ServerKill
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// class FName                             deathHandlerName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::ServerKill(class FName deathHandlerName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "ServerKill");

	Params::EverholmPlayerController_ServerKill Parms{};

	Parms.deathHandlerName = deathHandlerName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.ServerTakeItem
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// class FName                             pickupClassName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             characterName                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::ServerTakeItem(class FName pickupClassName, class FName characterName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "ServerTakeItem");

	Params::EverholmPlayerController_ServerTakeItem Parms{};

	Parms.pickupClassName = pickupClassName;
	Parms.characterName = characterName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.ShowSaveIcon
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bShow                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::ShowSaveIcon(bool bShow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "ShowSaveIcon");

	Params::EverholmPlayerController_ShowSaveIcon Parms{};

	Parms.bShow = bShow;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmPlayerController.TakeItem
// (Final, Exec, Native, Protected)
// Parameters:
// class FName                             pickupClassName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             characterName                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::TakeItem(class FName pickupClassName, class FName characterName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "TakeItem");

	Params::EverholmPlayerController_TakeItem Parms{};

	Parms.pickupClassName = pickupClassName;
	Parms.characterName = characterName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.TryToggleGamePause
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::TryToggleGamePause(EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "TryToggleGamePause");

	Params::EverholmPlayerController_TryToggleGamePause Parms{};

	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.UnRequestPause
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::UnRequestPause(EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "UnRequestPause");

	Params::EverholmPlayerController_UnRequestPause Parms{};

	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.GetLookAroundComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ULookAroundComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ULookAroundComponent* AEverholmPlayerController::GetLookAroundComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "GetLookAroundComponent");

	Params::EverholmPlayerController_GetLookAroundComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerController.IncrementAchievementOnClient
// (Net, NetReliable, Native, Event, Public, NetClient, Const)
// Parameters:
// const class APlayerState*               EverholmPlayerState                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::IncrementAchievementOnClient(const class APlayerState* EverholmPlayerState, const struct FAchievementKey& Key, int32 Amount) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "IncrementAchievementOnClient");

	Params::EverholmPlayerController_IncrementAchievementOnClient Parms{};

	Parms.EverholmPlayerState = EverholmPlayerState;
	Parms.Key = std::move(Key);
	Parms.Amount = Amount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.IncrementAchievementReferenceOnClient
// (Net, NetReliable, Native, Event, Public, NetClient, Const)
// Parameters:
// const class APlayerState*               EverholmPlayerState                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const class FName&                      Reference                                              (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::IncrementAchievementReferenceOnClient(const class APlayerState* EverholmPlayerState, const struct FAchievementKey& Key, const class FName& Reference) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "IncrementAchievementReferenceOnClient");

	Params::EverholmPlayerController_IncrementAchievementReferenceOnClient Parms{};

	Parms.EverholmPlayerState = EverholmPlayerState;
	Parms.Key = std::move(Key);
	Parms.Reference = Reference;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.Server_SetPlayerUniqueNetIdEOSPlus
// (Net, NetReliable, Native, Event, Public, NetServer, Const)
// Parameters:
// const class FString&                    eosPlusNetIdString                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerController::Server_SetPlayerUniqueNetIdEOSPlus(const class FString& eosPlusNetIdString) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "Server_SetPlayerUniqueNetIdEOSPlus");

	Params::EverholmPlayerController_Server_SetPlayerUniqueNetIdEOSPlus Parms{};

	Parms.eosPlusNetIdString = std::move(eosPlusNetIdString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerController.UnlockAchievementOnClient
// (Net, NetReliable, Native, Event, Public, NetClient, Const)
// Parameters:
// const class APlayerState*               EverholmPlayerState                                    (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FAchievementKey&           Key                                                    (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void AEverholmPlayerController::UnlockAchievementOnClient(const class APlayerState* EverholmPlayerState, const struct FAchievementKey& Key) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerController", "UnlockAchievementOnClient");

	Params::EverholmPlayerController_UnlockAchievementOnClient Parms{};

	Parms.EverholmPlayerState = EverholmPlayerState;
	Parms.Key = std::move(Key);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RecordActorTransformSubsystem.StartRecordingActorTransform
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           ActorToRecord                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URecordActorTransformSubsystem::StartRecordingActorTransform(class AActor* ActorToRecord)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecordActorTransformSubsystem", "StartRecordingActorTransform");

	Params::RecordActorTransformSubsystem_StartRecordingActorTransform Parms{};

	Parms.ActorToRecord = ActorToRecord;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RecordActorTransformSubsystem.StopRecordingActorTransform
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           ActorToStopRecording                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRecordingResult                 ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FRecordingResult URecordActorTransformSubsystem::StopRecordingActorTransform(class AActor* ActorToStopRecording)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RecordActorTransformSubsystem", "StopRecordingActorTransform");

	Params::RecordActorTransformSubsystem_StopRecordingActorTransform Parms{};

	Parms.ActorToStopRecording = ActorToStopRecording;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.StickySurface.HOP_StuckObjects
// (Final, Native, Protected)
// Parameters:
// int32                                   numObjects                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStickySurface::HOP_StuckObjects(int32 numObjects)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurface", "HOP_StuckObjects");

	Params::StickySurface_HOP_StuckObjects Parms{};

	Parms.numObjects = numObjects;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.StickySurface.MakeStuckPickupsSavable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bLoadData                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStickySurface::MakeStuckPickupsSavable(bool bLoadData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurface", "MakeStuckPickupsSavable");

	Params::StickySurface_MakeStuckPickupsSavable Parms{};

	Parms.bLoadData = bLoadData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.StickySurface.OnObjectStuck
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APickupBase*                      stuckPickup                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStickySurface::OnObjectStuck(class APickupBase* stuckPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurface", "OnObjectStuck");

	Params::StickySurface_OnObjectStuck Parms{};

	Parms.stuckPickup = stuckPickup;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.StickySurface.OnStuckObjectsChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   numObjects                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStickySurface::OnStuckObjectsChanged(int32 numObjects)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurface", "OnStuckObjectsChanged");

	Params::StickySurface_OnStuckObjectsChanged Parms{};

	Parms.numObjects = numObjects;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.StickySurface.OnSurfaceHit
// (Final, Native, Private, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, 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 AStickySurface::OnSurfaceHit(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurface", "OnSurfaceHit");

	Params::StickySurface_OnSurfaceHit Parms{};

	Parms.HitComponent = HitComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.StickySurface.GetStuckPickups
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class APickupBase*>              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class APickupBase*> AStickySurface::GetStuckPickups() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurface", "GetStuckPickups");

	Params::StickySurface_GetStuckPickups Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmMultipleAISpawner.OnSpawnTriggerImmediateSprint
// (Final, Native, Private)
// Parameters:
// class AAISpawner*                       Spawner                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            NewPawn                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmMultipleAISpawner::OnSpawnTriggerImmediateSprint(class AAISpawner* Spawner, class APawn* NewPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmMultipleAISpawner", "OnSpawnTriggerImmediateSprint");

	Params::EverholmMultipleAISpawner_OnSpawnTriggerImmediateSprint Parms{};

	Parms.Spawner = Spawner;
	Parms.NewPawn = NewPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmMultipleAISpawner.TriggerImmediateSprint
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class APawn*                      Pawn                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmMultipleAISpawner::TriggerImmediateSprint(const class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmMultipleAISpawner", "TriggerImmediateSprint");

	Params::EverholmMultipleAISpawner_TriggerImmediateSprint Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmMultipleAISpawner.RemoveTagsAppliedBySpawner
// (Final, Native, Protected, BlueprintCallable, Const)

void AEverholmMultipleAISpawner::RemoveTagsAppliedBySpawner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmMultipleAISpawner", "RemoveTagsAppliedBySpawner");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmNavigationSystem.GetEverholmNavigationSystem
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UEverholmNavigationSystem*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmNavigationSystem* UEverholmNavigationSystem::GetEverholmNavigationSystem(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmNavigationSystem", "GetEverholmNavigationSystem");

	Params::EverholmNavigationSystem_GetEverholmNavigationSystem Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmNavigationSystem.RebuildNavigation
// (Final, Native, Public, BlueprintCallable)

void UEverholmNavigationSystem::RebuildNavigation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNavigationSystem", "RebuildNavigation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmNetworkSessionManager.CleanUpSession
// (Final, Native, Public, BlueprintCallable)

void UEverholmNetworkSessionManager::CleanUpSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkSessionManager", "CleanUpSession");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmNetworkSessionManager.FindSessionWithLobbyCode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                SearchingPlayer                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    LobbyCode                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmNetworkSessionManager::FindSessionWithLobbyCode(class APlayerController* SearchingPlayer, const class FString& LobbyCode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkSessionManager", "FindSessionWithLobbyCode");

	Params::EverholmNetworkSessionManager_FindSessionWithLobbyCode Parms{};

	Parms.SearchingPlayer = SearchingPlayer;
	Parms.LobbyCode = std::move(LobbyCode);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmNetworkSessionManager.ShowExternalInviteUI
// (Final, Native, Public, BlueprintCallable)

void UEverholmNetworkSessionManager::ShowExternalInviteUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkSessionManager", "ShowExternalInviteUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmNetworkSessionManager.GetSessionLobbyCode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UEverholmNetworkSessionManager::GetSessionLobbyCode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkSessionManager", "GetSessionLobbyCode");

	Params::EverholmNetworkSessionManager_GetSessionLobbyCode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmNetworkSessionManager.IsCrossplayAvailable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmNetworkSessionManager::IsCrossplayAvailable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkSessionManager", "IsCrossplayAvailable");

	Params::EverholmNetworkSessionManager_IsCrossplayAvailable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmNetworkSessionManager.IsCrossplayEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmNetworkSessionManager::IsCrossplayEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkSessionManager", "IsCrossplayEnabled");

	Params::EverholmNetworkSessionManager_IsCrossplayEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmNetworkSessionManager.TriggerPlatformError
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmNetworkSessionManager::TriggerPlatformError() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkSessionManager", "TriggerPlatformError");

	Params::EverholmNetworkSessionManager_TriggerPlatformError Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MotionMatchingTestUtility.StartPlayback
// (Final, Native, Public, BlueprintCallable)

void AMotionMatchingTestUtility::StartPlayback()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchingTestUtility", "StartPlayback");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MotionMatchingTestUtility.StartRecording
// (Final, Native, Public, BlueprintCallable)

void AMotionMatchingTestUtility::StartRecording()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchingTestUtility", "StartRecording");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MotionMatchingTestUtility.StopPlayback
// (Final, Native, Public, BlueprintCallable)

void AMotionMatchingTestUtility::StopPlayback()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchingTestUtility", "StopPlayback");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MotionMatchingTestUtility.StopRecording
// (Final, Native, Public, BlueprintCallable)

void AMotionMatchingTestUtility::StopRecording()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MotionMatchingTestUtility", "StopRecording");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ForceEquipPickupToPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         targetPlayer                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      targetPickup                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::ForceEquipPickupToPlayer(class AEverholmPlayerCharacter* targetPlayer, class APickupBase* targetPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmPickupComponent", "ForceEquipPickupToPlayer");

	Params::EverholmPickupComponent_ForceEquipPickupToPlayer Parms{};

	Parms.targetPlayer = targetPlayer;
	Parms.targetPickup = targetPickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.UpdateEquippedMasks
// (Final, Native, Static, Private, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::UpdateEquippedMasks(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmPickupComponent", "UpdateEquippedMasks");

	Params::EverholmPickupComponent_UpdateEquippedMasks Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ClearQueuedEquip
// (Final, Native, Private, BlueprintCallable)

void UEverholmPickupComponent::ClearQueuedEquip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ClearQueuedEquip");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ForceDropEquippedMask
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bSnapToGround                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDisableAfterDrop                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPickupComponent::ForceDropEquippedMask(bool bSnapToGround, bool bDisableAfterDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ForceDropEquippedMask");

	Params::EverholmPickupComponent_ForceDropEquippedMask Parms{};

	Parms.bSnapToGround = bSnapToGround;
	Parms.bDisableAfterDrop = bDisableAfterDrop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.ForceDropHeldPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bOverrideUndroppable                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDisableAfterDrop                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPickupComponent::ForceDropHeldPickup(bool bOverrideUndroppable, bool bDisableAfterDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ForceDropHeldPickup");

	Params::EverholmPickupComponent_ForceDropHeldPickup Parms{};

	Parms.bOverrideUndroppable = bOverrideUndroppable;
	Parms.bDisableAfterDrop = bDisableAfterDrop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.ForceGrabPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPickupComponent::ForceGrabPickup(class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ForceGrabPickup");

	Params::EverholmPickupComponent_ForceGrabPickup Parms{};

	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.ForceInterruptAllStates
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UEverholmPickupComponent::ForceInterruptAllStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ForceInterruptAllStates");

	Params::EverholmPickupComponent_ForceInterruptAllStates Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.ForceStashHeldPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPickupComponent::ForceStashHeldPickup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ForceStashHeldPickup");

	Params::EverholmPickupComponent_ForceStashHeldPickup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.HandleClimbingTagChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ChangedTag                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::HandleClimbingTagChanged(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& ChangedTag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "HandleClimbingTagChanged");

	Params::EverholmPickupComponent_HandleClimbingTagChanged Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.ChangedTag = std::move(ChangedTag);
	Parms.bWasAdded = bWasAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.HandleExitingVehicleFinished
// (Final, Native, Public, BlueprintCallable)

void UEverholmPickupComponent::HandleExitingVehicleFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "HandleExitingVehicleFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.HandleExitingVehicleStarted
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bVehicleHandlesStash                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::HandleExitingVehicleStarted(bool bVehicleHandlesStash)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "HandleExitingVehicleStarted");

	Params::EverholmPickupComponent_HandleExitingVehicleStarted Parms{};

	Parms.bVehicleHandlesStash = bVehicleHandlesStash;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.HandleHarpoonRetrievedDuringVehicleExit
// (Final, Native, Public)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::HandleHarpoonRetrievedDuringVehicleExit(class AEverholmCharacter* Initiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "HandleHarpoonRetrievedDuringVehicleExit");

	Params::EverholmPickupComponent_HandleHarpoonRetrievedDuringVehicleExit Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.HandlePickupStateTagChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ChangedTag                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::HandlePickupStateTagChanged(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& ChangedTag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "HandlePickupStateTagChanged");

	Params::EverholmPickupComponent_HandlePickupStateTagChanged Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.ChangedTag = std::move(ChangedTag);
	Parms.bWasAdded = bWasAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.HandleTagChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ChangedTag                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::HandleTagChanged(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& ChangedTag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "HandleTagChanged");

	Params::EverholmPickupComponent_HandleTagChanged Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.ChangedTag = std::move(ChangedTag);
	Parms.bWasAdded = bWasAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_AbortUsingItem
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UEverholmPickupComponent::Multicast_AbortUsingItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_AbortUsingItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_ApplyLocoProfile
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class ULocomotionProfileAsset*          locoProfile                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_ApplyLocoProfile(class ULocomotionProfileAsset* locoProfile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_ApplyLocoProfile");

	Params::EverholmPickupComponent_Multicast_ApplyLocoProfile Parms{};

	Parms.locoProfile = locoProfile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_ConsumePickup
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_ConsumePickup(class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_ConsumePickup");

	Params::EverholmPickupComponent_Multicast_ConsumePickup Parms{};

	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_CreatePickupNotificationWidget
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class AEverholmCharacter*               holder                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_CreatePickupNotificationWidget(class AEverholmCharacter* holder, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_CreatePickupNotificationWidget");

	Params::EverholmPickupComponent_Multicast_CreatePickupNotificationWidget Parms{};

	Parms.holder = holder;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_ForceDropEquippedMask
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// bool                                    bSnapToGround                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDisableAfterDrop                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_ForceDropEquippedMask(bool bSnapToGround, bool bDisableAfterDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_ForceDropEquippedMask");

	Params::EverholmPickupComponent_Multicast_ForceDropEquippedMask Parms{};

	Parms.bSnapToGround = bSnapToGround;
	Parms.bDisableAfterDrop = bDisableAfterDrop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_ForceDropHeldPickup
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// bool                                    bDisableAfterDrop                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_ForceDropHeldPickup(bool bDisableAfterDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_ForceDropHeldPickup");

	Params::EverholmPickupComponent_Multicast_ForceDropHeldPickup Parms{};

	Parms.bDisableAfterDrop = bDisableAfterDrop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_ForceGrabPickup
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_ForceGrabPickup(class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_ForceGrabPickup");

	Params::EverholmPickupComponent_Multicast_ForceGrabPickup Parms{};

	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_ForceInterruptAllStates
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UEverholmPickupComponent::Multicast_ForceInterruptAllStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_ForceInterruptAllStates");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_ForceStashHeldPickup
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UEverholmPickupComponent::Multicast_ForceStashHeldPickup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_ForceStashHeldPickup");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_RemoveLocoProfile
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UEverholmPickupComponent::Multicast_RemoveLocoProfile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_RemoveLocoProfile");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_RequestPickupState
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// EPickupState                            NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_RequestPickupState(EPickupState NewState, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_RequestPickupState");

	Params::EverholmPickupComponent_Multicast_RequestPickupState Parms{};

	Parms.NewState = NewState;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_SetThrowParams
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FThrowParams&              throwParameters                                        (ConstParm, Parm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_SetThrowParams(const struct FThrowParams& throwParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_SetThrowParams");

	Params::EverholmPickupComponent_Multicast_SetThrowParams Parms{};

	Parms.throwParameters = std::move(throwParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_StartUsingItem
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const class AEverholmCharacter*         User                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_StartUsingItem(const class AEverholmCharacter* User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_StartUsingItem");

	Params::EverholmPickupComponent_Multicast_StartUsingItem Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_StopUsingItem
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const class AEverholmCharacter*         User                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_StopUsingItem(const class AEverholmCharacter* User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_StopUsingItem");

	Params::EverholmPickupComponent_Multicast_StopUsingItem Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_TryQuickEquipMask
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class AMaskPickup*                      MaskPickup                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_TryQuickEquipMask(class AMaskPickup* MaskPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_TryQuickEquipMask");

	Params::EverholmPickupComponent_Multicast_TryQuickEquipMask Parms{};

	Parms.MaskPickup = MaskPickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Multicast_TryQuickEquipOtherPlayersMask
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class AMaskPickup*                      MaskPickup                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Multicast_TryQuickEquipOtherPlayersMask(class AMaskPickup* MaskPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Multicast_TryQuickEquipOtherPlayersMask");

	Params::EverholmPickupComponent_Multicast_TryQuickEquipOtherPlayersMask Parms{};

	Parms.MaskPickup = MaskPickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.OnLedgeClimbingChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bIsClimbing                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ledgeHeightAfterAlignment                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::OnLedgeClimbingChanged(bool bIsClimbing, float ledgeHeightAfterAlignment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "OnLedgeClimbingChanged");

	Params::EverholmPickupComponent_OnLedgeClimbingChanged Parms{};

	Parms.bIsClimbing = bIsClimbing;
	Parms.ledgeHeightAfterAlignment = ledgeHeightAfterAlignment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.OnSurfaceClimbingChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bIsClimbing                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::OnSurfaceClimbingChanged(bool bIsClimbing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "OnSurfaceClimbingChanged");

	Params::EverholmPickupComponent_OnSurfaceClimbingChanged Parms{};

	Parms.bIsClimbing = bIsClimbing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.QueueEquip
// (Final, Native, Private, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayTag                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::QueueEquip(const struct FGameplayTag& GameplayTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "QueueEquip");

	Params::EverholmPickupComponent_QueueEquip Parms{};

	Parms.GameplayTag = std::move(GameplayTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ReservePickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsReserved                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::ReservePickup(class APickupBase* pickup, bool bIsReserved)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ReservePickup");

	Params::EverholmPickupComponent_ReservePickup Parms{};

	Parms.pickup = pickup;
	Parms.bIsReserved = bIsReserved;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_AbortUsingItem
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UEverholmPickupComponent::Server_AbortUsingItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_AbortUsingItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_ApplyLocoProfile
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class ULocomotionProfileAsset*          locoProfile                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_ApplyLocoProfile(class ULocomotionProfileAsset* locoProfile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_ApplyLocoProfile");

	Params::EverholmPickupComponent_Server_ApplyLocoProfile Parms{};

	Parms.locoProfile = locoProfile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_ConsumePickup
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_ConsumePickup(class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_ConsumePickup");

	Params::EverholmPickupComponent_Server_ConsumePickup Parms{};

	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_CreatePickupNotificationWidget
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class AEverholmCharacter*               holder                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_CreatePickupNotificationWidget(class AEverholmCharacter* holder, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_CreatePickupNotificationWidget");

	Params::EverholmPickupComponent_Server_CreatePickupNotificationWidget Parms{};

	Parms.holder = holder;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_ForceDropEquippedMask
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// bool                                    bSnapToGround                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDisableAfterDrop                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_ForceDropEquippedMask(bool bSnapToGround, bool bDisableAfterDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_ForceDropEquippedMask");

	Params::EverholmPickupComponent_Server_ForceDropEquippedMask Parms{};

	Parms.bSnapToGround = bSnapToGround;
	Parms.bDisableAfterDrop = bDisableAfterDrop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_ForceDropHeldPickup
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// bool                                    bDisableAfterDrop                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_ForceDropHeldPickup(bool bDisableAfterDrop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_ForceDropHeldPickup");

	Params::EverholmPickupComponent_Server_ForceDropHeldPickup Parms{};

	Parms.bDisableAfterDrop = bDisableAfterDrop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_ForceGrabPickup
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_ForceGrabPickup(class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_ForceGrabPickup");

	Params::EverholmPickupComponent_Server_ForceGrabPickup Parms{};

	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_ForceInterruptAllStates
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UEverholmPickupComponent::Server_ForceInterruptAllStates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_ForceInterruptAllStates");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_ForceStashHeldPickup
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UEverholmPickupComponent::Server_ForceStashHeldPickup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_ForceStashHeldPickup");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_RemoveLocoProfile
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UEverholmPickupComponent::Server_RemoveLocoProfile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_RemoveLocoProfile");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_RequestPickupState
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// EPickupState                            NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_RequestPickupState(EPickupState NewState, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_RequestPickupState");

	Params::EverholmPickupComponent_Server_RequestPickupState Parms{};

	Parms.NewState = NewState;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_SetThrowParams
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// const struct FThrowParams&              throwParameters                                        (ConstParm, Parm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_SetThrowParams(const struct FThrowParams& throwParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_SetThrowParams");

	Params::EverholmPickupComponent_Server_SetThrowParams Parms{};

	Parms.throwParameters = std::move(throwParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_StartUsingItem
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// const class AEverholmCharacter*         User                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_StartUsingItem(const class AEverholmCharacter* User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_StartUsingItem");

	Params::EverholmPickupComponent_Server_StartUsingItem Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_StopUsingItem
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// const class AEverholmCharacter*         User                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_StopUsingItem(const class AEverholmCharacter* User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_StopUsingItem");

	Params::EverholmPickupComponent_Server_StopUsingItem Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_TryQuickEquipMask
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class AMaskPickup*                      MaskPickup                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_TryQuickEquipMask(class AMaskPickup* MaskPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_TryQuickEquipMask");

	Params::EverholmPickupComponent_Server_TryQuickEquipMask Parms{};

	Parms.MaskPickup = MaskPickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.Server_TryQuickEquipOtherPlayersMask
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class AMaskPickup*                      MaskPickup                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::Server_TryQuickEquipOtherPlayersMask(class AMaskPickup* MaskPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "Server_TryQuickEquipOtherPlayersMask");

	Params::EverholmPickupComponent_Server_TryQuickEquipOtherPlayersMask Parms{};

	Parms.MaskPickup = MaskPickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ServerReservePickup
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsReserved                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::ServerReservePickup(class APickupBase* pickup, bool bIsReserved)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ServerReservePickup");

	Params::EverholmPickupComponent_ServerReservePickup Parms{};

	Parms.pickup = pickup;
	Parms.bIsReserved = bIsReserved;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ServerSetPickupClientDirected
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsClientDirected                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::ServerSetPickupClientDirected(class APickupBase* pickup, bool bIsClientDirected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ServerSetPickupClientDirected");

	Params::EverholmPickupComponent_ServerSetPickupClientDirected Parms{};

	Parms.pickup = pickup;
	Parms.bIsClientDirected = bIsClientDirected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ServerSetRBState
// (Net, Native, Event, Public, NetServer)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRigidBodyState&           State                                                  (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::ServerSetRBState(class APickupBase* pickup, const struct FRigidBodyState& State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ServerSetRBState");

	Params::EverholmPickupComponent_ServerSetRBState Parms{};

	Parms.pickup = pickup;
	Parms.State = std::move(State);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.ServerSpawnClientDirectedHarpoon
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults)
// Parameters:
// class AHarpoonPickup*                   HarpoonPickup                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           hitActor                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                spawnTransform                                         (ConstParm, Parm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::ServerSpawnClientDirectedHarpoon(class AHarpoonPickup* HarpoonPickup, class AActor* hitActor, const struct FTransform& spawnTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "ServerSpawnClientDirectedHarpoon");

	Params::EverholmPickupComponent_ServerSpawnClientDirectedHarpoon Parms{};

	Parms.HarpoonPickup = HarpoonPickup;
	Parms.hitActor = hitActor;
	Parms.spawnTransform = std::move(spawnTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.SetInventoryEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::SetInventoryEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "SetInventoryEnabled");

	Params::EverholmPickupComponent_SetInventoryEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.TryExecuteQueuedEquip
// (Final, Native, Private, BlueprintCallable)

void UEverholmPickupComponent::TryExecuteQueuedEquip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "TryExecuteQueuedEquip");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPickupComponent.UpdateThrowMotionWarpTarget
// (Event, Public, BlueprintEvent)
// Parameters:
// const class UTargetComponent*           Target                                                 (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPickupComponent::UpdateThrowMotionWarpTarget(const class UTargetComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "UpdateThrowMotionWarpTarget");

	Params::EverholmPickupComponent_UpdateThrowMotionWarpTarget Parms{};

	Parms.Target = Target;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmPickupComponent.GetActivePickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UEverholmPickupComponent::GetActivePickup() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "GetActivePickup");

	Params::EverholmPickupComponent_GetActivePickup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.GetCurrentPickupState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPickupState                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPickupState UEverholmPickupComponent::GetCurrentPickupState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "GetCurrentPickupState");

	Params::EverholmPickupComponent_GetCurrentPickupState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.GetCurrentPickupType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPickupType                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPickupType UEverholmPickupComponent::GetCurrentPickupType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "GetCurrentPickupType");

	Params::EverholmPickupComponent_GetCurrentPickupType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.GetEquippedMask
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AMaskPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AMaskPickup* UEverholmPickupComponent::GetEquippedMask() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "GetEquippedMask");

	Params::EverholmPickupComponent_GetEquippedMask Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.GetHeldPickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bEvenIfCurrentlyStashing                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UEverholmPickupComponent::GetHeldPickup(bool bEvenIfCurrentlyStashing) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "GetHeldPickup");

	Params::EverholmPickupComponent_GetHeldPickup Parms{};

	Parms.bEvenIfCurrentlyStashing = bEvenIfCurrentlyStashing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.GetLastStashedPickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* UEverholmPickupComponent::GetLastStashedPickup() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "GetLastStashedPickup");

	Params::EverholmPickupComponent_GetLastStashedPickup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.GetReservedMask
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AMaskPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AMaskPickup* UEverholmPickupComponent::GetReservedMask() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "GetReservedMask");

	Params::EverholmPickupComponent_GetReservedMask Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.HeldPickupHasTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              Tag                                                    (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPickupComponent::HeldPickupHasTag(const struct FGameplayTag& Tag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "HeldPickupHasTag");

	Params::EverholmPickupComponent_HeldPickupHasTag Parms{};

	Parms.Tag = std::move(Tag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPickupComponent.IsOtherPlayerWearingMask
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AMaskPickup*                Mask                                                   (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPickupComponent::IsOtherPlayerWearingMask(const class AMaskPickup* Mask) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPickupComponent", "IsOtherPlayerWearingMask");

	Params::EverholmPickupComponent_IsOtherPlayerWearingMask Parms{};

	Parms.Mask = Mask;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ChooserTableTransitionAsset.GetBlendTimeForTransition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UChooserTable*                    From                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UChooserTable*                    To                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UChooserTableTransitionAsset::GetBlendTimeForTransition(class UChooserTable* From, class UChooserTable* To) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ChooserTableTransitionAsset", "GetBlendTimeForTransition");

	Params::ChooserTableTransitionAsset_GetBlendTimeForTransition Parms{};

	Parms.From = From;
	Parms.To = To;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerAnimInstance.BindPlayerPawnCallbacks
// (Final, Native, Public, BlueprintCallable)

void UEverholmPlayerAnimInstance::BindPlayerPawnCallbacks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "BindPlayerPawnCallbacks");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerAnimInstance.BindPlayerPawnInBoatCallbacks
// (Final, Native, Public, BlueprintCallable)

void UEverholmPlayerAnimInstance::BindPlayerPawnInBoatCallbacks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "BindPlayerPawnInBoatCallbacks");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerAnimInstance.OnAIAttachmentChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bIsHumbugAttached                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPlayerAnimInstance::OnAIAttachmentChanged(bool bIsHumbugAttached)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "OnAIAttachmentChanged");

	Params::EverholmPlayerAnimInstance_OnAIAttachmentChanged Parms{};

	Parms.bIsHumbugAttached = bIsHumbugAttached;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmPlayerAnimInstance.OnDeathWarning
// (Event, Public, BlueprintEvent)

void UEverholmPlayerAnimInstance::OnDeathWarning()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "OnDeathWarning");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmPlayerAnimInstance.OnHarpoonThrown
// (Event, Public, BlueprintEvent)

void UEverholmPlayerAnimInstance::OnHarpoonThrown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "OnHarpoonThrown");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmPlayerAnimInstance.GetChooserTableTransitionTime
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UChooserTable*                    From                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UChooserTable*                    To                                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmPlayerAnimInstance::GetChooserTableTransitionTime(class UChooserTable* From, class UChooserTable* To) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "GetChooserTableTransitionTime");

	Params::EverholmPlayerAnimInstance_GetChooserTableTransitionTime Parms{};

	Parms.From = From;
	Parms.To = To;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerAnimInstance.GetIKAlpha
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bIsWorldSpace                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmPlayerAnimInstance::GetIKAlpha(bool bIsWorldSpace) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "GetIKAlpha");

	Params::EverholmPlayerAnimInstance_GetIKAlpha Parms{};

	Parms.bIsWorldSpace = bIsWorldSpace;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerAnimInstance.GetIKDataFromSlot
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerIKSlot                           Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsWorldSpace                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  outAlpha                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      OutTransform                                           (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPlayerAnimInstance::GetIKDataFromSlot(EPlayerIKSlot Slot, bool bIsWorldSpace, float* outAlpha, struct FTransform* OutTransform) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "GetIKDataFromSlot");

	Params::EverholmPlayerAnimInstance_GetIKDataFromSlot Parms{};

	Parms.Slot = Slot;
	Parms.bIsWorldSpace = bIsWorldSpace;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outAlpha != nullptr)
		*outAlpha = Parms.outAlpha;

	if (OutTransform != nullptr)
		*OutTransform = std::move(Parms.OutTransform);
}


// Function Everholm.EverholmPlayerAnimInstance.GetOwningPlayerCharacter
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UEverholmPlayerAnimInstance::GetOwningPlayerCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerAnimInstance", "GetOwningPlayerCharacter");

	Params::EverholmPlayerAnimInstance_GetOwningPlayerCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerCharacter.GetCrouchComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UCrouchComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UCrouchComponent* AEverholmPlayerCharacter::GetCrouchComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetCrouchComponent");

	Params::EverholmPlayerCharacter_GetCrouchComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerCharacter.GetShot
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::GetShot(const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetShot");

	Params::EverholmPlayerCharacter_GetShot Parms{};

	Parms.HitResult = std::move(HitResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.HandlePlayerDrowned
// (Event, Public, BlueprintEvent)

void AEverholmPlayerCharacter::HandlePlayerDrowned()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "HandlePlayerDrowned");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EverholmPlayerCharacter.HandlePlayerWakeUp
// (Native, Public, BlueprintCallable)

void AEverholmPlayerCharacter::HandlePlayerWakeUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "HandlePlayerWakeUp");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.MoveTo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AcceptanceRadius                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DesiredMoveSpeed                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::MoveTo(const struct FVector& Location, const struct FVector& Direction, float AcceptanceRadius, float DesiredMoveSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "MoveTo");

	Params::EverholmPlayerCharacter_MoveTo Parms{};

	Parms.Location = std::move(Location);
	Parms.Direction = std::move(Direction);
	Parms.AcceptanceRadius = AcceptanceRadius;
	Parms.DesiredMoveSpeed = DesiredMoveSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.MultiCast_GetShot
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::MultiCast_GetShot(const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "MultiCast_GetShot");

	Params::EverholmPlayerCharacter_MultiCast_GetShot Parms{};

	Parms.HitResult = std::move(HitResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.Multicast_TeleportAllPlayers
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::Multicast_TeleportAllPlayers(const struct FVector& targetLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "Multicast_TeleportAllPlayers");

	Params::EverholmPlayerCharacter_Multicast_TeleportAllPlayers Parms{};

	Parms.targetLocation = std::move(targetLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.OnMoveFinished
// (Native, Public)
// Parameters:
// EPathFollowingResult                    Result                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::OnMoveFinished(EPathFollowingResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "OnMoveFinished");

	Params::EverholmPlayerCharacter_OnMoveFinished Parms{};

	Parms.Result = Result;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.Server_GetShot
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::Server_GetShot(const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "Server_GetShot");

	Params::EverholmPlayerCharacter_Server_GetShot Parms{};

	Parms.HitResult = std::move(HitResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.Server_TeleportAllPlayers
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults)
// Parameters:
// const struct FVector&                   targetLocation                                         (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::Server_TeleportAllPlayers(const struct FVector& targetLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "Server_TeleportAllPlayers");

	Params::EverholmPlayerCharacter_Server_TeleportAllPlayers Parms{};

	Parms.targetLocation = std::move(targetLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.SetIsInBoat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    isInBoat                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::SetIsInBoat(bool isInBoat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "SetIsInBoat");

	Params::EverholmPlayerCharacter_SetIsInBoat Parms{};

	Parms.isInBoat = isInBoat;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.SimulateInput
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FInputActionValue&         Value                                                  (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const ECharacterInstruction             instruction                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::SimulateInput(const struct FInputActionValue& Value, const ECharacterInstruction instruction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "SimulateInput");

	Params::EverholmPlayerCharacter_SimulateInput Parms{};

	Parms.Value = std::move(Value);
	Parms.instruction = instruction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerCharacter.UpdatePlayerDrownProgress
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   Progress                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerCharacter::UpdatePlayerDrownProgress(float Progress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "UpdatePlayerDrownProgress");

	Params::EverholmPlayerCharacter_UpdatePlayerDrownProgress Parms{};

	Parms.Progress = Progress;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EverholmPlayerCharacter.GetAIEncounterDataComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAIEncounterDataComponent*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAIEncounterDataComponent* AEverholmPlayerCharacter::GetAIEncounterDataComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetAIEncounterDataComponent");

	Params::EverholmPlayerCharacter_GetAIEncounterDataComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerCharacter.GetHeldPickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bEvenIfCurrentlyStashing                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* AEverholmPlayerCharacter::GetHeldPickup(bool bEvenIfCurrentlyStashing) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetHeldPickup");

	Params::EverholmPlayerCharacter_GetHeldPickup Parms{};

	Parms.bEvenIfCurrentlyStashing = bEvenIfCurrentlyStashing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerCharacter.GetIsInBoat
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEverholmPlayerCharacter::GetIsInBoat() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetIsInBoat");

	Params::EverholmPlayerCharacter_GetIsInBoat Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerCharacter.GetPickupComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UEverholmPickupComponent*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UEverholmPickupComponent* AEverholmPlayerCharacter::GetPickupComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetPickupComponent");

	Params::EverholmPlayerCharacter_GetPickupComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerCharacter.GetPlayerPawnType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPlayerPawnType AEverholmPlayerCharacter::GetPlayerPawnType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetPlayerPawnType");

	Params::EverholmPlayerCharacter_GetPlayerPawnType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerCharacter.GetTargetingComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UTargetingComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTargetingComponent* AEverholmPlayerCharacter::GetTargetingComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerCharacter", "GetTargetingComponent");

	Params::EverholmPlayerCharacter_GetTargetingComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerManagerSubsystem.HaveAllPlayersSpawnedOnServerAndClient
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPlayerManagerSubsystem::HaveAllPlayersSpawnedOnServerAndClient() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerManagerSubsystem", "HaveAllPlayersSpawnedOnServerAndClient");

	Params::EverholmPlayerManagerSubsystem_HaveAllPlayersSpawnedOnServerAndClient Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerState.Server_SetOnlinePlatformString
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const class FString&                    platformString                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEverholmPlayerState::Server_SetOnlinePlatformString(const class FString& platformString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerState", "Server_SetOnlinePlatformString");

	Params::EverholmPlayerState_Server_SetOnlinePlatformString Parms{};

	Parms.platformString = std::move(platformString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPlayerState.GetEverholmPlayerCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* AEverholmPlayerState::GetEverholmPlayerCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerState", "GetEverholmPlayerCharacter");

	Params::EverholmPlayerState_GetEverholmPlayerCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerState.GetEverholmPlayerController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerController*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerController* AEverholmPlayerState::GetEverholmPlayerController() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerState", "GetEverholmPlayerController");

	Params::EverholmPlayerState_GetEverholmPlayerController Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerState.GetPlayerPawnType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerPawnType                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPlayerPawnType AEverholmPlayerState::GetPlayerPawnType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerState", "GetPlayerPawnType");

	Params::EverholmPlayerState_GetPlayerPawnType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPlayerState.GetPlayerStateType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPlayerStateType                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPlayerStateType AEverholmPlayerState::GetPlayerStateType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPlayerState", "GetPlayerStateType");

	Params::EverholmPlayerState_GetPlayerStateType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MenuItems.AddMainMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UMenuItems>           WidgetClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMenuItems::AddMainMenu(TSubclassOf<class UMenuItems> WidgetClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuItems", "AddMainMenu");

	Params::MenuItems_AddMainMenu Parms{};

	Parms.WidgetClass = WidgetClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuItems.HideUnselected
// (Final, Native, Public, BlueprintCallable)

void UMenuItems::HideUnselected()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuItems", "HideUnselected");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuItems.RemoveThisMenu
// (Final, Native, Public, BlueprintCallable)

void UMenuItems::RemoveThisMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuItems", "RemoveThisMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MenuItems.UnHideAll
// (Final, Native, Public, BlueprintCallable)

void UMenuItems::UnHideAll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MenuItems", "UnHideAll");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPumpInteraction.GetPumpInputData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FPumpInputData                   ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FPumpInputData UEverholmPumpInteraction::GetPumpInputData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPumpInteraction", "GetPumpInputData");

	Params::EverholmPumpInteraction_GetPumpInputData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmPumpInteraction.SetProcessInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ShouldProcessInput                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmPumpInteraction::SetProcessInput(bool ShouldProcessInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPumpInteraction", "SetProcessInput");

	Params::EverholmPumpInteraction_SetProcessInput Parms{};

	Parms.ShouldProcessInput = ShouldProcessInput;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPumpInteraction.UpdateRequiredIntent
// (Final, Native, Public, BlueprintCallable)

void UEverholmPumpInteraction::UpdateRequiredIntent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPumpInteraction", "UpdateRequiredIntent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmPumpInteraction.GetProcessInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmPumpInteraction::GetProcessInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmPumpInteraction", "GetProcessInput");

	Params::EverholmPumpInteraction_GetProcessInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.DisableCustomFlicker
// (Final, Native, Public, BlueprintCallable)

void ARadioPickup::DisableCustomFlicker()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "DisableCustomFlicker");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.KillTuningOnAudioComponent
// (Final, Native, Public, BlueprintCallable)

void ARadioPickup::KillTuningOnAudioComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "KillTuningOnAudioComponent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.OnActiveStateChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bIsActive                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::OnActiveStateChanged(bool bIsActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "OnActiveStateChanged");

	Params::RadioPickup_OnActiveStateChanged Parms{};

	Parms.bIsActive = bIsActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.OnInputReceived
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               User                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::OnInputReceived(class AEverholmCharacter* User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "OnInputReceived");

	Params::RadioPickup_OnInputReceived Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.OnInputRemoved
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               User                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::OnInputRemoved(class AEverholmCharacter* User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "OnInputRemoved");

	Params::RadioPickup_OnInputRemoved Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.OnRep_bIsTuning
// (Final, Native, Public)

void ARadioPickup::OnRep_bIsTuning()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "OnRep_bIsTuning");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.OnSignalCallback
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EAkCallbackType                         CallbackType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  CallbackInfo                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::OnSignalCallback(EAkCallbackType CallbackType, class UAkCallbackInfo* CallbackInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "OnSignalCallback");

	Params::RadioPickup_OnSignalCallback Parms{};

	Parms.CallbackType = CallbackType;
	Parms.CallbackInfo = CallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.PostRadioActiveEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ARadioPickup::PostRadioActiveEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "PostRadioActiveEvent");

	Params::RadioPickup_PostRadioActiveEvent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.PostSignalFoundEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UAkAudioEvent*                    signalFoundEvent                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ARadioPickup::PostSignalFoundEvent(class UAkAudioEvent* signalFoundEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "PostSignalFoundEvent");

	Params::RadioPickup_PostSignalFoundEvent Parms{};

	Parms.signalFoundEvent = signalFoundEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.PostStartTuningEvent
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ARadioPickup::PostStartTuningEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "PostStartTuningEvent");

	Params::RadioPickup_PostStartTuningEvent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.PostStopTuningEvent
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ARadioPickup::PostStopTuningEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "PostStopTuningEvent");

	Params::RadioPickup_PostStopTuningEvent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.PostTargetAudioEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class URadioTargetComponent*            Target                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ARadioPickup::PostTargetAudioEvent(class URadioTargetComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "PostTargetAudioEvent");

	Params::RadioPickup_PostTargetAudioEvent Parms{};

	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.SetFlickerCurve
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FRuntimeFloatCurve&        Curve                                                  (Parm, NativeAccessSpecifierPublic)
// float                                   Weight                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldLoop                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::SetFlickerCurve(const struct FRuntimeFloatCurve& Curve, float Weight, bool bShouldLoop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "SetFlickerCurve");

	Params::RadioPickup_SetFlickerCurve Parms{};

	Parms.Curve = std::move(Curve);
	Parms.Weight = Weight;
	Parms.bShouldLoop = bShouldLoop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.SetMaxLightIntensity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Intensity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::SetMaxLightIntensity(float Intensity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "SetMaxLightIntensity");

	Params::RadioPickup_SetMaxLightIntensity Parms{};

	Parms.Intensity = Intensity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.SetMaxScreenBrightness
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Brightness                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::SetMaxScreenBrightness(float Brightness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "SetMaxScreenBrightness");

	Params::RadioPickup_SetMaxScreenBrightness Parms{};

	Parms.Brightness = Brightness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.StartTuningInBoat
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   inputDir                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::StartTuningInBoat(const struct FVector& inputDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "StartTuningInBoat");

	Params::RadioPickup_StartTuningInBoat Parms{};

	Parms.inputDir = std::move(inputDir);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.StopRadioActiveEvent
// (Native, Event, Public, BlueprintEvent)

void ARadioPickup::StopRadioActiveEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "StopRadioActiveEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.StopRadioTargetEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class URadioTargetComponent*            Target                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PlayingID                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::StopRadioTargetEvent(class URadioTargetComponent* Target, int32 PlayingID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "StopRadioTargetEvent");

	Params::RadioPickup_StopRadioTargetEvent Parms{};

	Parms.Target = Target;
	Parms.PlayingID = PlayingID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.UnlockSignalType
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// ERadioSignalType                        signalType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARadioPickup::UnlockSignalType(ERadioSignalType signalType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "UnlockSignalType");

	Params::RadioPickup_UnlockSignalType Parms{};

	Parms.signalType = signalType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RadioPickup.GetAimVector
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const class AActor*                     holder                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ARadioPickup::GetAimVector(const class AActor* holder) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "GetAimVector");

	Params::RadioPickup_GetAimVector Parms{};

	Parms.holder = holder;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.GetFlickerLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ARadioPickup::GetFlickerLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "GetFlickerLevel");

	Params::RadioPickup_GetFlickerLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.GetRadioSignalLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ARadioPickup::GetRadioSignalLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "GetRadioSignalLevel");

	Params::RadioPickup_GetRadioSignalLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.HasAnyTargets
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ARadioPickup::HasAnyTargets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "HasAnyTargets");

	Params::RadioPickup_HasAnyTargets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RadioPickup.IsTuning
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ARadioPickup::IsTuning() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RadioPickup", "IsTuning");

	Params::RadioPickup_IsTuning Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.TiedTogetherOnSplineComponent.GetIntent
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UTiedTogetherOnSplineComponent::GetIntent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TiedTogetherOnSplineComponent", "GetIntent");

	Params::TiedTogetherOnSplineComponent_GetIntent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PlayerProfileSubsystem.OnPlayerLoggedOut
// (Final, Native, Public)
// Parameters:
// ELocalUserType                          Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Success                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerProfileSubsystem::OnPlayerLoggedOut(ELocalUserType Type, bool Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerProfileSubsystem", "OnPlayerLoggedOut");

	Params::PlayerProfileSubsystem_OnPlayerLoggedOut Parms{};

	Parms.Type = Type;
	Parms.Success = Success;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmSaveSystem.GetSlotMetadata
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FSaveSlotMetadata                ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FSaveSlotMetadata UEverholmSaveSystem::GetSlotMetadata(int32 SlotIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSaveSystem", "GetSlotMetadata");

	Params::EverholmSaveSystem_GetSlotMetadata Parms{};

	Parms.SlotIndex = SlotIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSaveSystem.OnPlayerInitialized
// (Final, Native, Private)
// Parameters:
// ELocalUserType                          Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Success                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Error                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmSaveSystem::OnPlayerInitialized(ELocalUserType Type, const class UCommonUserInfo* UserInfo, bool Success, const class FString& Error)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSaveSystem", "OnPlayerInitialized");

	Params::EverholmSaveSystem_OnPlayerInitialized Parms{};

	Parms.Type = Type;
	Parms.UserInfo = UserInfo;
	Parms.Success = Success;
	Parms.Error = std::move(Error);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmSaveSystem.OnPlayerLoggedOut
// (Final, Native, Private)
// Parameters:
// ELocalUserType                          Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Success                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmSaveSystem::OnPlayerLoggedOut(ELocalUserType Type, bool Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSaveSystem", "OnPlayerLoggedOut");

	Params::EverholmSaveSystem_OnPlayerLoggedOut Parms{};

	Parms.Type = Type;
	Parms.Success = Success;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmSaveSystem.DoesSlotHaveSaveData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmSaveSystem::DoesSlotHaveSaveData(int32 SlotIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSaveSystem", "DoesSlotHaveSaveData");

	Params::EverholmSaveSystem_DoesSlotHaveSaveData Parms{};

	Parms.SlotIndex = SlotIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSaveSystem.GetActiveSlotIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UEverholmSaveSystem::GetActiveSlotIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSaveSystem", "GetActiveSlotIndex");

	Params::EverholmSaveSystem_GetActiveSlotIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSaveSystem.GetAllUnlockedChaptersRowNameInChapterSelectDataTable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UEverholmSaveSystem::GetAllUnlockedChaptersRowNameInChapterSelectDataTable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSaveSystem", "GetAllUnlockedChaptersRowNameInChapterSelectDataTable");

	Params::EverholmSaveSystem_GetAllUnlockedChaptersRowNameInChapterSelectDataTable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSaveSystem.HasUnlockedChapter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ChapterRowNameInDataTable                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmSaveSystem::HasUnlockedChapter(class FName ChapterRowNameInDataTable) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSaveSystem", "HasUnlockedChapter");

	Params::EverholmSaveSystem_HasUnlockedChapter Parms{};

	Parms.ChapterRowNameInDataTable = ChapterRowNameInDataTable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PipOverrideInterface.GetCustomPipWorldLocation
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// class AEverholmPlayerCharacter*         Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInteractorComponent*             interactor                                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         WorldLocation                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   discard                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IPipOverrideInterface::GetCustomPipWorldLocation(class AEverholmPlayerCharacter* Character, class UInteractorComponent* interactor, struct FVector* WorldLocation, bool* discard) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("PipOverrideInterface", "GetCustomPipWorldLocation");

	Params::PipOverrideInterface_GetCustomPipWorldLocation Parms{};

	Parms.Character = Character;
	Parms.interactor = interactor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (WorldLocation != nullptr)
		*WorldLocation = std::move(Parms.WorldLocation);

	if (discard != nullptr)
		*discard = Parms.discard;
}


// Function Everholm.EverholmShaderPrecompilationManager.IsShaderPrecompilationComplete
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmShaderPrecompilationManager::IsShaderPrecompilationComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("EverholmShaderPrecompilationManager", "IsShaderPrecompilationComplete");

	Params::EverholmShaderPrecompilationManager_IsShaderPrecompilationComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmShaderPrecompilationManager.GetShaderPrecompilationPercentage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmShaderPrecompilationManager::GetShaderPrecompilationPercentage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmShaderPrecompilationManager", "GetShaderPrecompilationPercentage");

	Params::EverholmShaderPrecompilationManager_GetShaderPrecompilationPercentage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmShaderPrecompilationManager.SetShaderPrecompilationMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EShaderPrecompilationMode               Mode                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmShaderPrecompilationManager::SetShaderPrecompilationMode(EShaderPrecompilationMode Mode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmShaderPrecompilationManager", "SetShaderPrecompilationMode");

	Params::EverholmShaderPrecompilationManager_SetShaderPrecompilationMode Parms{};

	Parms.Mode = Mode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmShaderPrecompilationManager.GetShaderPrecompilationMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EShaderPrecompilationMode               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EShaderPrecompilationMode UEverholmShaderPrecompilationManager::GetShaderPrecompilationMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmShaderPrecompilationManager", "GetShaderPrecompilationMode");

	Params::EverholmShaderPrecompilationManager_GetShaderPrecompilationMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmShaderPrecompilationManager.ShouldDisplayProgressUI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmShaderPrecompilationManager::ShouldDisplayProgressUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmShaderPrecompilationManager", "ShouldDisplayProgressUI");

	Params::EverholmShaderPrecompilationManager_ShouldDisplayProgressUI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SignalActivationGroupRegion.HIP_SetActivationGroupState
// (Final, Native, Public)
// Parameters:
// bool                                    bIsActive                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActivationGroupRegion::HIP_SetActivationGroupState(bool bIsActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActivationGroupRegion", "HIP_SetActivationGroupState");

	Params::SignalActivationGroupRegion_HIP_SetActivationGroupState Parms{};

	Parms.bIsActive = bIsActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmSplineComponent.GetTotalInputKeyValueOfSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UEverholmSplineComponent::GetTotalInputKeyValueOfSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSplineComponent", "GetTotalInputKeyValueOfSpline");

	Params::EverholmSplineComponent_GetTotalInputKeyValueOfSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSplineComponent.GetWorldLocationFurtherAlongSpline
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   currentLocation                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             distanceFurtherAlongSpline                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             currentSplineInputKey                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmSplineComponent::GetWorldLocationFurtherAlongSpline(const struct FVector& currentLocation, const float distanceFurtherAlongSpline, const float currentSplineInputKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSplineComponent", "GetWorldLocationFurtherAlongSpline");

	Params::EverholmSplineComponent_GetWorldLocationFurtherAlongSpline Parms{};

	Parms.currentLocation = std::move(currentLocation);
	Parms.distanceFurtherAlongSpline = distanceFurtherAlongSpline;
	Parms.currentSplineInputKey = currentSplineInputKey;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSplineComponent.GetWorldLocationFurtherAlongSplineBasedOnDistance
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             travelledDistance                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             distanceFurtherAlongSpline                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UEverholmSplineComponent::GetWorldLocationFurtherAlongSplineBasedOnDistance(const float travelledDistance, const float distanceFurtherAlongSpline) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSplineComponent", "GetWorldLocationFurtherAlongSplineBasedOnDistance");

	Params::EverholmSplineComponent_GetWorldLocationFurtherAlongSplineBasedOnDistance Parms{};

	Parms.travelledDistance = travelledDistance;
	Parms.distanceFurtherAlongSpline = distanceFurtherAlongSpline;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSuspenseSubsystem.RequestThreatLevel_Server
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// ESuspenseThreatLevel                    threatLevel                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          requester                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmSuspenseSubsystem::RequestThreatLevel_Server(ESuspenseThreatLevel threatLevel, class UObject* requester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSuspenseSubsystem", "RequestThreatLevel_Server");

	Params::EverholmSuspenseSubsystem_RequestThreatLevel_Server Parms{};

	Parms.threatLevel = threatLevel;
	Parms.requester = requester;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmSuspenseSubsystem.UnrequestThreatLevel_Server
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          requester                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmSuspenseSubsystem::UnrequestThreatLevel_Server(class UObject* requester)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSuspenseSubsystem", "UnrequestThreatLevel_Server");

	Params::EverholmSuspenseSubsystem_UnrequestThreatLevel_Server Parms{};

	Parms.requester = requester;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmSuspenseSubsystem.AreEnemiesNearby
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UEverholmSuspenseSubsystem::AreEnemiesNearby() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSuspenseSubsystem", "AreEnemiesNearby");

	Params::EverholmSuspenseSubsystem_AreEnemiesNearby Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSuspenseSubsystem.GetHighestThreatAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmCharacter*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmCharacter* UEverholmSuspenseSubsystem::GetHighestThreatAI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSuspenseSubsystem", "GetHighestThreatAI");

	Params::EverholmSuspenseSubsystem_GetHighestThreatAI Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmSuspenseSubsystem.GetThreatLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ESuspenseThreatLevel                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ESuspenseThreatLevel UEverholmSuspenseSubsystem::GetThreatLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmSuspenseSubsystem", "GetThreatLevel");

	Params::EverholmSuspenseSubsystem_GetThreatLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmTickOptimization.OnCinematicModeChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bIsEnabled                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmTickOptimization::OnCinematicModeChanged(bool bIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmTickOptimization", "OnCinematicModeChanged");

	Params::EverholmTickOptimization_OnCinematicModeChanged Parms{};

	Parms.bIsEnabled = bIsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmWaterBodyEventInterface.ActorFoundInWaterBodyBounds
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UWaterBodyComponent*              WaterBodyComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IEverholmWaterBodyEventInterface::ActorFoundInWaterBodyBounds(class UWaterBodyComponent* WaterBodyComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("EverholmWaterBodyEventInterface", "ActorFoundInWaterBodyBounds");

	Params::EverholmWaterBodyEventInterface_ActorFoundInWaterBodyBounds Parms{};

	Parms.WaterBodyComponent = WaterBodyComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmWaterSubsystem.GetWaterBodyAtLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWaterBodyComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterBodyComponent* UEverholmWaterSubsystem::GetWaterBodyAtLocation(const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmWaterSubsystem", "GetWaterBodyAtLocation");

	Params::EverholmWaterSubsystem_GetWaterBodyAtLocation Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmWaterSubsystem.GetWaterBodyForActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UWaterBodyComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterBodyComponent* UEverholmWaterSubsystem::GetWaterBodyForActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmWaterSubsystem", "GetWaterBodyForActor");

	Params::EverholmWaterSubsystem_GetWaterBodyForActor Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EverholmWaterSubsystem.OnWaterBodyAdded
// (Final, Native, Protected)
// Parameters:
// class UWaterBodyComponent*              WaterBodyComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmWaterSubsystem::OnWaterBodyAdded(class UWaterBodyComponent* WaterBodyComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmWaterSubsystem", "OnWaterBodyAdded");

	Params::EverholmWaterSubsystem_OnWaterBodyAdded Parms{};

	Parms.WaterBodyComponent = WaterBodyComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmWaterSubsystem.OnWaterBodyRemoved
// (Final, Native, Protected)
// Parameters:
// class UWaterBodyComponent*              WaterBodyComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmWaterSubsystem::OnWaterBodyRemoved(class UWaterBodyComponent* WaterBodyComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmWaterSubsystem", "OnWaterBodyRemoved");

	Params::EverholmWaterSubsystem_OnWaterBodyRemoved Parms{};

	Parms.WaterBodyComponent = WaterBodyComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmWaterSubsystem.GetOceanWaterBodyComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWaterBodyComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWaterBodyComponent* UEverholmWaterSubsystem::GetOceanWaterBodyComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmWaterSubsystem", "GetOceanWaterBodyComponent");

	Params::EverholmWaterSubsystem_GetOceanWaterBodyComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVMotherFinale.EnsurePlayerOneIsFocused
// (Final, Native, Public, BlueprintCallable)

void AEVMotherFinale::EnsurePlayerOneIsFocused()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "EnsurePlayerOneIsFocused");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.Multicast_Cleanup
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void AEVMotherFinale::Multicast_Cleanup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "Multicast_Cleanup");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.Multicast_SwitchCameraFocus
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class AEverholmPlayerCharacter*         playerToFocus                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         playerToIgnore                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVMotherFinale::Multicast_SwitchCameraFocus(class AEverholmPlayerCharacter* playerToFocus, class AEverholmPlayerCharacter* playerToIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "Multicast_SwitchCameraFocus");

	Params::EVMotherFinale_Multicast_SwitchCameraFocus Parms{};

	Parms.playerToFocus = playerToFocus;
	Parms.playerToIgnore = playerToIgnore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.Multicast_SwitchPlayerControl
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class AEverholmPlayerCharacter*         playerToFocus                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         playerToIgnore                                         (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVMotherFinale::Multicast_SwitchPlayerControl(class AEverholmPlayerCharacter* playerToFocus, class AEverholmPlayerCharacter* playerToIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "Multicast_SwitchPlayerControl");

	Params::EVMotherFinale_Multicast_SwitchPlayerControl Parms{};

	Parms.playerToFocus = playerToFocus;
	Parms.playerToIgnore = playerToIgnore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.OnFinaleEventStarted
// (Event, Public, BlueprintEvent)

void AEVMotherFinale::OnFinaleEventStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "OnFinaleEventStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.EVMotherFinale.OnFinaleProgressionChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   mainStage                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMotherFinaleSubStage                   subStage                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVMotherFinale::OnFinaleProgressionChanged(int32 mainStage, EMotherFinaleSubStage subStage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "OnFinaleProgressionChanged");

	Params::EVMotherFinale_OnFinaleProgressionChanged Parms{};

	Parms.mainStage = mainStage;
	Parms.subStage = subStage;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EVMotherFinale.OnFinaleStageStarted
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   newStageIndex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVMotherFinale::OnFinaleStageStarted(int32 newStageIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "OnFinaleStageStarted");

	Params::EVMotherFinale_OnFinaleStageStarted Parms{};

	Parms.newStageIndex = newStageIndex;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.EVMotherFinale.OnRequiredInteractionTriggered
// (Final, Native, Private)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInteractEndReason                interactEndReason                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVMotherFinale::OnRequiredInteractionTriggered(class APawn* Initiator, const EInteractEndReason interactEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "OnRequiredInteractionTriggered");

	Params::EVMotherFinale_OnRequiredInteractionTriggered Parms{};

	Parms.Initiator = Initiator;
	Parms.interactEndReason = interactEndReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.StartFinaleStage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const int32                             finaleStage                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EMotherFinaleSubStage             subStageOverride                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVMotherFinale::StartFinaleStage(const int32 finaleStage, const EMotherFinaleSubStage subStageOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "StartFinaleStage");

	Params::EVMotherFinale_StartFinaleStage Parms{};

	Parms.finaleStage = finaleStage;
	Parms.subStageOverride = subStageOverride;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.StartMotherFinale
// (Final, Native, Public, BlueprintCallable)

void AEVMotherFinale::StartMotherFinale()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "StartMotherFinale");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.TriggerRequiredInteraction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AEVMotherFinale::TriggerRequiredInteraction(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "TriggerRequiredInteraction");

	Params::EVMotherFinale_TriggerRequiredInteraction Parms{};

	Parms.Initiator = Initiator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVMotherFinale.GetCurrentlyFocusedPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* AEVMotherFinale::GetCurrentlyFocusedPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "GetCurrentlyFocusedPlayer");

	Params::EVMotherFinale_GetCurrentlyFocusedPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVMotherFinale.GetCurrentMotherFinaleStage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AEVMotherFinale::GetCurrentMotherFinaleStage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "GetCurrentMotherFinaleStage");

	Params::EVMotherFinale_GetCurrentMotherFinaleStage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVMotherFinale.GetCurrentMotherFinaleSubStage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EMotherFinaleSubStage                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMotherFinaleSubStage AEVMotherFinale::GetCurrentMotherFinaleSubStage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "GetCurrentMotherFinaleSubStage");

	Params::EVMotherFinale_GetCurrentMotherFinaleSubStage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVMotherFinale.GetThreatenedPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APawn* AEVMotherFinale::GetThreatenedPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "GetThreatenedPlayer");

	Params::EVMotherFinale_GetThreatenedPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVMotherFinale.HasFinaleStarted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AEVMotherFinale::HasFinaleStarted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVMotherFinale", "HasFinaleStarted");

	Params::EVMotherFinale_HasFinaleStarted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.EVSpiderkidLightSource.SetAffectedArea
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// float                                   NewArea                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEVSpiderkidLightSource::SetAffectedArea(float NewArea)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVSpiderkidLightSource", "SetAffectedArea");

	Params::EVSpiderkidLightSource_SetAffectedArea Parms{};

	Parms.NewArea = NewArea;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EVSpiderkidLightSource.GetClosestRetreatLocation
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAILocationUnion&          SourceLocation                                         (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FAILocationUnion                 ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FAILocationUnion UEVSpiderkidLightSource::GetClosestRetreatLocation(const struct FAILocationUnion& SourceLocation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EVSpiderkidLightSource", "GetClosestRetreatLocation");

	Params::EVSpiderkidLightSource_GetClosestRetreatLocation Parms{};

	Parms.SourceLocation = std::move(SourceLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ExternalCameraBlendingVolume.GetExternalBlendWeight
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FCameraHintInParameters&   inParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// double                                  timedBlendIn                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class ADirectedCameraHint_Base*   testHint                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FExternalBlendResult             ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FExternalBlendResult AExternalCameraBlendingVolume::GetExternalBlendWeight(const struct FCameraHintInParameters& inParams, double timedBlendIn, const class ADirectedCameraHint_Base* testHint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExternalCameraBlendingVolume", "GetExternalBlendWeight");

	Params::ExternalCameraBlendingVolume_GetExternalBlendWeight Parms{};

	Parms.inParams = std::move(inParams);
	Parms.timedBlendIn = timedBlendIn;
	Parms.testHint = testHint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ExternalCameraBlendingVolume.PrintVolumeDebugInfo
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AExternalCameraBlendingVolume::PrintVolumeDebugInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExternalCameraBlendingVolume", "PrintVolumeDebugInfo");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.ExternalCameraBlendingVolume.SetUsedThisFrame
// (Final, Native, Public, BlueprintCallable)

void AExternalCameraBlendingVolume::SetUsedThisFrame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExternalCameraBlendingVolume", "SetUsedThisFrame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ExternalCameraBlendingVolume.GetUsedThisFrame
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AExternalCameraBlendingVolume::GetUsedThisFrame() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExternalCameraBlendingVolume", "GetUsedThisFrame");

	Params::ExternalCameraBlendingVolume_GetUsedThisFrame Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ExtGameViewportClient.GetExtendedViewportClient
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContext                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UExtGameViewportClient*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UExtGameViewportClient* UExtGameViewportClient::GetExtendedViewportClient(const class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ExtGameViewportClient", "GetExtendedViewportClient");

	Params::ExtGameViewportClient_GetExtendedViewportClient Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ExtGameViewportClient.SetPlayerViewRect
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FViewRect&                 ViewRect                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UExtGameViewportClient::SetPlayerViewRect(int32 LocalPlayerIndex, const struct FViewRect& ViewRect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExtGameViewportClient", "SetPlayerViewRect");

	Params::ExtGameViewportClient_SetPlayerViewRect Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;
	Parms.ViewRect = std::move(ViewRect);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ExtGameViewportClient.GetPlayerFovMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFovLockAxis                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFovLockAxis UExtGameViewportClient::GetPlayerFovMode(int32 LocalPlayerIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExtGameViewportClient", "GetPlayerFovMode");

	Params::ExtGameViewportClient_GetPlayerFovMode Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ExtGameViewportClient.GetPlayerViewRect
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FViewRect                        ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FViewRect UExtGameViewportClient::GetPlayerViewRect(int32 LocalPlayerIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExtGameViewportClient", "GetPlayerViewRect");

	Params::ExtGameViewportClient_GetPlayerViewRect Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ExtGameViewportClient.SetPlayerFovMode
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// int32                                   LocalPlayerIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFovLockAxis                            Mode                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UExtGameViewportClient::SetPlayerFovMode(int32 LocalPlayerIndex, EFovLockAxis Mode) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ExtGameViewportClient", "SetPlayerFovMode");

	Params::ExtGameViewportClient_SetPlayerFovMode Parms{};

	Parms.LocalPlayerIndex = LocalPlayerIndex;
	Parms.Mode = Mode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.FixedAngleSphereHint.GetHintRotation
// (Native, Event, Protected, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AFixedAngleSphereHint::GetHintRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FixedAngleSphereHint", "GetHintRotation");

	Params::FixedAngleSphereHint_GetHintRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GameEffectManager.OnGameEffectEnded
// (Final, Native, Public)
// Parameters:
// class UGameEffect*                      GameEffect                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AGameEffectManager::OnGameEffectEnded(class UGameEffect* GameEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffectManager", "OnGameEffectEnded");

	Params::GameEffectManager_OnGameEffectEnded Parms{};

	Parms.GameEffect = GameEffect;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GameEffectManager.PlayGameEffect
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FNetworkedGameEffectProperties&Data                                                   (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void AGameEffectManager::PlayGameEffect(const struct FNetworkedGameEffectProperties& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GameEffectManager", "PlayGameEffect");

	Params::GameEffectManager_PlayGameEffect Parms{};

	Parms.Data = std::move(Data);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GameEffectFunctionLibrary.GetOrCreateGameEffectManager
// (Final, Native, Static, Public)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AGameEffectManager*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AGameEffectManager* UGameEffectFunctionLibrary::GetOrCreateGameEffectManager(class UObject* WorldContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GameEffectFunctionLibrary", "GetOrCreateGameEffectManager");

	Params::GameEffectFunctionLibrary_GetOrCreateGameEffectManager Parms{};

	Parms.WorldContext = WorldContext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GameEffectFunctionLibrary.PlayGameEffect
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameEffect*                      GameEffect                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGameEffectFunctionLibrary::PlayGameEffect(class UGameEffect* GameEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("GameEffectFunctionLibrary", "PlayGameEffect");

	Params::GameEffectFunctionLibrary_PlayGameEffect Parms{};

	Parms.GameEffect = GameEffect;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaypointActor.OnTrackedGameGlobalChanged
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWaypointActor::OnTrackedGameGlobalChanged(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaypointActor", "OnTrackedGameGlobalChanged");

	Params::WaypointActor_OnTrackedGameGlobalChanged Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericControllerDisconnectedMessage.NativeOnTryReconnectUser
// (Final, Native, Protected)
// Parameters:
// const ELocalUserType                    localUserType                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            device                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EUserReconnectResult                    Result                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGenericControllerDisconnectedMessage::NativeOnTryReconnectUser(const ELocalUserType localUserType, const struct FInputDeviceId& device, EUserReconnectResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerDisconnectedMessage", "NativeOnTryReconnectUser");

	Params::GenericControllerDisconnectedMessage_NativeOnTryReconnectUser Parms{};

	Parms.localUserType = localUserType;
	Parms.device = std::move(device);
	Parms.Result = Result;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericControllerDisconnectedMessage.OnControllerConnectionChange
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bConnected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ControllerId                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            InputDevice                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                PlayerController                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGenericControllerDisconnectedMessage::OnControllerConnectionChange(bool bConnected, int32 ControllerId, const struct FInputDeviceId& InputDevice, class APlayerController* PlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerDisconnectedMessage", "OnControllerConnectionChange");

	Params::GenericControllerDisconnectedMessage_OnControllerConnectionChange Parms{};

	Parms.bConnected = bConnected;
	Parms.ControllerId = ControllerId;
	Parms.InputDevice = std::move(InputDevice);
	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericControllerDisconnectedMessage.OnDisconnectUser
// (Event, Protected, BlueprintEvent)

void UGenericControllerDisconnectedMessage::OnDisconnectUser()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerDisconnectedMessage", "OnDisconnectUser");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.GenericControllerDisconnectedMessage.OnTryReconnectUser
// (Event, Protected, BlueprintEvent)
// Parameters:
// const ELocalUserType                    localUserType                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FInputDeviceId&            device                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EUserReconnectResult                    Result                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGenericControllerDisconnectedMessage::OnTryReconnectUser(const ELocalUserType localUserType, const struct FInputDeviceId& device, EUserReconnectResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerDisconnectedMessage", "OnTryReconnectUser");

	Params::GenericControllerDisconnectedMessage_OnTryReconnectUser Parms{};

	Parms.localUserType = localUserType;
	Parms.device = std::move(device);
	Parms.Result = Result;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.GenericControllerDisconnectedMessage.ShowPromptWithMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (Parm, NativeAccessSpecifierPublic)

void UGenericControllerDisconnectedMessage::ShowPromptWithMessage(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerDisconnectedMessage", "ShowPromptWithMessage");

	Params::GenericControllerDisconnectedMessage_ShowPromptWithMessage Parms{};

	Parms.InText = std::move(InText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.GenericControllerDisconnectedMessage.CanContinue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGenericControllerDisconnectedMessage::CanContinue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericControllerDisconnectedMessage", "CanContinue");

	Params::GenericControllerDisconnectedMessage_CanContinue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GenericMessage.ShowPromptWithMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      InText                                                 (Parm, NativeAccessSpecifierPublic)

void UGenericMessage::ShowPromptWithMessage(const class FText& InText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GenericMessage", "ShowPromptWithMessage");

	Params::GenericMessage_ShowPromptWithMessage Parms{};

	Parms.InText = std::move(InText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.StickySurfaceSlotComponent.OnActorClassLoaded
// (Final, Native, Private)

void UStickySurfaceSlotComponent::OnActorClassLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurfaceSlotComponent", "OnActorClassLoaded");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.StickySurfaceSlotComponent.GetActorInSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UStickySurfaceSlotComponent::GetActorInSlot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StickySurfaceSlotComponent", "GetActorInSlot");

	Params::StickySurfaceSlotComponent_GetActorInSlot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GrabHelperComponent.GetGrabHelperConfig
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGrabHelperConfig                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGrabHelperConfig UGrabHelperComponent::GetGrabHelperConfig() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelperComponent", "GetGrabHelperConfig");

	Params::GrabHelperComponent_GetGrabHelperConfig Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GrabHelperComponent.GetIsAutoPushable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabHelperComponent::GetIsAutoPushable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelperComponent", "GetIsAutoPushable");

	Params::GrabHelperComponent_GetIsAutoPushable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.GrabHelperComponent.GetIsAvailable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabHelperComponent::GetIsAvailable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelperComponent", "GetIsAvailable");

	Params::GrabHelperComponent_GetIsAvailable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PassengerMoveAroundComponent.CinematicModeEnabled
// (Final, Native, Protected)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPassengerMoveAroundComponent::CinematicModeEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "CinematicModeEnabled");

	Params::PassengerMoveAroundComponent_CinematicModeEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.InitialEnterLockDone
// (Final, Native, Protected)

void UPassengerMoveAroundComponent::InitialEnterLockDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "InitialEnterLockDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.LockPassengerAtSplineIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPassengerMoveAroundComponent::LockPassengerAtSplineIndex(int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "LockPassengerAtSplineIndex");

	Params::PassengerMoveAroundComponent_LockPassengerAtSplineIndex Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.OnPassengerPickupChanging
// (Final, Native, Protected)
// Parameters:
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPassengerMoveAroundComponent::OnPassengerPickupChanging(class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "OnPassengerPickupChanging");

	Params::PassengerMoveAroundComponent_OnPassengerPickupChanging Parms{};

	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.OnRep_TargetSplineInputKey
// (Final, Native, Protected)

void UPassengerMoveAroundComponent::OnRep_TargetSplineInputKey()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "OnRep_TargetSplineInputKey");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.ResetPassengerDirection
// (Final, Native, Public, BlueprintCallable)

void UPassengerMoveAroundComponent::ResetPassengerDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "ResetPassengerDirection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.SetPlayerIntent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FVehicleControlData&       controlData                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   cameraHintYawWeight                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPassengerMoveAroundComponent::SetPlayerIntent(const struct FVehicleControlData& controlData, float cameraHintYawWeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "SetPlayerIntent");

	Params::PassengerMoveAroundComponent_SetPlayerIntent Parms{};

	Parms.controlData = std::move(controlData);
	Parms.cameraHintYawWeight = cameraHintYawWeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.UnblockMoveAfterThrow
// (Final, Native, Protected)

void UPassengerMoveAroundComponent::UnblockMoveAfterThrow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "UnblockMoveAfterThrow");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.UnblockPassengerMoveAroundAfterThrow
// (Final, Native, Public, BlueprintCallable)

void UPassengerMoveAroundComponent::UnblockPassengerMoveAroundAfterThrow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "UnblockPassengerMoveAroundAfterThrow");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.UnlockPassengerMoveAround
// (Final, Native, Public, BlueprintCallable)

void UPassengerMoveAroundComponent::UnlockPassengerMoveAround()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "UnlockPassengerMoveAround");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.VehiclePassengerRoleAssigned
// (Final, Native, Protected)
// Parameters:
// const class AEverholmCharacter*         newPassenger                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmCharacter*         oldPassenger                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPassengerMoveAroundComponent::VehiclePassengerRoleAssigned(const class AEverholmCharacter* newPassenger, const class AEverholmCharacter* oldPassenger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "VehiclePassengerRoleAssigned");

	Params::PassengerMoveAroundComponent_VehiclePassengerRoleAssigned Parms{};

	Parms.newPassenger = newPassenger;
	Parms.oldPassenger = oldPassenger;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PassengerMoveAroundComponent.GetCurrentAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UPassengerMoveAroundComponent::GetCurrentAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "GetCurrentAngle");

	Params::PassengerMoveAroundComponent_GetCurrentAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PassengerMoveAroundComponent.GetCurrentSplinePositionIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPassengerMoveAroundComponent::GetCurrentSplinePositionIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "GetCurrentSplinePositionIndex");

	Params::PassengerMoveAroundComponent_GetCurrentSplinePositionIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PassengerMoveAroundComponent.GetPassengerMoveAroundData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVehicleCharacterMoveAround      ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FVehicleCharacterMoveAround UPassengerMoveAroundComponent::GetPassengerMoveAroundData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PassengerMoveAroundComponent", "GetPassengerMoveAroundData");

	Params::PassengerMoveAroundComponent_GetPassengerMoveAroundData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ProgressionComponent.HOP_OnProgressionApplied
// (Final, Native, Public)

void UProgressionComponent::HOP_OnProgressionApplied()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ProgressionComponent", "HOP_OnProgressionApplied");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ProgressionComponent.IsProgressionCompleted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UProgressionComponent::IsProgressionCompleted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ProgressionComponent", "IsProgressionCompleted");

	Params::ProgressionComponent_IsProgressionCompleted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.HarpoonPickup.HandleStaticHarpoonSpawned
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AHarpoonPickup::HandleStaticHarpoonSpawned()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HarpoonPickup", "HandleStaticHarpoonSpawned");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.HarpoonPickup.SpawnClientDirectedHarpoon
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         throwInstigator                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           hitActor                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                spawnTransform                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AHarpoonPickup::SpawnClientDirectedHarpoon(class AEverholmPlayerCharacter* throwInstigator, class AActor* hitActor, const struct FTransform& spawnTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HarpoonPickup", "SpawnClientDirectedHarpoon");

	Params::HarpoonPickup_SpawnClientDirectedHarpoon Parms{};

	Parms.throwInstigator = throwInstigator;
	Parms.hitActor = hitActor;
	Parms.spawnTransform = std::move(spawnTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.HarpoonPickup.SpawnStaticHarpoon
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           hitActor                                               (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                spawnTransform                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AHarpoonPickup::SpawnStaticHarpoon(class AActor* hitActor, const struct FTransform& spawnTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HarpoonPickup", "SpawnStaticHarpoon");

	Params::HarpoonPickup_SpawnStaticHarpoon Parms{};

	Parms.hitActor = hitActor;
	Parms.spawnTransform = std::move(spawnTransform);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.IKAnimDataComponent.ApplyData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerIKPriority                       Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   defaultAlpha                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UIKAnimDataComponent::ApplyData(class AEverholmPlayerCharacter* Player, EPlayerIKPriority Priority, float defaultAlpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKAnimDataComponent", "ApplyData");

	Params::IKAnimDataComponent_ApplyData Parms{};

	Parms.Player = Player;
	Parms.Priority = Priority;
	Parms.defaultAlpha = defaultAlpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKAnimDataComponent.BlendIn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerIKPriority                       Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEasingFunc                             EasingFunction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UIKAnimDataComponent::BlendIn(class AEverholmPlayerCharacter* Player, EPlayerIKPriority Priority, float Duration, EEasingFunc EasingFunction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKAnimDataComponent", "BlendIn");

	Params::IKAnimDataComponent_BlendIn Parms{};

	Parms.Player = Player;
	Parms.Priority = Priority;
	Parms.Duration = Duration;
	Parms.EasingFunction = EasingFunction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKAnimDataComponent.BlendOut
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerIKPriority                       Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEasingFunc                             EasingFunction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UIKAnimDataComponent::BlendOut(class AEverholmPlayerCharacter* Player, EPlayerIKPriority Priority, float Duration, EEasingFunc EasingFunction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKAnimDataComponent", "BlendOut");

	Params::IKAnimDataComponent_BlendOut Parms{};

	Parms.Player = Player;
	Parms.Priority = Priority;
	Parms.Duration = Duration;
	Parms.EasingFunction = EasingFunction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKAnimDataComponent.ClearData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPlayerIKPriority                       Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UIKAnimDataComponent::ClearData(class AEverholmPlayerCharacter* Player, EPlayerIKPriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKAnimDataComponent", "ClearData");

	Params::IKAnimDataComponent_ClearData Parms{};

	Parms.Player = Player;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKAnimDataComponent.StopBlend
// (Final, Native, Public, BlueprintCallable)

void UIKAnimDataComponent::StopBlend()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKAnimDataComponent", "StopBlend");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKAnimDataComponent.IsBlending
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UIKAnimDataComponent::IsBlending() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKAnimDataComponent", "IsBlending");

	Params::IKAnimDataComponent_IsBlending Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.IKAnimDataComponent.ShouldApplyData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UIKAnimDataComponent::ShouldApplyData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKAnimDataComponent", "ShouldApplyData");

	Params::IKAnimDataComponent_ShouldApplyData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.IKPointComponent.ActivateIK
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AEverholmPlayerCharacter*         Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   blendDuration                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEasingFunc                             EasingFunction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UIKPointComponent::ActivateIK(class AEverholmPlayerCharacter* Player, float blendDuration, EEasingFunc EasingFunction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKPointComponent", "ActivateIK");

	Params::IKPointComponent_ActivateIK Parms{};

	Parms.Player = Player;
	Parms.blendDuration = blendDuration;
	Parms.EasingFunction = EasingFunction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKPointComponent.DeactivateIK
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   blendDuration                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEasingFunc                             EasingFunction                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UIKPointComponent::DeactivateIK(float blendDuration, EEasingFunc EasingFunction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKPointComponent", "DeactivateIK");

	Params::IKPointComponent_DeactivateIK Parms{};

	Parms.blendDuration = blendDuration;
	Parms.EasingFunction = EasingFunction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKPointComponent.ManualTick
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UIKPointComponent::ManualTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKPointComponent", "ManualTick");

	Params::IKPointComponent_ManualTick Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.IKPointComponent.GetActiveIKPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UIKPointComponent::GetActiveIKPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKPointComponent", "GetActiveIKPlayer");

	Params::IKPointComponent_GetActiveIKPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.IKPointComponent.IsIKActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UIKPointComponent::IsIKActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IKPointComponent", "IsIKActive");

	Params::IKPointComponent_IsIKActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.IntersectionHint.CalculateExitWeights
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   focalPointWorldLocation                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<float>                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<float> AIntersectionHint::CalculateExitWeights(const struct FVector& focalPointWorldLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IntersectionHint", "CalculateExitWeights");

	Params::IntersectionHint_CalculateExitWeights Parms{};

	Parms.focalPointWorldLocation = std::move(focalPointWorldLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.IntersectionHint.GetCameraDirection
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   focalPointWorldLocation                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<float>&                    exitWeights                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AIntersectionHint::GetCameraDirection(const struct FVector& focalPointWorldLocation, const TArray<float>& exitWeights)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("IntersectionHint", "GetCameraDirection");

	Params::IntersectionHint_GetCameraDirection Parms{};

	Parms.focalPointWorldLocation = std::move(focalPointWorldLocation);
	Parms.exitWeights = std::move(exitWeights);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InWaterMovementMode.OnDrowning
// (Event, Public, BlueprintEvent)

void UInWaterMovementMode::OnDrowning()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "OnDrowning");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.InWaterMovementMode.OnEntryAnimFinished
// (Final, Native, Public)

void UInWaterMovementMode::OnEntryAnimFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "OnEntryAnimFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.InWaterMovementMode.OnPostMovementTick
// (Event, Public, BlueprintEvent)
// Parameters:
// const float                             DeltaTime                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInWaterMovementMode::OnPostMovementTick(const float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "OnPostMovementTick");

	Params::InWaterMovementMode_OnPostMovementTick Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.InWaterMovementMode.OnStartSwimming
// (Event, Public, BlueprintEvent)

void UInWaterMovementMode::OnStartSwimming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "OnStartSwimming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.InWaterMovementMode.OnStopSwimming
// (Event, Public, BlueprintEvent)

void UInWaterMovementMode::OnStopSwimming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "OnStopSwimming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.InWaterMovementMode.OnWaterEntry
// (Event, Public, BlueprintEvent)
// Parameters:
// const bool                              bWasLanding                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInWaterMovementMode::OnWaterEntry(const bool bWasLanding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "OnWaterEntry");

	Params::InWaterMovementMode_OnWaterEntry Parms{};

	Parms.bWasLanding = bWasLanding;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.InWaterMovementMode.OnWaterExit
// (Event, Public, BlueprintEvent)

void UInWaterMovementMode::OnWaterExit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "OnWaterExit");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.InWaterMovementMode.GetCharacterOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AEverholmPlayerCharacter*   ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class AEverholmPlayerCharacter* UInWaterMovementMode::GetCharacterOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "GetCharacterOwner");

	Params::InWaterMovementMode_GetCharacterOwner Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.InWaterMovementMode.GetOwnerLocationOnSurface
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UInWaterMovementMode::GetOwnerLocationOnSurface() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InWaterMovementMode", "GetOwnerLocationOnSurface");

	Params::InWaterMovementMode_GetOwnerLocationOnSurface Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.JumpAbility.OnMovementModeChanged
// (Final, Native, Public)
// Parameters:
// class UEverholmCharacterMovementComponent*MovementComponent                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmCharacterMovementMode          PreviousMovementMode                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UJumpAbility::OnMovementModeChanged(class UEverholmCharacterMovementComponent* MovementComponent, EEverholmCharacterMovementMode PreviousMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("JumpAbility", "OnMovementModeChanged");

	Params::JumpAbility_OnMovementModeChanged Parms{};

	Parms.MovementComponent = MovementComponent;
	Parms.PreviousMovementMode = PreviousMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SoundInteractionReactorComponent.GatherActiveInteractors
// (Event, Public, BlueprintEvent)

void USoundInteractionReactorComponent::GatherActiveInteractors()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundInteractionReactorComponent", "GatherActiveInteractors");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Everholm.SoundInteractionReactorComponent.SetIsListening
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldListen                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USoundInteractionReactorComponent::SetIsListening(bool bShouldListen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundInteractionReactorComponent", "SetIsListening");

	Params::SoundInteractionReactorComponent_SetIsListening Parms{};

	Parms.bShouldListen = bShouldListen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SoundInteractionReactorComponent.SetPrimitiveOverlapVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              PrimitiveComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USoundInteractionReactorComponent::SetPrimitiveOverlapVolume(class UPrimitiveComponent* PrimitiveComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundInteractionReactorComponent", "SetPrimitiveOverlapVolume");

	Params::SoundInteractionReactorComponent_SetPrimitiveOverlapVolume Parms{};

	Parms.PrimitiveComponent = PrimitiveComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SoundInteractionReactorComponent.GetIsListening
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USoundInteractionReactorComponent::GetIsListening() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SoundInteractionReactorComponent", "GetIsListening");

	Params::SoundInteractionReactorComponent_GetIsListening Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LedgeClimbAbility.IsOnCooldown
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ULedgeClimbAbility::IsOnCooldown() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("LedgeClimbAbility", "IsOnCooldown");

	Params::LedgeClimbAbility_IsOnCooldown Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalizationHelper.EnumToUnrealCultureCode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECulture                                Culture                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ULocalizationHelper::EnumToUnrealCultureCode(ECulture Culture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelper", "EnumToUnrealCultureCode");

	Params::LocalizationHelper_EnumToUnrealCultureCode Parms{};

	Parms.Culture = Culture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalizationHelper.GetCurrentCultureAsEnum
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECulture                                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECulture ULocalizationHelper::GetCurrentCultureAsEnum()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelper", "GetCurrentCultureAsEnum");

	Params::LocalizationHelper_GetCurrentCultureAsEnum Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalizationHelper.GetLanguages
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// TMap<class FString, class FText>        ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

TMap<class FString, class FText> ULocalizationHelper::GetLanguages()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelper", "GetLanguages");

	Params::LocalizationHelper_GetLanguages Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalizationHelper.GetLocalizedLanguageNameFromCultureEnum
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECulture                                Culture                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText ULocalizationHelper::GetLocalizedLanguageNameFromCultureEnum(ECulture Culture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelper", "GetLocalizedLanguageNameFromCultureEnum");

	Params::LocalizationHelper_GetLocalizedLanguageNameFromCultureEnum Parms{};

	Parms.Culture = Culture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalizationHelper.GetTextWidth
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      Text                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FSlateFontInfo&            Font                                                   (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ULocalizationHelper::GetTextWidth(const class FText& Text, const struct FSlateFontInfo& Font)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelper", "GetTextWidth");

	Params::LocalizationHelper_GetTextWidth Parms{};

	Parms.Text = std::move(Text);
	Parms.Font = std::move(Font);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalizationHelper.IsCurrentCultureRTL
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ULocalizationHelper::IsCurrentCultureRTL()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelper", "IsCurrentCultureRTL");

	Params::LocalizationHelper_IsCurrentCultureRTL Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalizationHelper.UnrealCultureCodeToEnum
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FString&                    UnrealCode                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECulture                                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECulture ULocalizationHelper::UnrealCultureCodeToEnum(const class FString& UnrealCode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelper", "UnrealCultureCodeToEnum");

	Params::LocalizationHelper_UnrealCultureCodeToEnum Parms{};

	Parms.UnrealCode = std::move(UnrealCode);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalUserFunctionLibrary.GetCommonUserDebugString
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ULocalUserFunctionLibrary::GetCommonUserDebugString(const class UCommonUserInfo* UserInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalUserFunctionLibrary", "GetCommonUserDebugString");

	Params::LocalUserFunctionLibrary_GetCommonUserDebugString Parms{};

	Parms.UserInfo = UserInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.LocalUserFunctionLibrary.GetCommonUserNickname
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ULocalUserFunctionLibrary::GetCommonUserNickname(const class UCommonUserInfo* UserInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalUserFunctionLibrary", "GetCommonUserNickname");

	Params::LocalUserFunctionLibrary_GetCommonUserNickname Parms{};

	Parms.UserInfo = UserInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PlatformPresenceSubsystem.OnEndGame
// (Final, Native, Public, BlueprintCallable)

void UPlatformPresenceSubsystem::OnEndGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlatformPresenceSubsystem", "OnEndGame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlatformPresenceSubsystem.OnNewGame
// (Final, Native, Public, BlueprintCallable)

void UPlatformPresenceSubsystem::OnNewGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlatformPresenceSubsystem", "OnNewGame");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlatformPresenceSubsystem.StartActivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             activityId                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlatformPresenceSubsystem::StartActivity(class FName activityId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlatformPresenceSubsystem", "StartActivity");

	Params::PlatformPresenceSubsystem_StartActivity Parms{};

	Parms.activityId = activityId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.MaskUI.SessionSupportsBothPlayerMasks
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UMaskUI::SessionSupportsBothPlayerMasks(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MaskUI", "SessionSupportsBothPlayerMasks");

	Params::MaskUI_SessionSupportsBothPlayerMasks Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.MaskUI.CreateMaskEntryWidget
// (Event, Protected, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FDataTableRowHandle&       maskRowHandle                                          (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class UWidget*                          ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UWidget* UMaskUI::CreateMaskEntryWidget(const struct FDataTableRowHandle& maskRowHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MaskUI", "CreateMaskEntryWidget");

	Params::MaskUI_CreateMaskEntryWidget Parms{};

	Parms.maskRowHandle = std::move(maskRowHandle);

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.MaskUI.ReserveMaskToEquip
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AMaskPickup*                      maskToEquip                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmPlayerCharacter*         targetPlayer                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMaskUI::ReserveMaskToEquip(class AMaskPickup* maskToEquip, class AEverholmPlayerCharacter* targetPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MaskUI", "ReserveMaskToEquip");

	Params::MaskUI_ReserveMaskToEquip Parms{};

	Parms.maskToEquip = maskToEquip;
	Parms.targetPlayer = targetPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.NetInteractableComponent.EndInteraction
// (Final, Native, Public, BlueprintCallable)

void UNetInteractableComponent::EndInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetInteractableComponent", "EndInteraction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.NetInteractableComponent.EndPrepareInteraction
// (Final, Native, Public, BlueprintCallable)

void UNetInteractableComponent::EndPrepareInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetInteractableComponent", "EndPrepareInteraction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.NetInteractableComponent.RPC_ResumePairedInteract
// (Net, NetReliable, Native, Event, NetMulticast, Protected)

void UNetInteractableComponent::RPC_ResumePairedInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetInteractableComponent", "RPC_ResumePairedInteract");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.NetInteractableComponent.RPC_ServerPlayerBeginInteraction
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               interactor                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UNetInteractableComponent::RPC_ServerPlayerBeginInteraction(class AEverholmCharacter* interactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetInteractableComponent", "RPC_ServerPlayerBeginInteraction");

	Params::NetInteractableComponent_RPC_ServerPlayerBeginInteraction Parms{};

	Parms.interactor = interactor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.NetInteractableComponent.SetServerValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// uint8                                   valueKey                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAllowServerLocal                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UNetInteractableComponent::SetServerValue(uint8 valueKey, float Value, bool bAllowServerLocal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetInteractableComponent", "SetServerValue");

	Params::NetInteractableComponent_SetServerValue Parms{};

	Parms.valueKey = valueKey;
	Parms.Value = Value;
	Parms.bAllowServerLocal = bAllowServerLocal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.NetInteractableComponent.GetPairedInteractableComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UNetInteractableComponent*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNetInteractableComponent* UNetInteractableComponent::GetPairedInteractableComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetInteractableComponent", "GetPairedInteractableComponent");

	Params::NetInteractableComponent_GetPairedInteractableComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PauseMenuUI.SetPausingPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerState*                     pausingPlayerState                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPauseReason                            pauseReason                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPauseMenuUI::SetPausingPlayer(class APlayerState* pausingPlayerState, EPauseReason pauseReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PauseMenuUI", "SetPausingPlayer");

	Params::PauseMenuUI_SetPausingPlayer Parms{};

	Parms.pausingPlayerState = pausingPlayerState;
	Parms.pauseReason = pauseReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PhysicalControllerSubsystem.GetConnectedControllerPlayerPairs
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FControllerPlayerPair>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FControllerPlayerPair> UPhysicalControllerSubsystem::GetConnectedControllerPlayerPairs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "GetConnectedControllerPlayerPairs");

	Params::PhysicalControllerSubsystem_GetConnectedControllerPlayerPairs Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.GetPlayerControllerByControllerId
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ControllerId                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APlayerController* UPhysicalControllerSubsystem::GetPlayerControllerByControllerId(int32 ControllerId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "GetPlayerControllerByControllerId");

	Params::PhysicalControllerSubsystem_GetPlayerControllerByControllerId Parms{};

	Parms.ControllerId = ControllerId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.GetUserIndexForControllerId
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ControllerId                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhysicalControllerSubsystem::GetUserIndexForControllerId(int32 ControllerId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "GetUserIndexForControllerId");

	Params::PhysicalControllerSubsystem_GetUserIndexForControllerId Parms{};

	Parms.ControllerId = ControllerId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.OnUserInitializationCompleted
// (Final, Native, Protected)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UCommonUserInfo*            UserInfo                                               (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Error                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhysicalControllerSubsystem::OnUserInitializationCompleted(ELocalUserType localUserType, const class UCommonUserInfo* UserInfo, bool bSuccess, const class FString& Error)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "OnUserInitializationCompleted");

	Params::PhysicalControllerSubsystem_OnUserInitializationCompleted Parms{};

	Parms.localUserType = localUserType;
	Parms.UserInfo = UserInfo;
	Parms.bSuccess = bSuccess;
	Parms.Error = std::move(Error);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PhysicalControllerSubsystem.OnUserLogoutCompleted
// (Final, Native, Protected)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSuccess                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPhysicalControllerSubsystem::OnUserLogoutCompleted(ELocalUserType localUserType, bool bSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "OnUserLogoutCompleted");

	Params::PhysicalControllerSubsystem_OnUserLogoutCompleted Parms{};

	Parms.localUserType = localUserType;
	Parms.bSuccess = bSuccess;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PhysicalControllerSubsystem.TryUnsetInputDeviceForUser
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ELocalUserType                          User                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhysicalControllerSubsystem::TryUnsetInputDeviceForUser(ELocalUserType User)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "TryUnsetInputDeviceForUser");

	Params::PhysicalControllerSubsystem_TryUnsetInputDeviceForUser Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.AllowManualRemapPrimaryUser
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhysicalControllerSubsystem::AllowManualRemapPrimaryUser() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "AllowManualRemapPrimaryUser");

	Params::PhysicalControllerSubsystem_AllowManualRemapPrimaryUser Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.AllowManualRemapUser
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhysicalControllerSubsystem::AllowManualRemapUser(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "AllowManualRemapUser");

	Params::PhysicalControllerSubsystem_AllowManualRemapUser Parms{};

	Parms.localUserType = localUserType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.AreBothUsersMapped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhysicalControllerSubsystem::AreBothUsersMapped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "AreBothUsersMapped");

	Params::PhysicalControllerSubsystem_AreBothUsersMapped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.GetConnectedGamepadsCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UPhysicalControllerSubsystem::GetConnectedGamepadsCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "GetConnectedGamepadsCount");

	Params::PhysicalControllerSubsystem_GetConnectedGamepadsCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.GetInputDeviceId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInputDeviceId                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FInputDeviceId UPhysicalControllerSubsystem::GetInputDeviceId(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "GetInputDeviceId");

	Params::PhysicalControllerSubsystem_GetInputDeviceId Parms{};

	Parms.localUserType = localUserType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.GetNextUnmappedUser
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TOptional<ELocalUserType>               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TOptional<ELocalUserType> UPhysicalControllerSubsystem::GetNextUnmappedUser() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "GetNextUnmappedUser");

	Params::PhysicalControllerSubsystem_GetNextUnmappedUser Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.IsEitherUserMapped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhysicalControllerSubsystem::IsEitherUserMapped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "IsEitherUserMapped");

	Params::PhysicalControllerSubsystem_IsEitherUserMapped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.IsKeyboardUser
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          User                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhysicalControllerSubsystem::IsKeyboardUser(ELocalUserType User) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "IsKeyboardUser");

	Params::PhysicalControllerSubsystem_IsKeyboardUser Parms{};

	Parms.User = User;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PhysicalControllerSubsystem.IsUserMappedToInputDevice
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPhysicalControllerSubsystem::IsUserMappedToInputDevice(ELocalUserType localUserType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalControllerSubsystem", "IsUserMappedToInputDevice");

	Params::PhysicalControllerSubsystem_IsUserMappedToInputDevice Parms{};

	Parms.localUserType = localUserType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PickupAbilityComponent.Multicast_StartPickingUp
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// EPickupAbilityActivation                activationType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPickupAbilityComponent::Multicast_StartPickingUp(EPickupAbilityActivation activationType, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupAbilityComponent", "Multicast_StartPickingUp");

	Params::PickupAbilityComponent_Multicast_StartPickingUp Parms{};

	Parms.activationType = activationType;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupAbilityComponent.OnAnimTransitionFinished
// (Final, Native, Private)
// Parameters:
// EPickupState                            transitionState                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPickupAbilityComponent::OnAnimTransitionFinished(EPickupState transitionState, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupAbilityComponent", "OnAnimTransitionFinished");

	Params::PickupAbilityComponent_OnAnimTransitionFinished Parms{};

	Parms.transitionState = transitionState;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupAbilityComponent.OnPickupReleased
// (Final, Native, Private)

void UPickupAbilityComponent::OnPickupReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupAbilityComponent", "OnPickupReleased");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupAbilityComponent.Server_StartPickingUp
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// EPickupAbilityActivation                activationType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPickupAbilityComponent::Server_StartPickingUp(EPickupAbilityActivation activationType, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupAbilityComponent", "Server_StartPickingUp");

	Params::PickupAbilityComponent_Server_StartPickingUp Parms{};

	Parms.activationType = activationType;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupAlignComponent.AlignPickupWithOffset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InteractingActor                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  AttachTo                                               (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPickupAlignComponent::AlignPickupWithOffset(class AActor* InteractingActor, class USceneComponent* AttachTo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupAlignComponent", "AlignPickupWithOffset");

	Params::PickupAlignComponent_AlignPickupWithOffset Parms{};

	Parms.InteractingActor = InteractingActor;
	Parms.AttachTo = AttachTo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PickupAlignComponent.CollectBackPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InteractingActor                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPickupAlignComponent::CollectBackPickup(class AActor* InteractingActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PickupAlignComponent", "CollectBackPickup");

	Params::PickupAlignComponent_CollectBackPickup Parms{};

	Parms.InteractingActor = InteractingActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PigletScenarioActor.OnRep_PigletQuestState
// (Final, Native, Protected)
// Parameters:
// EPigQuestState                          previousState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APigletScenarioActor::OnRep_PigletQuestState(EPigQuestState previousState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigletScenarioActor", "OnRep_PigletQuestState");

	Params::PigletScenarioActor_OnRep_PigletQuestState Parms{};

	Parms.previousState = previousState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PigletScenarioActor.PigQuestStateUpdate
// (Event, Protected, BlueprintEvent)
// Parameters:
// EPigQuestState                          NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPigQuestState                          previousState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APigletScenarioActor::PigQuestStateUpdate(EPigQuestState NewState, EPigQuestState previousState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigletScenarioActor", "PigQuestStateUpdate");

	Params::PigletScenarioActor_PigQuestStateUpdate Parms{};

	Parms.NewState = NewState;
	Parms.previousState = previousState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PigletScenarioActor.SetQuestState
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EPigQuestState                          NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void APigletScenarioActor::SetQuestState(EPigQuestState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PigletScenarioActor", "SetQuestState");

	Params::PigletScenarioActor_SetQuestState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlayerActionsAnalyzer.OnLedgeClimbingChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bIsEnabled                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ledgeHeightAfterAlignment                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerActionsAnalyzer::OnLedgeClimbingChanged(bool bIsEnabled, float ledgeHeightAfterAlignment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerActionsAnalyzer", "OnLedgeClimbingChanged");

	Params::PlayerActionsAnalyzer_OnLedgeClimbingChanged Parms{};

	Parms.bIsEnabled = bIsEnabled;
	Parms.ledgeHeightAfterAlignment = ledgeHeightAfterAlignment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlayerActionsAnalyzer.OnMovementModeChanged
// (Final, Native, Private)
// Parameters:
// class UEverholmCharacterMovementComponent*MovementComponent                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmCharacterMovementMode          PreviousMovementMode                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerActionsAnalyzer::OnMovementModeChanged(class UEverholmCharacterMovementComponent* MovementComponent, EEverholmCharacterMovementMode PreviousMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerActionsAnalyzer", "OnMovementModeChanged");

	Params::PlayerActionsAnalyzer_OnMovementModeChanged Parms{};

	Parms.MovementComponent = MovementComponent;
	Parms.PreviousMovementMode = PreviousMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlayerActionsAnalyzer.OnSurfaceClimbingChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bIsEnabled                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerActionsAnalyzer::OnSurfaceClimbingChanged(bool bIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerActionsAnalyzer", "OnSurfaceClimbingChanged");

	Params::PlayerActionsAnalyzer_OnSurfaceClimbingChanged Parms{};

	Parms.bIsEnabled = bIsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlayerActionsAnalyzer.OnTargetActorUpdated
// (Final, Native, Private)
// Parameters:
// class UChalkboardWrapper*               Chalkboard                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FChalkboardSectionKey&     sectionKey                                             (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerActionsAnalyzer::OnTargetActorUpdated(class UChalkboardWrapper* Chalkboard, const struct FChalkboardSectionKey& sectionKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerActionsAnalyzer", "OnTargetActorUpdated");

	Params::PlayerActionsAnalyzer_OnTargetActorUpdated Parms{};

	Parms.Chalkboard = Chalkboard;
	Parms.sectionKey = std::move(sectionKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PlayerInteractionWidget.OnInteractionStarted
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerInteractionWidget::OnInteractionStarted(class APawn* Initiator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInteractionWidget", "OnInteractionStarted");

	Params::PlayerInteractionWidget_OnInteractionStarted Parms{};

	Parms.Initiator = Initiator;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PlayerInteractionWidget.SetIcon
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class UTexture2D*                 iconObject                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerInteractionWidget::SetIcon(const class UTexture2D* iconObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInteractionWidget", "SetIcon");

	Params::PlayerInteractionWidget_SetIcon Parms{};

	Parms.iconObject = iconObject;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PlayerInteractionWidget.SetIconAngle
// (Event, Protected, BlueprintEvent)
// Parameters:
// const float                             Angle                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerInteractionWidget::SetIconAngle(const float Angle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInteractionWidget", "SetIconAngle");

	Params::PlayerInteractionWidget_SetIconAngle Parms{};

	Parms.Angle = Angle;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PlayerInteractionWidget.SetIconTranslation
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector2D&                 Translation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerInteractionWidget::SetIconTranslation(const struct FVector2D& Translation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInteractionWidget", "SetIconTranslation");

	Params::PlayerInteractionWidget_SetIconTranslation Parms{};

	Parms.Translation = std::move(Translation);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.PlayerInteractionWidget.GetCurrentInteractionName
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UPlayerInteractionWidget::GetCurrentInteractionName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInteractionWidget", "GetCurrentInteractionName");

	Params::PlayerInteractionWidget_GetCurrentInteractionName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PlayerInteractionWidget.GetOtherPip
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPlayerInteractionWidget*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPlayerInteractionWidget* UPlayerInteractionWidget::GetOtherPip() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerInteractionWidget", "GetOtherPip");

	Params::PlayerInteractionWidget_GetOtherPip Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.PlayMontageInteractionComponent.HasPlayableMontage
// (Event, Protected, BlueprintEvent, Const)
// Parameters:
// class APawn*                            Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayMontageInteractionComponent::HasPlayableMontage(class APawn* Initiator) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayMontageInteractionComponent", "HasPlayableMontage");

	Params::PlayMontageInteractionComponent_HasPlayableMontage Parms{};

	Parms.Initiator = Initiator;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Everholm.PlaySessionLauncher.OnSessionManagerNetworkFailure
// (Final, Native, Private)
// Parameters:
// ENetworkSessionManagerFailType          FailType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlaySessionLauncher::OnSessionManagerNetworkFailure(ENetworkSessionManagerFailType FailType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlaySessionLauncher", "OnSessionManagerNetworkFailure");

	Params::PlaySessionLauncher_OnSessionManagerNetworkFailure Parms{};

	Parms.FailType = FailType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PushBoatInteractionComponent.InteractStartEvent
// (Final, Native, Protected)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPushBoatInteractionComponent::InteractStartEvent(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PushBoatInteractionComponent", "InteractStartEvent");

	Params::PushBoatInteractionComponent_InteractStartEvent Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PushBoatInteractionComponent.OnEndingInteraction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bAborted                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPushBoatInteractionComponent::OnEndingInteraction(bool bAborted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PushBoatInteractionComponent", "OnEndingInteraction");

	Params::PushBoatInteractionComponent_OnEndingInteraction Parms{};

	Parms.bAborted = bAborted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.PushBoatInteractionComponent.OnStartedPushing
// (Final, Native, Public, BlueprintCallable)

void UPushBoatInteractionComponent::OnStartedPushing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PushBoatInteractionComponent", "OnStartedPushing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RecordActorTransformFunctionLibrary.DrawDebugRecording
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRecordingResult&          Recording                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URecordActorTransformFunctionLibrary::DrawDebugRecording(class UObject* WorldContextObject, const struct FRecordingResult& Recording, float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RecordActorTransformFunctionLibrary", "DrawDebugRecording");

	Params::RecordActorTransformFunctionLibrary_DrawDebugRecording Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Recording = std::move(Recording);
	Parms.Duration = Duration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RecordActorTransformFunctionLibrary.LoadRecordingFromFileExplicitPath
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FRecordingResult*                Recording                                              (Parm, OutParm, NativeAccessSpecifierPublic)
// const class FString&                    saveFilePath                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString URecordActorTransformFunctionLibrary::LoadRecordingFromFileExplicitPath(struct FRecordingResult* Recording, const class FString& saveFilePath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RecordActorTransformFunctionLibrary", "LoadRecordingFromFileExplicitPath");

	Params::RecordActorTransformFunctionLibrary_LoadRecordingFromFileExplicitPath Parms{};

	Parms.saveFilePath = std::move(saveFilePath);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Recording != nullptr)
		*Recording = std::move(Parms.Recording);

	return Parms.ReturnValue;
}


// Function Everholm.RecordActorTransformFunctionLibrary.LoadRecordingFromFileFromSavedDirectory
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FRecordingResult*                Recording                                              (Parm, OutParm, NativeAccessSpecifierPublic)
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString URecordActorTransformFunctionLibrary::LoadRecordingFromFileFromSavedDirectory(struct FRecordingResult* Recording, const class FString& Filename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RecordActorTransformFunctionLibrary", "LoadRecordingFromFileFromSavedDirectory");

	Params::RecordActorTransformFunctionLibrary_LoadRecordingFromFileFromSavedDirectory Parms{};

	Parms.Filename = std::move(Filename);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Recording != nullptr)
		*Recording = std::move(Parms.Recording);

	return Parms.ReturnValue;
}


// Function Everholm.RecordActorTransformFunctionLibrary.SaveRecordingToFileExplicitDirectory
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FRecordingResult&          Recording                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FString&                    SaveDirectory                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransformRecordingResult        ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FTransformRecordingResult URecordActorTransformFunctionLibrary::SaveRecordingToFileExplicitDirectory(const struct FRecordingResult& Recording, const class FString& SaveDirectory, const class FString& Filename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RecordActorTransformFunctionLibrary", "SaveRecordingToFileExplicitDirectory");

	Params::RecordActorTransformFunctionLibrary_SaveRecordingToFileExplicitDirectory Parms{};

	Parms.Recording = std::move(Recording);
	Parms.SaveDirectory = std::move(SaveDirectory);
	Parms.Filename = std::move(Filename);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RecordActorTransformFunctionLibrary.SaveRecordingToFileInSavedDir
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FRecordingResult&          Recording                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FString&                    Filename                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransformRecordingResult        ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FTransformRecordingResult URecordActorTransformFunctionLibrary::SaveRecordingToFileInSavedDir(const struct FRecordingResult& Recording, const class FString& Filename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RecordActorTransformFunctionLibrary", "SaveRecordingToFileInSavedDir");

	Params::RecordActorTransformFunctionLibrary_SaveRecordingToFileInSavedDir Parms{};

	Parms.Recording = std::move(Recording);
	Parms.Filename = std::move(Filename);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RotateToTargetAction.GetLookAtRotation
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator URotateToTargetAction::GetLookAtRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RotateToTargetAction", "GetLookAtRotation");

	Params::RotateToTargetAction_GetLookAtRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.RubberBandingManager.ActivateRubberBanding
// (Native, Public, BlueprintCallable)

void ARubberBandingManager::ActivateRubberBanding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RubberBandingManager", "ActivateRubberBanding");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RubberBandingManager.DeactivateRubberBanding
// (Native, Public, BlueprintCallable)

void ARubberBandingManager::DeactivateRubberBanding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RubberBandingManager", "DeactivateRubberBanding");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RubberBandingManager.OnAISpawned
// (Final, Native, Protected)
// Parameters:
// class AAISpawner*                       Spawner                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            NewPawn                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARubberBandingManager::OnAISpawned(class AAISpawner* Spawner, class APawn* NewPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RubberBandingManager", "OnAISpawned");

	Params::RubberBandingManager_OnAISpawned Parms{};

	Parms.Spawner = Spawner;
	Parms.NewPawn = NewPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RubberBandingManager.OnLevelSequenceStarted
// (Final, Native, Protected)

void ARubberBandingManager::OnLevelSequenceStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RubberBandingManager", "OnLevelSequenceStarted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.RubberBandingManager.OnLevelSequenceStopped
// (Final, Native, Protected)

void ARubberBandingManager::OnLevelSequenceStopped()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RubberBandingManager", "OnLevelSequenceStopped");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveComponent.RegisterToSaveSystem
// (Final, Native, Public, BlueprintCallable)

void USaveComponent::RegisterToSaveSystem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SaveComponent", "RegisterToSaveSystem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.ClearSaveData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResetUserAndSlot                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USaveSystemBlueprintHelperLibrary::ClearSaveData(class UObject* WorldContextObject, bool bResetUserAndSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "ClearSaveData");

	Params::SaveSystemBlueprintHelperLibrary_ClearSaveData Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bResetUserAndSlot = bResetUserAndSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.ClearSaveDataCategories
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<ESaveDataCategory>&        Categories                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void USaveSystemBlueprintHelperLibrary::ClearSaveDataCategories(class UObject* WorldContextObject, const TArray<ESaveDataCategory>& Categories)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "ClearSaveDataCategories");

	Params::SaveSystemBlueprintHelperLibrary_ClearSaveDataCategories Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Categories = std::move(Categories);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemLoadCategoriesFromDiskProxyObject
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<ESaveDataCategory>&        Categories                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class USaveSystemLoadCategoriesFromDiskBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemLoadCategoriesFromDiskBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemLoadCategoriesFromDiskProxyObject(class UObject* WorldContextObject, const TArray<ESaveDataCategory>& Categories)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemLoadCategoriesFromDiskProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemLoadCategoriesFromDiskProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Categories = std::move(Categories);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemLoadFromDiskProxyObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USaveSystemLoadFromDiskBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemLoadFromDiskBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemLoadFromDiskProxyObject(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemLoadFromDiskProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemLoadFromDiskProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemRemoveCategoriesFromDiskProxyObject
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<ESaveDataCategory>&        Categories                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class USaveSystemRemoveCategoriesFromDiskBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemRemoveCategoriesFromDiskBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemRemoveCategoriesFromDiskProxyObject(class UObject* WorldContextObject, const TArray<ESaveDataCategory>& Categories)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemRemoveCategoriesFromDiskProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemRemoveCategoriesFromDiskProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Categories = std::move(Categories);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemRemoveFromDiskProxyObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USaveSystemRemoveFromDiskBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemRemoveFromDiskBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemRemoveFromDiskProxyObject(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemRemoveFromDiskProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemRemoveFromDiskProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemSaveCategoriesToDiskProxyObject
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<ESaveDataCategory>&        Categories                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class USaveSystemSaveCategoriesToDiskBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemSaveCategoriesToDiskBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemSaveCategoriesToDiskProxyObject(class UObject* WorldContextObject, const TArray<ESaveDataCategory>& Categories)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemSaveCategoriesToDiskProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemSaveCategoriesToDiskProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Categories = std::move(Categories);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemSaveToDiskProxyObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USaveSystemSaveToDiskBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemSaveToDiskBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemSaveToDiskProxyObject(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemSaveToDiskProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemSaveToDiskProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemSetActiveSlotIndexProxyObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USaveSystemSetActiveSlotIndexBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemSetActiveSlotIndexBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemSetActiveSlotIndexProxyObject(class UObject* WorldContextObject, int32 SlotIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemSetActiveSlotIndexProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemSetActiveSlotIndexProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SlotIndex = SlotIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.CreateSaveSystemSetActiveUserIndexProxyObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USaveSystemSetActiveUserIndexBlueprintProxy*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USaveSystemSetActiveUserIndexBlueprintProxy* USaveSystemBlueprintHelperLibrary::CreateSaveSystemSetActiveUserIndexProxyObject(class UObject* WorldContextObject, int32 UserIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "CreateSaveSystemSetActiveUserIndexProxyObject");

	Params::SaveSystemBlueprintHelperLibrary_CreateSaveSystemSetActiveUserIndexProxyObject Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.UserIndex = UserIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.GetActiveSlotIndex
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 USaveSystemBlueprintHelperLibrary::GetActiveSlotIndex(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "GetActiveSlotIndex");

	Params::SaveSystemBlueprintHelperLibrary_GetActiveSlotIndex Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.GetActiveUserIndex
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 USaveSystemBlueprintHelperLibrary::GetActiveUserIndex(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "GetActiveUserIndex");

	Params::SaveSystemBlueprintHelperLibrary_GetActiveUserIndex Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.LoadAllObjects
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USaveSystemBlueprintHelperLibrary::LoadAllObjects(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "LoadAllObjects");

	Params::SaveSystemBlueprintHelperLibrary_LoadAllObjects Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.LoadCategories
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<ESaveDataCategory>&        Categories                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void USaveSystemBlueprintHelperLibrary::LoadCategories(class UObject* WorldContextObject, const TArray<ESaveDataCategory>& Categories)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "LoadCategories");

	Params::SaveSystemBlueprintHelperLibrary_LoadCategories Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Categories = std::move(Categories);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.RegisterSavableObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          savableObject                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USaveSystemBlueprintHelperLibrary::RegisterSavableObject(class UObject* WorldContextObject, class UObject* savableObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "RegisterSavableObject");

	Params::SaveSystemBlueprintHelperLibrary_RegisterSavableObject Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.savableObject = savableObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.SaveCategories
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<ESaveDataCategory>&        Categories                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void USaveSystemBlueprintHelperLibrary::SaveCategories(class UObject* WorldContextObject, const TArray<ESaveDataCategory>& Categories)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "SaveCategories");

	Params::SaveSystemBlueprintHelperLibrary_SaveCategories Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Categories = std::move(Categories);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SaveSystemBlueprintHelperLibrary.SaveObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          savableObject                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USaveSystemBlueprintHelperLibrary::SaveObject(class UObject* WorldContextObject, class UObject* savableObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("SaveSystemBlueprintHelperLibrary", "SaveObject");

	Params::SaveSystemBlueprintHelperLibrary_SaveObject Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.savableObject = savableObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SelectIndexComponent.SelectIndex
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 USelectIndexComponent::SelectIndex(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SelectIndexComponent", "SelectIndex");

	Params::SelectIndexComponent_SelectIndex Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SheepSkinMovementComponent.SetBoyInput
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   boyInput                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USheepSkinMovementComponent::SetBoyInput(const struct FVector& boyInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinMovementComponent", "SetBoyInput");

	Params::SheepSkinMovementComponent_SetBoyInput Parms{};

	Parms.boyInput = std::move(boyInput);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SheepSkinMovementComponent.SetGirlInput
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   girlInput                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USheepSkinMovementComponent::SetGirlInput(const struct FVector& girlInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SheepSkinMovementComponent", "SetGirlInput");

	Params::SheepSkinMovementComponent_SetGirlInput Parms{};

	Parms.girlInput = std::move(girlInput);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SignalActivationGroupVolume.HIP_SetActivationGroupState
// (Final, Native, Public)
// Parameters:
// bool                                    bIsActive                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASignalActivationGroupVolume::HIP_SetActivationGroupState(bool bIsActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SignalActivationGroupVolume", "HIP_SetActivationGroupState");

	Params::SignalActivationGroupVolume_HIP_SetActivationGroupState Parms{};

	Parms.bIsActive = bIsActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SlideAbilityActivation.OnMovementModeChanged
// (Final, Native, Private)
// Parameters:
// class UEverholmCharacterMovementComponent*MovementComponent                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmCharacterMovementMode          PreviousMovementMode                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USlideAbilityActivation::OnMovementModeChanged(class UEverholmCharacterMovementComponent* MovementComponent, EEverholmCharacterMovementMode PreviousMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlideAbilityActivation", "OnMovementModeChanged");

	Params::SlideAbilityActivation_OnMovementModeChanged Parms{};

	Parms.MovementComponent = MovementComponent;
	Parms.PreviousMovementMode = PreviousMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SlotInteractionComponent.BP_HandlePickupInserted
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      insertedPickup_0                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USlotInteractionComponent::BP_HandlePickupInserted(class AEverholmCharacter* Initiator, class APickupBase* insertedPickup_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "BP_HandlePickupInserted");

	Params::SlotInteractionComponent_BP_HandlePickupInserted Parms{};

	Parms.Initiator = Initiator;
	Parms.insertedPickup_0 = insertedPickup_0;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.SlotInteractionComponent.BP_HandlePickupRemoved
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      removedPickup                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USlotInteractionComponent::BP_HandlePickupRemoved(class AEverholmCharacter* Initiator, class APickupBase* removedPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "BP_HandlePickupRemoved");

	Params::SlotInteractionComponent_BP_HandlePickupRemoved Parms{};

	Parms.Initiator = Initiator;
	Parms.removedPickup = removedPickup;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.SlotInteractionComponent.EjectInsertedPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bOverrideNoRemove                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* USlotInteractionComponent::EjectInsertedPickup(bool bOverrideNoRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "EjectInsertedPickup");

	Params::SlotInteractionComponent_EjectInsertedPickup Parms{};

	Parms.bOverrideNoRemove = bOverrideNoRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SlotInteractionComponent.HandlePickupInserted
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USlotInteractionComponent*        Slot                                                   (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInserted                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USlotInteractionComponent::HandlePickupInserted(class AEverholmCharacter* Initiator, class APickupBase* pickup, class USlotInteractionComponent* Slot, bool bInserted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "HandlePickupInserted");

	Params::SlotInteractionComponent_HandlePickupInserted Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;
	Parms.Slot = Slot;
	Parms.bInserted = bInserted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SlotInteractionComponent.HandlePickupRemoved
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Initiator                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APickupBase*                      pickup                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USlotInteractionComponent::HandlePickupRemoved(class AEverholmCharacter* Initiator, class APickupBase* pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "HandlePickupRemoved");

	Params::SlotInteractionComponent_HandlePickupRemoved Parms{};

	Parms.Initiator = Initiator;
	Parms.pickup = pickup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SlotInteractionComponent.HIP_CheckIfSlotted
// (Final, Native, Private)

void USlotInteractionComponent::HIP_CheckIfSlotted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "HIP_CheckIfSlotted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SlotInteractionComponent.HOP_CheckIfSlotted
// (Final, Native, Private)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USlotInteractionComponent::HOP_CheckIfSlotted(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "HOP_CheckIfSlotted");

	Params::SlotInteractionComponent_HOP_CheckIfSlotted Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SlotInteractionComponent.HOP_Slotted
// (Final, Native, Private)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsInitialization                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USlotInteractionComponent::HOP_Slotted(bool Value, bool bIsInitialization)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "HOP_Slotted");

	Params::SlotInteractionComponent_HOP_Slotted Parms{};

	Parms.Value = Value;
	Parms.bIsInitialization = bIsInitialization;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SlotInteractionComponent.GetInsertedPickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APickupBase*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class APickupBase* USlotInteractionComponent::GetInsertedPickup() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "GetInsertedPickup");

	Params::SlotInteractionComponent_GetInsertedPickup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SlotInteractionComponent.GetInsertTransitionSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAbstractEnum              ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FAbstractEnum USlotInteractionComponent::GetInsertTransitionSlot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "GetInsertTransitionSlot");

	Params::SlotInteractionComponent_GetInsertTransitionSlot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SlotInteractionComponent.GetRemoveTransitionSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAbstractEnum              ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FAbstractEnum USlotInteractionComponent::GetRemoveTransitionSlot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SlotInteractionComponent", "GetRemoveTransitionSlot");

	Params::SlotInteractionComponent_GetRemoveTransitionSlot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SmoothMeshMoverComponent.ResetLocationAndRotation
// (Final, Native, Public, BlueprintCallable)

void USmoothMeshMoverComponent::ResetLocationAndRotation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothMeshMoverComponent", "ResetLocationAndRotation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothMeshMoverComponent.SetRotationSmoothing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USmoothMeshMoverComponent::SetRotationSmoothing(bool State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothMeshMoverComponent", "SetRotationSmoothing");

	Params::SmoothMeshMoverComponent_SetRotationSmoothing Parms{};

	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothMeshMoverComponent.SetTranslationSmoothing
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USmoothMeshMoverComponent::SetTranslationSmoothing(bool State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothMeshMoverComponent", "SetTranslationSmoothing");

	Params::SmoothMeshMoverComponent_SetTranslationSmoothing Parms{};

	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SmoothMeshMoverComponent.GetLastRotationDelta
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FRotator                   ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

const struct FRotator USmoothMeshMoverComponent::GetLastRotationDelta() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothMeshMoverComponent", "GetLastRotationDelta");

	Params::SmoothMeshMoverComponent_GetLastRotationDelta Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SmoothMeshMoverComponent.GetLastTranslationDelta
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector USmoothMeshMoverComponent::GetLastTranslationDelta() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SmoothMeshMoverComponent", "GetLastTranslationDelta");

	Params::SmoothMeshMoverComponent_GetLastTranslationDelta Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ScalarSmoothRepSceneComponent.MC_ScalarServerFrame
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FScalarSmoothRepSceneComponentState&State                                                  (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UScalarSmoothRepSceneComponent::MC_ScalarServerFrame(const struct FScalarSmoothRepSceneComponentState& State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ScalarSmoothRepSceneComponent", "MC_ScalarServerFrame");

	Params::ScalarSmoothRepSceneComponent_MC_ScalarServerFrame Parms{};

	Parms.State = std::move(State);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SnifferAnimationRelayComponent.GetSnifferAnimData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAnimSnifferData           ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FAnimSnifferData USnifferAnimationRelayComponent::GetSnifferAnimData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SnifferAnimationRelayComponent", "GetSnifferAnimData");

	Params::SnifferAnimationRelayComponent_GetSnifferAnimData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SnifferAnimInstance.GetSnifferOverrideAnimationSet
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// class UAnimationSet*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimationSet* USnifferAnimInstance::GetSnifferOverrideAnimationSet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SnifferAnimInstance", "GetSnifferOverrideAnimationSet");

	Params::SnifferAnimInstance_GetSnifferOverrideAnimationSet Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SnifferAnimInstance.OnMontageEndedEvent
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    interrupted                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USnifferAnimInstance::OnMontageEndedEvent(class UAnimMontage* Montage, bool interrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SnifferAnimInstance", "OnMontageEndedEvent");

	Params::SnifferAnimInstance_OnMontageEndedEvent Parms{};

	Parms.Montage = Montage;
	Parms.interrupted = interrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SnifferAnimInstance.OnMovementModeChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const ESnifferMovementMode              NewMovementMode                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ESnifferMovementMode              PreviousMovementMode                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              skippedTransitionAnim                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USnifferAnimInstance::OnMovementModeChanged(const ESnifferMovementMode NewMovementMode, const ESnifferMovementMode PreviousMovementMode, const bool skippedTransitionAnim)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SnifferAnimInstance", "OnMovementModeChanged");

	Params::SnifferAnimInstance_OnMovementModeChanged Parms{};

	Parms.NewMovementMode = NewMovementMode;
	Parms.PreviousMovementMode = PreviousMovementMode;
	Parms.skippedTransitionAnim = skippedTransitionAnim;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.SnifferAnimInstance.OnTransitionBlendedIn
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USnifferAnimInstance::OnTransitionBlendedIn(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SnifferAnimInstance", "OnTransitionBlendedIn");

	Params::SnifferAnimInstance_OnTransitionBlendedIn Parms{};

	Parms.Montage = Montage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SnifferAnimInstance.GetAlertTransitionAnimByAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             Angle                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* USnifferAnimInstance::GetAlertTransitionAnimByAngle(const float Angle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SnifferAnimInstance", "GetAlertTransitionAnimByAngle");

	Params::SnifferAnimInstance_GetAlertTransitionAnimByAngle Parms{};

	Parms.Angle = Angle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SnifferAnimInstance.GetDeltaYawToClosestTarget
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const bool                              onlyConsiderClosestActualTarget                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              returnZeroIfNoCurrentTargetExists                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float USnifferAnimInstance::GetDeltaYawToClosestTarget(const bool onlyConsiderClosestActualTarget, const bool returnZeroIfNoCurrentTargetExists) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SnifferAnimInstance", "GetDeltaYawToClosestTarget");

	Params::SnifferAnimInstance_GetDeltaYawToClosestTarget Parms{};

	Parms.onlyConsiderClosestActualTarget = onlyConsiderClosestActualTarget;
	Parms.returnZeroIfNoCurrentTargetExists = returnZeroIfNoCurrentTargetExists;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SniperSubsystem.RegisterTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USniperTargetComponent*           Target                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USniperSubsystem::RegisterTarget(class USniperTargetComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SniperSubsystem", "RegisterTarget");

	Params::SniperSubsystem_RegisterTarget Parms{};

	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SniperSubsystem.UnregisterTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USniperTargetComponent*           Target                                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USniperSubsystem::UnregisterTarget(class USniperTargetComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SniperSubsystem", "UnregisterTarget");

	Params::SniperSubsystem_UnregisterTarget Parms{};

	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SniperSubsystem.GetTargets
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> USniperSubsystem::GetTargets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SniperSubsystem", "GetTargets");

	Params::SniperSubsystem_GetTargets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SpiderKidAnimInstance.GetSpiderkidOverrideAnimationSet
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// const ESpiderkidIlluminationState       illuminationState                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimationSet*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimationSet* USpiderKidAnimInstance::GetSpiderkidOverrideAnimationSet(const ESpiderkidIlluminationState illuminationState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SpiderKidAnimInstance", "GetSpiderkidOverrideAnimationSet");

	Params::SpiderKidAnimInstance_GetSpiderkidOverrideAnimationSet Parms{};

	Parms.illuminationState = illuminationState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SpiderKidAnimInstance.OnLightReactAnimBlendedIn
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USpiderKidAnimInstance::OnLightReactAnimBlendedIn(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SpiderKidAnimInstance", "OnLightReactAnimBlendedIn");

	Params::SpiderKidAnimInstance_OnLightReactAnimBlendedIn Parms{};

	Parms.Montage = Montage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SpiderKidAnimInstance.OnLightReactAnimEnded
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USpiderKidAnimInstance::OnLightReactAnimEnded(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SpiderKidAnimInstance", "OnLightReactAnimEnded");

	Params::SpiderKidAnimInstance_OnLightReactAnimEnded Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SpiralWhaleEyeEncounter.OnRep_SpiralWhaleQuestState
// (Final, Native, Protected)
// Parameters:
// ESpiralWhaleQuestState                  previousState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASpiralWhaleEyeEncounter::OnRep_SpiralWhaleQuestState(ESpiralWhaleQuestState previousState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SpiralWhaleEyeEncounter", "OnRep_SpiralWhaleQuestState");

	Params::SpiralWhaleEyeEncounter_OnRep_SpiralWhaleQuestState Parms{};

	Parms.previousState = previousState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SpiralWhaleEyeEncounter.SetQuestState
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// ESpiralWhaleQuestState                  NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASpiralWhaleEyeEncounter::SetQuestState(ESpiralWhaleQuestState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SpiralWhaleEyeEncounter", "SetQuestState");

	Params::SpiralWhaleEyeEncounter_SetQuestState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SpiralWhaleEyeEncounter.SpiralWhaleQuestStateUpdate
// (Event, Protected, BlueprintEvent)
// Parameters:
// ESpiralWhaleQuestState                  NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ESpiralWhaleQuestState                  previousState                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASpiralWhaleEyeEncounter::SpiralWhaleQuestStateUpdate(ESpiralWhaleQuestState NewState, ESpiralWhaleQuestState previousState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SpiralWhaleEyeEncounter", "SpiralWhaleQuestStateUpdate");

	Params::SpiralWhaleEyeEncounter_SpiralWhaleQuestStateUpdate Parms{};

	Parms.NewState = NewState;
	Parms.previousState = previousState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.SplineCameraHint.DebugSplines
// (Native, Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   CameraHintLookTarget_0                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ASplineCameraHint::DebugSplines(const struct FVector& CameraHintLookTarget_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineCameraHint", "DebugSplines");

	Params::SplineCameraHint_DebugSplines Parms{};

	Parms.CameraHintLookTarget_0 = std::move(CameraHintLookTarget_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SplineCameraHint.GetCameraAimSpline
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class USplineComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USplineComponent* ASplineCameraHint::GetCameraAimSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineCameraHint", "GetCameraAimSpline");

	Params::SplineCameraHint_GetCameraAimSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SplineCameraHint.GetCameraSpline
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class USplineComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USplineComponent* ASplineCameraHint::GetCameraSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineCameraHint", "GetCameraSpline");

	Params::SplineCameraHint_GetCameraSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SplineCameraHint.GetPlayerSpline
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class USplineComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USplineComponent* ASplineCameraHint::GetPlayerSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineCameraHint", "GetPlayerSpline");

	Params::SplineCameraHint_GetPlayerSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SplineCameraHint.MapPlayerSplineDistanceToOtherSplineDistance
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// double                                  distanceAlongPlayerSpline                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<double>&                   splineDistances                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class USplineComponent*           otherSpline                                            (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              DebugColor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ASplineCameraHint::MapPlayerSplineDistanceToOtherSplineDistance(double distanceAlongPlayerSpline, const TArray<double>& splineDistances, const class USplineComponent* otherSpline, const struct FLinearColor& DebugColor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SplineCameraHint", "MapPlayerSplineDistanceToOtherSplineDistance");

	Params::SplineCameraHint_MapPlayerSplineDistanceToOtherSplineDistance Parms{};

	Parms.distanceAlongPlayerSpline = distanceAlongPlayerSpline;
	Parms.splineDistances = std::move(splineDistances);
	Parms.otherSpline = otherSpline;
	Parms.DebugColor = std::move(DebugColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.StationaryCameraSphereHint.DebugStationaryCameraHint
// (Native, Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   FocalPoint                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   lookTarget                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStationaryCameraSphereHint::DebugStationaryCameraHint(const struct FVector& FocalPoint, const struct FVector& lookTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StationaryCameraSphereHint", "DebugStationaryCameraHint");

	Params::StationaryCameraSphereHint_DebugStationaryCameraHint Parms{};

	Parms.FocalPoint = std::move(FocalPoint);
	Parms.lookTarget = std::move(lookTarget);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.StationaryCameraSphereHint.EvaluateCameraLookInfo
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   FocalPoint                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         cameraLocationTarget_0                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        cameraRotationTarget_0                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector*                         lookTarget                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStationaryCameraSphereHint::EvaluateCameraLookInfo(const struct FVector& FocalPoint, struct FVector* cameraLocationTarget_0, struct FRotator* cameraRotationTarget_0, struct FVector* lookTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StationaryCameraSphereHint", "EvaluateCameraLookInfo");

	Params::StationaryCameraSphereHint_EvaluateCameraLookInfo Parms{};

	Parms.FocalPoint = std::move(FocalPoint);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (cameraLocationTarget_0 != nullptr)
		*cameraLocationTarget_0 = std::move(Parms.cameraLocationTarget_0);

	if (cameraRotationTarget_0 != nullptr)
		*cameraRotationTarget_0 = std::move(Parms.cameraRotationTarget_0);

	if (lookTarget != nullptr)
		*lookTarget = std::move(Parms.lookTarget);
}


// Function Everholm.SubtitleSubsystem.ShowSubtitle
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      Text                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const double                            Duration                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USubtitleSubsystem::ShowSubtitle(const class FText& Text, const double Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SubtitleSubsystem", "ShowSubtitle");

	Params::SubtitleSubsystem_ShowSubtitle Parms{};

	Parms.Text = std::move(Text);
	Parms.Duration = Duration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SurfaceClimbAbility.OnMovementModeChanged
// (Final, Native, Public)
// Parameters:
// class UEverholmCharacterMovementComponent*MovementComponent                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmCharacterMovementMode          PreviousMovementMode                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USurfaceClimbAbility::OnMovementModeChanged(class UEverholmCharacterMovementComponent* MovementComponent, EEverholmCharacterMovementMode PreviousMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbAbility", "OnMovementModeChanged");

	Params::SurfaceClimbAbility_OnMovementModeChanged Parms{};

	Parms.MovementComponent = MovementComponent;
	Parms.PreviousMovementMode = PreviousMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SurfaceClimbAbility.IsOnCooldown
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USurfaceClimbAbility::IsOnCooldown() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SurfaceClimbAbility", "IsOnCooldown");

	Params::SurfaceClimbAbility_IsOnCooldown Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SwapRoleOnVehicleComponent.CanSwapRoleInVehicle
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USwapRoleOnVehicleComponent::CanSwapRoleInVehicle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "CanSwapRoleInVehicle");

	Params::SwapRoleOnVehicleComponent_CanSwapRoleInVehicle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SwapRoleOnVehicleComponent.DriverCallAbility
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FCallContext&              CallContext                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void USwapRoleOnVehicleComponent::DriverCallAbility(const struct FCallContext& CallContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "DriverCallAbility");

	Params::SwapRoleOnVehicleComponent_DriverCallAbility Parms{};

	Parms.CallContext = std::move(CallContext);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.DriverRoleAssigned
// (Final, Native, Protected)
// Parameters:
// const class AEverholmCharacter*         NewCharacter                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmCharacter*         OldCharacter                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USwapRoleOnVehicleComponent::DriverRoleAssigned(const class AEverholmCharacter* NewCharacter, const class AEverholmCharacter* OldCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "DriverRoleAssigned");

	Params::SwapRoleOnVehicleComponent_DriverRoleAssigned Parms{};

	Parms.NewCharacter = NewCharacter;
	Parms.OldCharacter = OldCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.OnRep_SwapRoleState
// (Final, Native, Protected)
// Parameters:
// ESwapRoleState                          prevState                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USwapRoleOnVehicleComponent::OnRep_SwapRoleState(ESwapRoleState prevState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "OnRep_SwapRoleState");

	Params::SwapRoleOnVehicleComponent_OnRep_SwapRoleState Parms{};

	Parms.prevState = prevState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.PassengerCallAbility
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FCallContext&              CallContext                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void USwapRoleOnVehicleComponent::PassengerCallAbility(const struct FCallContext& CallContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "PassengerCallAbility");

	Params::SwapRoleOnVehicleComponent_PassengerCallAbility Parms{};

	Parms.CallContext = std::move(CallContext);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.PassengerRoleAssigned
// (Final, Native, Protected)
// Parameters:
// const class AEverholmCharacter*         NewCharacter                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AEverholmCharacter*         OldCharacter                                           (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USwapRoleOnVehicleComponent::PassengerRoleAssigned(const class AEverholmCharacter* NewCharacter, const class AEverholmCharacter* OldCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "PassengerRoleAssigned");

	Params::SwapRoleOnVehicleComponent_PassengerRoleAssigned Parms{};

	Parms.NewCharacter = NewCharacter;
	Parms.OldCharacter = OldCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.ReplyWindowTimerDone
// (Final, Native, Protected)

void USwapRoleOnVehicleComponent::ReplyWindowTimerDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "ReplyWindowTimerDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.SetSwapState
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// ESwapRoleState                          NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USwapRoleOnVehicleComponent::SetSwapState(ESwapRoleState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "SetSwapState");

	Params::SwapRoleOnVehicleComponent_SetSwapState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.SinglePlayerCompanionReply
// (Final, Native, Protected)

void USwapRoleOnVehicleComponent::SinglePlayerCompanionReply()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "SinglePlayerCompanionReply");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwapRoleOnVehicleComponent.SwapMoveDone
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AEverholmCharacter*               PrevDriver                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               PrevPassenger                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USwapRoleOnVehicleComponent::SwapMoveDone(class AEverholmCharacter* PrevDriver, class AEverholmCharacter* PrevPassenger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwapRoleOnVehicleComponent", "SwapMoveDone");

	Params::SwapRoleOnVehicleComponent_SwapMoveDone Parms{};

	Parms.PrevDriver = PrevDriver;
	Parms.PrevPassenger = PrevPassenger;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.SwimAbility.GetIsInSwimmingRegion
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool USwimAbility::GetIsInSwimmingRegion() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwimAbility", "GetIsInSwimmingRegion");

	Params::SwimAbility_GetIsInSwimmingRegion Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SwimAbility.GetWaterData
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FSwimmingWaterData               ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FSwimmingWaterData USwimAbility::GetWaterData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwimAbility", "GetWaterData");

	Params::SwimAbility_GetWaterData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SwimAbility.GetWaterSurfaceLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector USwimAbility::GetWaterSurfaceLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwimAbility", "GetWaterSurfaceLocation");

	Params::SwimAbility_GetWaterSurfaceLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.SwimmingRegion.GetSurfaceLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   playerLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ASwimmingRegion::GetSurfaceLocation(const struct FVector& playerLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwimmingRegion", "GetSurfaceLocation");

	Params::SwimmingRegion_GetSurfaceLocation Parms{};

	Parms.playerLocation = std::move(playerLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TankActor.BoxOverlapTankTargetComponents
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FQuat&                     BoxOrient                                              (ConstParm, Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxPos                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxExtent                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<EObjectTypeQuery>&         ObjectTypes                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class UClass*                           ComponentClassFilter                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            ActorsToIgnore                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UTankTargetComponent*>*    OutComponents                                          (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ATankActor::BoxOverlapTankTargetComponents(const class UObject* WorldContextObject, const struct FQuat& BoxOrient, const struct FVector& BoxPos, const struct FVector& BoxExtent, const TArray<EObjectTypeQuery>& ObjectTypes, class UClass* ComponentClassFilter, const TArray<class AActor*>& ActorsToIgnore, TArray<class UTankTargetComponent*>* OutComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TankActor", "BoxOverlapTankTargetComponents");

	Params::TankActor_BoxOverlapTankTargetComponents Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.BoxOrient = std::move(BoxOrient);
	Parms.BoxPos = std::move(BoxPos);
	Parms.BoxExtent = std::move(BoxExtent);
	Parms.ObjectTypes = std::move(ObjectTypes);
	Parms.ComponentClassFilter = ComponentClassFilter;
	Parms.ActorsToIgnore = std::move(ActorsToIgnore);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutComponents != nullptr)
		*OutComponents = std::move(Parms.OutComponents);

	return Parms.ReturnValue;
}


// Function Everholm.TankActor.GetCurrentTank
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ATankActor*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ATankActor* ATankActor::GetCurrentTank(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("TankActor", "GetCurrentTank");

	Params::TankActor_GetCurrentTank Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TankActor.GetTankVelocity
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector ATankActor::GetTankVelocity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TankActor", "GetTankVelocity");

	Params::TankActor_GetTankVelocity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TankNetProxyComponent.MC_ServerFrameTank
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FSmoothRepSceneComponentState&State                                                  (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FTankMoveRepState&         tankState                                              (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UTankNetProxyComponent::MC_ServerFrameTank(const struct FSmoothRepSceneComponentState& State, const struct FTankMoveRepState& tankState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TankNetProxyComponent", "MC_ServerFrameTank");

	Params::TankNetProxyComponent_MC_ServerFrameTank Parms{};

	Parms.State = std::move(State);
	Parms.tankState = std::move(tankState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.FindTarget
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// ETargetType                             TargetType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   angleFromForward                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   rotationOffsetFromForward                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   rotationOffsetAxis                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UTargetComponent*           ReturnValue                                            (ConstParm, ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UTargetComponent* UTargetingComponent::FindTarget(ETargetType TargetType, float angleFromForward, float rotationOffsetFromForward, const struct FVector& rotationOffsetAxis)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "FindTarget");

	Params::TargetingComponent_FindTarget Parms{};

	Parms.TargetType = TargetType;
	Parms.angleFromForward = angleFromForward;
	Parms.rotationOffsetFromForward = rotationOffsetFromForward;
	Parms.rotationOffsetAxis = std::move(rotationOffsetAxis);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TargetingComponent.HandleCinematicModeChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTargetingComponent::HandleCinematicModeChanged(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "HandleCinematicModeChanged");

	Params::TargetingComponent_HandleCinematicModeChanged Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.HandleGameplayTagsChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ChangedTag                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTargetingComponent::HandleGameplayTagsChanged(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& ChangedTag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "HandleGameplayTagsChanged");

	Params::TargetingComponent_HandleGameplayTagsChanged Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.ChangedTag = std::move(ChangedTag);
	Parms.bWasAdded = bWasAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.HandleMeshAnimInitialized
// (Final, Native, Private)

void UTargetingComponent::HandleMeshAnimInitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "HandleMeshAnimInitialized");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.OnOwnerControllerChanged
// (Final, Native, Private)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      OldController                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      NewController                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTargetingComponent::OnOwnerControllerChanged(class APawn* Pawn, class AController* OldController, class AController* NewController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "OnOwnerControllerChanged");

	Params::TargetingComponent_OnOwnerControllerChanged Parms{};

	Parms.Pawn = Pawn;
	Parms.OldController = OldController;
	Parms.NewController = NewController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.OnRep_RawLookInput
// (Final, Native, Private)

void UTargetingComponent::OnRep_RawLookInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "OnRep_RawLookInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.ServerSetLookInput
// (Final, Net, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// const struct FVector_NetQuantizeNormal& lookInput                                              (ConstParm, Parm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTargetingComponent::ServerSetLookInput(const struct FVector_NetQuantizeNormal& lookInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "ServerSetLookInput");

	Params::TargetingComponent_ServerSetLookInput Parms{};

	Parms.lookInput = std::move(lookInput);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.SetLookAtBlendCurve
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FRuntimeFloatCurve&        blendCurve                                             (Parm, NativeAccessSpecifierPublic)

void UTargetingComponent::SetLookAtBlendCurve(const struct FRuntimeFloatCurve& blendCurve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "SetLookAtBlendCurve");

	Params::TargetingComponent_SetLookAtBlendCurve Parms{};

	Parms.blendCurve = std::move(blendCurve);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.SetOverrideLookAtTargetActor
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class UTargetComponent*           overrideTarget                                         (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   optionalOffset                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTargetingComponent::SetOverrideLookAtTargetActor(const class UTargetComponent* overrideTarget, const struct FVector& optionalOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "SetOverrideLookAtTargetActor");

	Params::TargetingComponent_SetOverrideLookAtTargetActor Parms{};

	Parms.overrideTarget = overrideTarget;
	Parms.optionalOffset = std::move(optionalOffset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TargetingComponent.GetLastFoundTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ETargetType                             TargetType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTargetComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTargetComponent* UTargetingComponent::GetLastFoundTarget(ETargetType TargetType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "GetLastFoundTarget");

	Params::TargetingComponent_GetLastFoundTarget Parms{};

	Parms.TargetType = TargetType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TargetingComponent.GetLookAtBlendCurve
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRuntimeFloatCurve               ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FRuntimeFloatCurve UTargetingComponent::GetLookAtBlendCurve() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "GetLookAtBlendCurve");

	Params::TargetingComponent_GetLookAtBlendCurve Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TargetingComponent.GetLookInput
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector                    ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const struct FVector UTargetingComponent::GetLookInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TargetingComponent", "GetLookInput");

	Params::TargetingComponent_GetLookInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TarsierCommonRichTextBlock.OnInputMethodChanged
// (Final, Native, Protected)
// Parameters:
// ELocalUserType                          localUserType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECommonInputType                        NewInputType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTarsierCommonRichTextBlock::OnInputMethodChanged(ELocalUserType localUserType, ECommonInputType NewInputType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TarsierCommonRichTextBlock", "OnInputMethodChanged");

	Params::TarsierCommonRichTextBlock_OnInputMethodChanged Parms{};

	Parms.localUserType = localUserType;
	Parms.NewInputType = NewInputType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TeleportationRelayComponent.BindTeleportDelegate
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTeleportationRelayComponent::BindTeleportDelegate(class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TeleportationRelayComponent", "BindTeleportDelegate");

	Params::TeleportationRelayComponent_BindTeleportDelegate Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TeleportationRelayComponent.CleanupTeleport
// (Final, Native, Public, BlueprintCallable)

void UTeleportationRelayComponent::CleanupTeleport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TeleportationRelayComponent", "CleanupTeleport");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TeleportationRelayComponent.OnPlayerCharacterSpawned
// (Final, Native, Private)
// Parameters:
// class AEverholmPlayerCharacter*         PlayerCharacter                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTeleportationRelayComponent::OnPlayerCharacterSpawned(class AEverholmPlayerCharacter* PlayerCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TeleportationRelayComponent", "OnPlayerCharacterSpawned");

	Params::TeleportationRelayComponent_OnPlayerCharacterSpawned Parms{};

	Parms.PlayerCharacter = PlayerCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TeleportationRelayComponent.OnTeleportSuccess
// (Final, Native, Private)
// Parameters:
// class AEverholmCharacter*               teleportingCharacter                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTeleportationRelayComponent::OnTeleportSuccess(class AEverholmCharacter* teleportingCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TeleportationRelayComponent", "OnTeleportSuccess");

	Params::TeleportationRelayComponent_OnTeleportSuccess Parms{};

	Parms.teleportingCharacter = teleportingCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TeleportationRelayComponent.ResetTeleportHistory
// (Final, Native, Private)

void UTeleportationRelayComponent::ResetTeleportHistory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TeleportationRelayComponent", "ResetTeleportHistory");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TeleportationRelayComponent.StartTeleport
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FTeleportRelayEntry>&teleportingCharacters                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UTeleportationRelayComponent::StartTeleport(const TArray<struct FTeleportRelayEntry>& teleportingCharacters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TeleportationRelayComponent", "StartTeleport");

	Params::TeleportationRelayComponent_StartTeleport Parms{};

	Parms.teleportingCharacters = std::move(teleportingCharacters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ThrowTargetPipWidget.SetIcon
// (Event, Protected, BlueprintEvent)
// Parameters:
// const class UTexture2D*                 iconTexture                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowTargetPipWidget::SetIcon(const class UTexture2D* iconTexture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowTargetPipWidget", "SetIcon");

	Params::ThrowTargetPipWidget_SetIcon Parms{};

	Parms.iconTexture = iconTexture;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ThrowTargetPipWidget.SetIconAngle
// (Event, Protected, BlueprintEvent)
// Parameters:
// const float                             Angle                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowTargetPipWidget::SetIconAngle(const float Angle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowTargetPipWidget", "SetIconAngle");

	Params::ThrowTargetPipWidget_SetIconAngle Parms{};

	Parms.Angle = Angle;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ThrowTargetPipWidget.SetIconTranslation
// (Event, Protected, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector2D&                 Translation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UThrowTargetPipWidget::SetIconTranslation(const struct FVector2D& Translation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowTargetPipWidget", "SetIconTranslation");

	Params::ThrowTargetPipWidget_SetIconTranslation Parms{};

	Parms.Translation = std::move(Translation);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ThrowTargetPipWidget.GetCurrentTarget
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UTargetComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTargetComponent* UThrowTargetPipWidget::GetCurrentTarget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowTargetPipWidget", "GetCurrentTarget");

	Params::ThrowTargetPipWidget_GetCurrentTarget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowTargetPipWidget.GetCurrentTargetName
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UThrowTargetPipWidget::GetCurrentTargetName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowTargetPipWidget", "GetCurrentTargetName");

	Params::ThrowTargetPipWidget_GetCurrentTargetName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowTargetPipWidget.GetOtherPip
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UThrowTargetPipWidget*            ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UThrowTargetPipWidget* UThrowTargetPipWidget::GetOtherPip() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowTargetPipWidget", "GetOtherPip");

	Params::ThrowTargetPipWidget_GetOtherPip Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ThrowTargetPipWidget.GetOwningCharacter
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AEverholmPlayerCharacter*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AEverholmPlayerCharacter* UThrowTargetPipWidget::GetOwningCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThrowTargetPipWidget", "GetOwningCharacter");

	Params::ThrowTargetPipWidget_GetOwningCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.TiedTogetherComponent.OnRep_RopeTiedTogetherActor
// (Final, Native, Protected)

void UTiedTogetherComponent::OnRep_RopeTiedTogetherActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TiedTogetherComponent", "OnRep_RopeTiedTogetherActor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TiedTogetherComponent.RopeReachedLimit
// (Native, Event, Public, BlueprintEvent)

void UTiedTogetherComponent::RopeReachedLimit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TiedTogetherComponent", "RopeReachedLimit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TiedTogetherComponent.Server_ClientInputReceived
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)

void UTiedTogetherComponent::Server_ClientInputReceived()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TiedTogetherComponent", "Server_ClientInputReceived");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TiedTogetherComponent.SetPlayPullAnimMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bPlayAnim                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTiedTogetherComponent::SetPlayPullAnimMontage(bool bPlayAnim)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TiedTogetherComponent", "SetPlayPullAnimMontage");

	Params::TiedTogetherComponent_SetPlayPullAnimMontage Parms{};

	Parms.bPlayAnim = bPlayAnim;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TiedTogetherComponent.SetRopeHidden
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const bool                              bIsHidden                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTiedTogetherComponent::SetRopeHidden(const bool bIsHidden)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TiedTogetherComponent", "SetRopeHidden");

	Params::TiedTogetherComponent_SetRopeHidden Parms{};

	Parms.bIsHidden = bIsHidden;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TiedTogetherComponent.GetTiedRopeLength
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UTiedTogetherComponent::GetTiedRopeLength() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TiedTogetherComponent", "GetTiedRopeLength");

	Params::TiedTogetherComponent_GetTiedRopeLength Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ToolPryComponent.GetPryComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UToolPryComponent*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UToolPryComponent* UToolPryComponent::GetPryComponent(const class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("ToolPryComponent", "GetPryComponent");

	Params::ToolPryComponent_GetPryComponent Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ToolPryComponent.HandlePryCompleted
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UToolPryComponent::HandlePryCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ToolPryComponent", "HandlePryCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ToolPryComponent.OnHolderChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           newHolder                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UToolPryComponent::OnHolderChanged(class AActor* newHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ToolPryComponent", "OnHolderChanged");

	Params::ToolPryComponent_OnHolderChanged Parms{};

	Parms.newHolder = newHolder;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.ToolSwingComponent.CanBounce
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UToolSwingComponent::CanBounce(const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ToolSwingComponent", "CanBounce");

	Params::ToolSwingComponent_CanBounce Parms{};

	Parms.HitResult = std::move(HitResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.ToolSwingComponent.OnRep_HitResults
// (Final, Native, Protected)

void UToolSwingComponent::OnRep_HitResults()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ToolSwingComponent", "OnRep_HitResults");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ToolSwingComponent.StartOverlap
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   overlapDuration                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            Instigator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UToolSwingComponent::StartOverlap(float overlapDuration, class APawn* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ToolSwingComponent", "StartOverlap");

	Params::ToolSwingComponent_StartOverlap Parms{};

	Parms.overlapDuration = overlapDuration;
	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.ToolSwingComponent.StopOverlap
// (Final, Native, Public, BlueprintCallable)

void UToolSwingComponent::StopOverlap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ToolSwingComponent", "StopOverlap");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TutorialPromptComponent.ActorEnter
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTutorialPromptComponent::ActorEnter(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TutorialPromptComponent", "ActorEnter");

	Params::TutorialPromptComponent_ActorEnter Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TutorialPromptComponent.ActorLeave
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTutorialPromptComponent::ActorLeave(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TutorialPromptComponent", "ActorLeave");

	Params::TutorialPromptComponent_ActorLeave Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TutorialPromptComponent.ClearHint
// (Final, Native, Protected, BlueprintCallable)

void UTutorialPromptComponent::ClearHint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TutorialPromptComponent", "ClearHint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TutorialPromptWidget.HandleTagChanged
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ChangedTag                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UTutorialPromptWidget::HandleTagChanged(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& ChangedTag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TutorialPromptWidget", "HandleTagChanged");

	Params::TutorialPromptWidget_HandleTagChanged Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.ChangedTag = std::move(ChangedTag);
	Parms.bWasAdded = bWasAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.TutorialPromptWidget.StartRemoveHint
// (Native, Event, Public, BlueprintEvent)

void UTutorialPromptWidget::StartRemoveHint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("TutorialPromptWidget", "StartRemoveHint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.EverholmNetworkErrorListenerSubsystem.OnNetworkSessionManagerFailure
// (Final, Native, Protected)
// Parameters:
// ENetworkSessionManagerFailType          FailureType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UEverholmNetworkErrorListenerSubsystem::OnNetworkSessionManagerFailure(ENetworkSessionManagerFailType FailureType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("EverholmNetworkErrorListenerSubsystem", "OnNetworkSessionManagerFailure");

	Params::EverholmNetworkErrorListenerSubsystem_OnNetworkSessionManagerFailure Parms{};

	Parms.FailureType = FailureType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UILayer.BP_AddWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UTarsierActivatableWidget>WidgetClass                                            (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTarsierActivatableWidget*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTarsierActivatableWidget* UUILayer::BP_AddWidget(TSubclassOf<class UTarsierActivatableWidget> WidgetClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "BP_AddWidget");

	Params::UILayer_BP_AddWidget Parms{};

	Parms.WidgetClass = WidgetClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.UILayer.ClearWidgets
// (Final, Native, Public, BlueprintCallable)

void UUILayer::ClearWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "ClearWidgets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UILayer.GatherAllInputActions
// (Final, Native, Public, BlueprintCallable)

void UUILayer::GatherAllInputActions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "GatherAllInputActions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UILayer.GetGatheredInputActions
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const TArray<struct FInputActionDisplayInfo>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FInputActionDisplayInfo> UUILayer::GetGatheredInputActions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "GetGatheredInputActions");

	Params::UILayer_GetGatheredInputActions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.UILayer.GetNumberOfWidgets
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UUILayer::GetNumberOfWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "GetNumberOfWidgets");

	Params::UILayer_GetNumberOfWidgets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.UILayer.OnStackDisplayedWidgetChanged
// (Final, Native, Protected)
// Parameters:
// class UCommonActivatableWidget*         displayedWidget                                        (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UUILayer::OnStackDisplayedWidgetChanged(class UCommonActivatableWidget* displayedWidget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "OnStackDisplayedWidgetChanged");

	Params::UILayer_OnStackDisplayedWidgetChanged Parms{};

	Parms.displayedWidget = displayedWidget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UILayer.ResetFocus
// (Final, Native, Public, BlueprintCallable)

void UUILayer::ResetFocus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "ResetFocus");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.UILayer.HasAnyWidget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UUILayer::HasAnyWidget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("UILayer", "HasAnyWidget");

	Params::UILayer_HasAnyWidget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleAlignSplineComponent.RotationSpeedTowardsAlignSpline
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UVehicleAlignSplineComponent::RotationSpeedTowardsAlignSpline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleAlignSplineComponent", "RotationSpeedTowardsAlignSpline");

	Params::VehicleAlignSplineComponent_RotationSpeedTowardsAlignSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleControlComponent.CinematicModeEnabled
// (Final, Native, Protected)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleControlComponent::CinematicModeEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "CinematicModeEnabled");

	Params::VehicleControlComponent_CinematicModeEnabled Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.Multicast_UseVehicle
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FVector_NetQuantize&       localVehicleLocation                                   (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantizeNormal& localUseVehicleForward                                 (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleControlComponent::Multicast_UseVehicle(const struct FVector_NetQuantize& localVehicleLocation, const struct FVector_NetQuantizeNormal& localUseVehicleForward, class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "Multicast_UseVehicle");

	Params::VehicleControlComponent_Multicast_UseVehicle Parms{};

	Parms.localVehicleLocation = std::move(localVehicleLocation);
	Parms.localUseVehicleForward = std::move(localUseVehicleForward);
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.OnMovementModeChanged
// (Final, Native, Protected)
// Parameters:
// class UEverholmCharacterMovementComponent*MovementComponent                                      (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEverholmCharacterMovementMode          PreviousMovementMode                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleControlComponent::OnMovementModeChanged(class UEverholmCharacterMovementComponent* MovementComponent, EEverholmCharacterMovementMode PreviousMovementMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "OnMovementModeChanged");

	Params::VehicleControlComponent_OnMovementModeChanged Parms{};

	Parms.MovementComponent = MovementComponent;
	Parms.PreviousMovementMode = PreviousMovementMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.OnRep_ControlledVehicle
// (Final, Native, Protected)
// Parameters:
// const struct FControlledVehicleRef&     oldVehicle                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleControlComponent::OnRep_ControlledVehicle(const struct FControlledVehicleRef& oldVehicle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "OnRep_ControlledVehicle");

	Params::VehicleControlComponent_OnRep_ControlledVehicle Parms{};

	Parms.oldVehicle = std::move(oldVehicle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.OnRep_VehicleControlData
// (Final, Native, Protected)

void UVehicleControlComponent::OnRep_VehicleControlData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "OnRep_VehicleControlData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.ResetPlayerOnControlledVehicle
// (Final, Native, Protected)
// Parameters:
// class AEverholmCharacter*               Player                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleControlComponent::ResetPlayerOnControlledVehicle(class AEverholmCharacter* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "ResetPlayerOnControlledVehicle");

	Params::VehicleControlComponent_ResetPlayerOnControlledVehicle Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.Server_ExitVehicle
// (Net, NetReliable, Native, Event, Protected, NetServer)

void UVehicleControlComponent::Server_ExitVehicle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "Server_ExitVehicle");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.Server_SetControlData
// (Net, Native, Event, Protected, NetServer)
// Parameters:
// const struct FVehicleControlData&       vehicleControl                                         (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleControlComponent::Server_SetControlData(const struct FVehicleControlData& vehicleControl)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "Server_SetControlData");

	Params::VehicleControlComponent_Server_SetControlData Parms{};

	Parms.vehicleControl = std::move(vehicleControl);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.Server_UseVehicle
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// const struct FVector_NetQuantize&       localVehicleLocation                                   (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantizeNormal& localUseVehicleForward                                 (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AEverholmCharacter*               Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleControlComponent::Server_UseVehicle(const struct FVector_NetQuantize& localVehicleLocation, const struct FVector_NetQuantizeNormal& localUseVehicleForward, class AEverholmCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "Server_UseVehicle");

	Params::VehicleControlComponent_Server_UseVehicle Parms{};

	Parms.localVehicleLocation = std::move(localVehicleLocation);
	Parms.localUseVehicleForward = std::move(localUseVehicleForward);
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.UseVehicleCooldownTimerDone
// (Final, Native, Private)

void UVehicleControlComponent::UseVehicleCooldownTimerDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "UseVehicleCooldownTimerDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleControlComponent.GetCurrentVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AVehicleActor*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AVehicleActor* UVehicleControlComponent::GetCurrentVehicle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleControlComponent", "GetCurrentVehicle");

	Params::VehicleControlComponent_GetCurrentVehicle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleSpawnInfoDataAsset.GetSpawnInfoForVehicle
// (Final, Native, Private, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const TSoftObjectPtr<class AVehicleActor>&VehicleActor                                           (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVehicleSpawnInfo                ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FVehicleSpawnInfo UVehicleSpawnInfoDataAsset::GetSpawnInfoForVehicle(const TSoftObjectPtr<class AVehicleActor>& VehicleActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleSpawnInfoDataAsset", "GetSpawnInfoForVehicle");

	Params::VehicleSpawnInfoDataAsset_GetSpawnInfoForVehicle Parms{};

	Parms.VehicleActor = VehicleActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleDeathHandler.CalculateAngleToInstigator
// (Final, Native, Protected, BlueprintCallable)

void AVehicleDeathHandler::CalculateAngleToInstigator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleDeathHandler", "CalculateAngleToInstigator");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleDeathHandler.GetAngleToInstigator
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AVehicleDeathHandler::GetAngleToInstigator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleDeathHandler", "GetAngleToInstigator");

	Params::VehicleDeathHandler_GetAngleToInstigator Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleDeathHandler.OnDeathHandlerAnimNotify
// (Event, Public, BlueprintEvent)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           ownerMeshComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleDeathHandler::OnDeathHandlerAnimNotify(class FName NotifyName, class UAnimSequenceBase* Animation, class USkeletalMeshComponent* ownerMeshComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleDeathHandler", "OnDeathHandlerAnimNotify");

	Params::VehicleDeathHandler_OnDeathHandlerAnimNotify Parms{};

	Parms.NotifyName = NotifyName;
	Parms.Animation = Animation;
	Parms.ownerMeshComponent = ownerMeshComponent;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.VehicleDeathHandler.PlayMontageOnInstigator
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           instigatorActor                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleDeathHandler::PlayMontageOnInstigator(class AActor* instigatorActor, class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleDeathHandler", "PlayMontageOnInstigator");

	Params::VehicleDeathHandler_PlayMontageOnInstigator Parms{};

	Parms.instigatorActor = instigatorActor;
	Parms.Montage = Montage;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Everholm.VehicleDeathHandler.Ragdoll
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           ownerMeshComponent                                     (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRuntimeFloatCurve&        blendInCurve                                           (Parm, NativeAccessSpecifierPublic)

void AVehicleDeathHandler::Ragdoll(class USkeletalMeshComponent* ownerMeshComponent, const struct FRuntimeFloatCurve& blendInCurve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleDeathHandler", "Ragdoll");

	Params::VehicleDeathHandler_Ragdoll Parms{};

	Parms.ownerMeshComponent = ownerMeshComponent;
	Parms.blendInCurve = std::move(blendInCurve);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleDeathHandler.SelectAndPlayMontageOnCharacters
// (Final, Native, Protected, BlueprintCallable)

void AVehicleDeathHandler::SelectAndPlayMontageOnCharacters()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleDeathHandler", "SelectAndPlayMontageOnCharacters");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleDeathHandler.SelectAndPlayPreKillMontageOnCharacters
// (Final, Native, Protected, BlueprintCallable)

void AVehicleDeathHandler::SelectAndPlayPreKillMontageOnCharacters()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleDeathHandler", "SelectAndPlayPreKillMontageOnCharacters");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActorReplicationComponent.ClearCollisionEventForReplication
// (Final, Native, Public, BlueprintCallable)

void UVehicleActorReplicationComponent::ClearCollisionEventForReplication()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActorReplicationComponent", "ClearCollisionEventForReplication");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActorReplicationComponent.MC_ServerFrameVehicle
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FSmoothRepSceneComponentState&State                                                  (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVehicleActorMoveRepState& vehicleState                                           (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleActorReplicationComponent::MC_ServerFrameVehicle(const struct FSmoothRepSceneComponentState& State, const struct FVehicleActorMoveRepState& vehicleState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActorReplicationComponent", "MC_ServerFrameVehicle");

	Params::VehicleActorReplicationComponent_MC_ServerFrameVehicle Parms{};

	Parms.State = std::move(State);
	Parms.vehicleState = std::move(vehicleState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActorReplicationComponent.MC_ServerFrameVehicleWithColl
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const struct FSmoothRepSceneComponentState&State                                                  (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVehicleActorMoveRepStateWithCollision&vehicleState                                           (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UVehicleActorReplicationComponent::MC_ServerFrameVehicleWithColl(const struct FSmoothRepSceneComponentState& State, const struct FVehicleActorMoveRepStateWithCollision& vehicleState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActorReplicationComponent", "MC_ServerFrameVehicleWithColl");

	Params::VehicleActorReplicationComponent_MC_ServerFrameVehicleWithColl Parms{};

	Parms.State = std::move(State);
	Parms.vehicleState = std::move(vehicleState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActorReplicationComponent.SetCollisionEventForReplication
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   CollisionEvent                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleActorReplicationComponent::SetCollisionEventForReplication(int32 CollisionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActorReplicationComponent", "SetCollisionEventForReplication");

	Params::VehicleActorReplicationComponent_SetCollisionEventForReplication Parms{};

	Parms.CollisionEvent = CollisionEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleActorReplicationComponent.GetCollisionEventForReplication
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UVehicleActorReplicationComponent::GetCollisionEventForReplication() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleActorReplicationComponent", "GetCollisionEventForReplication");

	Params::VehicleActorReplicationComponent_GetCollisionEventForReplication Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleMoveToTargetComponent.FollowTargetTransformTLDone
// (Final, Native, Protected)

void UVehicleMoveToTargetComponent::FollowTargetTransformTLDone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "FollowTargetTransformTLDone");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveToTargetComponent.FollowTargetTransformTLUpdate
// (Final, Native, Protected)
// Parameters:
// float                                   Alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMoveToTargetComponent::FollowTargetTransformTLUpdate(float Alpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "FollowTargetTransformTLUpdate");

	Params::VehicleMoveToTargetComponent_FollowTargetTransformTLUpdate Parms{};

	Parms.Alpha = Alpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveToTargetComponent.MoveToTarget
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   targetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  targetRotation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      overrideMovementCurve                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bReturnControlOnDone                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMoveToTargetComponent::MoveToTarget(const struct FVector& targetLocation, const struct FRotator& targetRotation, float Duration, class UCurveFloat* overrideMovementCurve, bool bReturnControlOnDone)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "MoveToTarget");

	Params::VehicleMoveToTargetComponent_MoveToTarget Parms{};

	Parms.targetLocation = std::move(targetLocation);
	Parms.targetRotation = std::move(targetRotation);
	Parms.Duration = Duration;
	Parms.overrideMovementCurve = overrideMovementCurve;
	Parms.bReturnControlOnDone = bReturnControlOnDone;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveToTargetComponent.MoveToTarget_SeparateDuration
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   targetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  targetRotation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   moveDuration                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   rotateDuration                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      overrideMovementCurve                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bReturnControlOnDone                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMoveToTargetComponent::MoveToTarget_SeparateDuration(const struct FVector& targetLocation, const struct FRotator& targetRotation, float moveDuration, float rotateDuration, class UCurveFloat* overrideMovementCurve, bool bReturnControlOnDone)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "MoveToTarget_SeparateDuration");

	Params::VehicleMoveToTargetComponent_MoveToTarget_SeparateDuration Parms{};

	Parms.targetLocation = std::move(targetLocation);
	Parms.targetRotation = std::move(targetRotation);
	Parms.moveDuration = moveDuration;
	Parms.rotateDuration = rotateDuration;
	Parms.overrideMovementCurve = overrideMovementCurve;
	Parms.bReturnControlOnDone = bReturnControlOnDone;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveToTargetComponent.MoveToTargetTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                TargetTransform                                        (Parm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      overrideMovementCurve                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bReturnControlOnDone                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMoveToTargetComponent::MoveToTargetTransform(const struct FTransform& TargetTransform, float Duration, class UCurveFloat* overrideMovementCurve, bool bReturnControlOnDone)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "MoveToTargetTransform");

	Params::VehicleMoveToTargetComponent_MoveToTargetTransform Parms{};

	Parms.TargetTransform = std::move(TargetTransform);
	Parms.Duration = Duration;
	Parms.overrideMovementCurve = overrideMovementCurve;
	Parms.bReturnControlOnDone = bReturnControlOnDone;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveToTargetComponent.SetComponentState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVehicleMoveToTargetComponent::SetComponentState(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "SetComponentState");

	Params::VehicleMoveToTargetComponent_SetComponentState Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveToTargetComponent.StopImmediately
// (Final, Native, Public, BlueprintCallable)

void UVehicleMoveToTargetComponent::StopImmediately()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "StopImmediately");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleMoveToTargetComponent.IsRotationOnly
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UVehicleMoveToTargetComponent::IsRotationOnly() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleMoveToTargetComponent", "IsRotationOnly");

	Params::VehicleMoveToTargetComponent_IsRotationOnly Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleSpeedModifierPresets.GetSpeedModifierParamsFromPreset
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EVehicleSpeedMofidierPreset             preset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVehicleSpeedModifierParamsReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FVehicleSpeedModifierParams UVehicleSpeedModifierPresets::GetSpeedModifierParamsFromPreset(EVehicleSpeedMofidierPreset preset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("VehicleSpeedModifierPresets", "GetSpeedModifierParamsFromPreset");

	Params::VehicleSpeedModifierPresets_GetSpeedModifierParamsFromPreset Parms{};

	Parms.preset = preset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.VehicleSpeedModifierVolume.ApplyPresetToVehicle
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AVehicleActor*                    Vehicle                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EVehicleSpeedMofidierPreset             speedModifierPreset                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceInstant                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleSpeedModifierVolume::ApplyPresetToVehicle(class AVehicleActor* Vehicle, EVehicleSpeedMofidierPreset speedModifierPreset, bool bForceInstant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleSpeedModifierVolume", "ApplyPresetToVehicle");

	Params::VehicleSpeedModifierVolume_ApplyPresetToVehicle Parms{};

	Parms.Vehicle = Vehicle;
	Parms.speedModifierPreset = speedModifierPreset;
	Parms.bForceInstant = bForceInstant;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleSpeedModifierVolume.EnterValidVehicle
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AVehicleActor*                    Vehicle                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleSpeedModifierVolume::EnterValidVehicle(class AVehicleActor* Vehicle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleSpeedModifierVolume", "EnterValidVehicle");

	Params::VehicleSpeedModifierVolume_EnterValidVehicle Parms{};

	Parms.Vehicle = Vehicle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.VehicleSpeedModifierVolume.ExitValidVehicle
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class AVehicleActor*                    Vehicle                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AVehicleSpeedModifierVolume::ExitValidVehicle(class AVehicleActor* Vehicle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VehicleSpeedModifierVolume", "ExitValidVehicle");

	Params::VehicleSpeedModifierVolume_ExitValidVehicle Parms{};

	Parms.Vehicle = Vehicle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WadingComponent.OnRep_WadingData
// (Final, Native, Public)

void UWadingComponent::OnRep_WadingData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WadingComponent", "OnRep_WadingData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WadingComponent.Server_SetWadingData
// (Net, Native, Event, Public, NetServer)
// Parameters:
// const struct FWadingData&               WadingData                                             (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UWadingComponent::Server_SetWadingData(const struct FWadingData& WadingData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WadingComponent", "Server_SetWadingData");

	Params::WadingComponent_Server_SetWadingData Parms{};

	Parms.WadingData = std::move(WadingData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WadingComponent.SetWadingData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FWadingData&               WadingData                                             (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UWadingComponent::SetWadingData(const struct FWadingData& WadingData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WadingComponent", "SetWadingData");

	Params::WadingComponent_SetWadingData Parms{};

	Parms.WadingData = std::move(WadingData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WadingComponent.GetLastMaxDepth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UWadingComponent::GetLastMaxDepth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WadingComponent", "GetLastMaxDepth");

	Params::WadingComponent_GetLastMaxDepth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.WadingComponent.GetWadingData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FWadingData                ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FWadingData UWadingComponent::GetWadingData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WadingComponent", "GetWadingData");

	Params::WadingComponent_GetWadingData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.WallDetectionComponent.HandleMeshAnimInitialized
// (Final, Native, Protected)

void UWallDetectionComponent::HandleMeshAnimInitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WallDetectionComponent", "HandleMeshAnimInitialized");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WallDetectionComponent.HandleOwnerTagChange
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UAbilityActivationComponent*      AbilityActivationComponent                             (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bWasAdded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWallDetectionComponent::HandleOwnerTagChange(class UAbilityActivationComponent* AbilityActivationComponent, const struct FGameplayTag& Tag, const bool bWasAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WallDetectionComponent", "HandleOwnerTagChange");

	Params::WallDetectionComponent_HandleOwnerTagChange Parms{};

	Parms.AbilityActivationComponent = AbilityActivationComponent;
	Parms.Tag = std::move(Tag);
	Parms.bWasAdded = bWasAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaypointSubsystem.ActivateWaypoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AWaypointActor*                   waypointToActivate                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWaypointSubsystem::ActivateWaypoint(class AWaypointActor* waypointToActivate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaypointSubsystem", "ActivateWaypoint");

	Params::WaypointSubsystem_ActivateWaypoint Parms{};

	Parms.waypointToActivate = waypointToActivate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaypointSubsystem.DeactivateWaypoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AWaypointActor*                   waypointToDeactivate                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UWaypointSubsystem::DeactivateWaypoint(class AWaypointActor* waypointToDeactivate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaypointSubsystem", "DeactivateWaypoint");

	Params::WaypointSubsystem_DeactivateWaypoint Parms{};

	Parms.waypointToDeactivate = waypointToDeactivate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaypointSubsystem.ForceDeactivateCurrentWaypoint
// (Final, Native, Public, BlueprintCallable)

void UWaypointSubsystem::ForceDeactivateCurrentWaypoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaypointSubsystem", "ForceDeactivateCurrentWaypoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Everholm.WaypointSubsystem.GetActivatedWaypoint
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AWaypointActor*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWaypointActor* UWaypointSubsystem::GetActivatedWaypoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaypointSubsystem", "GetActivatedWaypoint");

	Params::WaypointSubsystem_GetActivatedWaypoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Everholm.WaypointSubsystem.HasActiveWaypoint
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UWaypointSubsystem::HasActiveWaypoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WaypointSubsystem", "HasActiveWaypoint");

	Params::WaypointSubsystem_HasActiveWaypoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}

}