#pragma once

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

// Package: RedpointEOSFrameworkExtra

#include "Basic.hpp"

#include "RedpointEOSFrameworkExtra_classes.hpp"
#include "RedpointEOSFrameworkExtra_parameters.hpp"


SDK_NAMESPACE_START

// Function RedpointEOSFrameworkExtra.RedpointAbilityBaseGameplayAbility.K2_ApplyCost
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const struct FGameplayAbilitySpecHandle&Handle                                                 (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayAbilityActorInfo& ActorInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FGameplayAbilityActivationInfo&ActivationInfo                                         (ConstParm, Parm, NoDestructor, NativeAccessSpecifierPublic)

void URedpointAbilityBaseGameplayAbility::K2_ApplyCost(const struct FGameplayAbilitySpecHandle& Handle, const struct FGameplayAbilityActorInfo& ActorInfo, const struct FGameplayAbilityActivationInfo& ActivationInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAbilityBaseGameplayAbility", "K2_ApplyCost");

	Params::RedpointAbilityBaseGameplayAbility_K2_ApplyCost Parms{};

	Parms.Handle = std::move(Handle);
	Parms.ActorInfo = std::move(ActorInfo);
	Parms.ActivationInfo = std::move(ActivationInfo);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityBaseGameplayAbility.K2_CheckCost
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const struct FGameplayAbilitySpecHandle&Handle                                                 (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayAbilityActorInfo& ActorInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URedpointAbilityBaseGameplayAbility::K2_CheckCost(const struct FGameplayAbilitySpecHandle& Handle, const struct FGameplayAbilityActorInfo& ActorInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAbilityBaseGameplayAbility", "K2_CheckCost");

	Params::RedpointAbilityBaseGameplayAbility_K2_CheckCost Parms{};

	Parms.Handle = std::move(Handle);
	Parms.ActorInfo = std::move(ActorInfo);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityBasePlayerState.ResetGameplayAbilities
// (Final, BlueprintAuthorityOnly, Native, Private, BlueprintCallable)

void ARedpointAbilityBasePlayerState::ResetGameplayAbilities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAbilityBasePlayerState", "ResetGameplayAbilities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.FindAbilitySpecHandleForClass
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UAbilitySystemComponent*          AbilitySystem                                          (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayAbility>     AbilityClass                                           (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          OptionalSourceObject                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayAbilitySpecHandle       ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayAbilitySpecHandle URedpointAbilityCharacterBlueprintLibrary::FindAbilitySpecHandleForClass(class UAbilitySystemComponent* AbilitySystem, TSubclassOf<class UGameplayAbility> AbilityClass, class UObject* OptionalSourceObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "FindAbilitySpecHandleForClass");

	Params::RedpointAbilityCharacterBlueprintLibrary_FindAbilitySpecHandleForClass Parms{};

	Parms.AbilitySystem = AbilitySystem;
	Parms.AbilityClass = AbilityClass;
	Parms.OptionalSourceObject = OptionalSourceObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.GetPrimaryAbilityInstanceFromClass
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAbilitySystemComponent*          AbilitySystemComponent                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayAbility>     InAbilityClass                                         (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGameplayAbility*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayAbility* URedpointAbilityCharacterBlueprintLibrary::GetPrimaryAbilityInstanceFromClass(class UAbilitySystemComponent* AbilitySystemComponent, TSubclassOf<class UGameplayAbility> InAbilityClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "GetPrimaryAbilityInstanceFromClass");

	Params::RedpointAbilityCharacterBlueprintLibrary_GetPrimaryAbilityInstanceFromClass Parms{};

	Parms.AbilitySystemComponent = AbilitySystemComponent;
	Parms.InAbilityClass = InAbilityClass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.GetPrimaryAbilityInstanceFromHandle
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAbilitySystemComponent*          AbilitySystemComponent                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayAbilitySpecHandle&Handle                                                 (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGameplayAbility*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayAbility* URedpointAbilityCharacterBlueprintLibrary::GetPrimaryAbilityInstanceFromHandle(class UAbilitySystemComponent* AbilitySystemComponent, const struct FGameplayAbilitySpecHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "GetPrimaryAbilityInstanceFromHandle");

	Params::RedpointAbilityCharacterBlueprintLibrary_GetPrimaryAbilityInstanceFromHandle Parms{};

	Parms.AbilitySystemComponent = AbilitySystemComponent;
	Parms.Handle = std::move(Handle);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.IsAbilitySpecHandleValid
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayAbilitySpecHandle&Handle                                                 (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URedpointAbilityCharacterBlueprintLibrary::IsAbilitySpecHandleValid(const struct FGameplayAbilitySpecHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "IsAbilitySpecHandleValid");

	Params::RedpointAbilityCharacterBlueprintLibrary_IsAbilitySpecHandleValid Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.IsPrimaryAbilityInstanceActive
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAbilitySystemComponent*          AbilitySystemComponent                                 (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayAbilitySpecHandle&Handle                                                 (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URedpointAbilityCharacterBlueprintLibrary::IsPrimaryAbilityInstanceActive(class UAbilitySystemComponent* AbilitySystemComponent, const struct FGameplayAbilitySpecHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "IsPrimaryAbilityInstanceActive");

	Params::RedpointAbilityCharacterBlueprintLibrary_IsPrimaryAbilityInstanceActive Parms{};

	Parms.AbilitySystemComponent = AbilitySystemComponent;
	Parms.Handle = std::move(Handle);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.ClearAbilityFromClass
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ARedpointAbilityBaseCharacter*    Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayAbilitySpecHandle&Handle                                                 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   Success                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointAbilityCharacterBlueprintLibrary::ClearAbilityFromClass(class ARedpointAbilityBaseCharacter* Character, const struct FGameplayAbilitySpecHandle& Handle, bool* Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "ClearAbilityFromClass");

	Params::RedpointAbilityCharacterBlueprintLibrary_ClearAbilityFromClass Parms{};

	Parms.Character = Character;
	Parms.Handle = std::move(Handle);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.ClearAllAbilities
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class ARedpointAbilityBaseCharacter*    Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointAbilityCharacterBlueprintLibrary::ClearAllAbilities(class ARedpointAbilityBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "ClearAllAbilities");

	Params::RedpointAbilityCharacterBlueprintLibrary_ClearAllAbilities Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityCharacterBlueprintLibrary.GiveAbilityFromClass
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ARedpointAbilityBaseCharacter*    Character                                              (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayAbility>     AbilityClass                                           (Parm, ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InputIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayAbilitySpecHandle*      Handle                                                 (Parm, OutParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   Success                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointAbilityCharacterBlueprintLibrary::GiveAbilityFromClass(class ARedpointAbilityBaseCharacter* Character, TSubclassOf<class UGameplayAbility> AbilityClass, int32 Level, int32 InputIndex, struct FGameplayAbilitySpecHandle* Handle, bool* Success)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAbilityCharacterBlueprintLibrary", "GiveAbilityFromClass");

	Params::RedpointAbilityCharacterBlueprintLibrary_GiveAbilityFromClass Parms{};

	Parms.Character = Character;
	Parms.AbilityClass = AbilityClass;
	Parms.Level = Level;
	Parms.InputIndex = InputIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function RedpointEOSFrameworkExtra.RedpointAbilityTask_WaitLanded.CreateWaitLanded
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class URedpointAbilityTask_WaitLanded*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class URedpointAbilityTask_WaitLanded* URedpointAbilityTask_WaitLanded::CreateWaitLanded(class UGameplayAbility* OwningAbility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointAbilityTask_WaitLanded", "CreateWaitLanded");

	Params::RedpointAbilityTask_WaitLanded_CreateWaitLanded Parms{};

	Parms.OwningAbility = OwningAbility;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityTask_WaitLanded.HandleOnLanded
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void URedpointAbilityTask_WaitLanded::HandleOnLanded(const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAbilityTask_WaitLanded", "HandleOnLanded");

	Params::RedpointAbilityTask_WaitLanded_HandleOnLanded Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityWithInputIdInterface.GetAbilityInputId
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ARedpointBackpackItem*            Item                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 IRedpointAbilityWithInputIdInterface::GetAbilityInputId(class ARedpointBackpackItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointAbilityWithInputIdInterface", "GetAbilityInputId");

	Params::RedpointAbilityWithInputIdInterface_GetAbilityInputId Parms{};

	Parms.Item = Item;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAbilityWithLevelInterface.GetAbilityLevel
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ARedpointBackpackItem*            Item                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 IRedpointAbilityWithLevelInterface::GetAbilityLevel(class ARedpointBackpackItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointAbilityWithLevelInterface", "GetAbilityLevel");

	Params::RedpointAbilityWithLevelInterface_GetAbilityLevel Parms{};

	Parms.Item = Item;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetDash.OnRep_DashLengthTime
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetDash::OnRep_DashLengthTime(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetDash", "OnRep_DashLengthTime");

	Params::RedpointAttributeSetDash_OnRep_DashLengthTime Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetDash.OnRep_DashStrength
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetDash::OnRep_DashStrength(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetDash", "OnRep_DashStrength");

	Params::RedpointAttributeSetDash_OnRep_DashStrength Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetDestructablePoints.OnRep_FinalHitPointsForDestruction
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetDestructablePoints::OnRep_FinalHitPointsForDestruction(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetDestructablePoints", "OnRep_FinalHitPointsForDestruction");

	Params::RedpointAttributeSetDestructablePoints_OnRep_FinalHitPointsForDestruction Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetDestructablePoints.OnRep_PointsForRecoveryToExitAfterStun
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetDestructablePoints::OnRep_PointsForRecoveryToExitAfterStun(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetDestructablePoints", "OnRep_PointsForRecoveryToExitAfterStun");

	Params::RedpointAttributeSetDestructablePoints_OnRep_PointsForRecoveryToExitAfterStun Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetDestructablePoints.OnRep_TotalPointsDroppedOnDestruction
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetDestructablePoints::OnRep_TotalPointsDroppedOnDestruction(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetDestructablePoints", "OnRep_TotalPointsDroppedOnDestruction");

	Params::RedpointAttributeSetDestructablePoints_OnRep_TotalPointsDroppedOnDestruction Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetDestructablePoints.OnRep_TotalPointsForDestruction
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetDestructablePoints::OnRep_TotalPointsForDestruction(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetDestructablePoints", "OnRep_TotalPointsForDestruction");

	Params::RedpointAttributeSetDestructablePoints_OnRep_TotalPointsForDestruction Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetHealth.OnRep_CurrentHealth
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetHealth::OnRep_CurrentHealth(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetHealth", "OnRep_CurrentHealth");

	Params::RedpointAttributeSetHealth_OnRep_CurrentHealth Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetHealth.OnRep_HealthRegenAmount
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetHealth::OnRep_HealthRegenAmount(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetHealth", "OnRep_HealthRegenAmount");

	Params::RedpointAttributeSetHealth_OnRep_HealthRegenAmount Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetHealth.OnRep_HealthRegenAmountModifier
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetHealth::OnRep_HealthRegenAmountModifier(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetHealth", "OnRep_HealthRegenAmountModifier");

	Params::RedpointAttributeSetHealth_OnRep_HealthRegenAmountModifier Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetHealth.OnRep_HealthRegenDelay
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetHealth::OnRep_HealthRegenDelay(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetHealth", "OnRep_HealthRegenDelay");

	Params::RedpointAttributeSetHealth_OnRep_HealthRegenDelay Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetHealth.OnRep_MaximumHealth
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetHealth::OnRep_MaximumHealth(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetHealth", "OnRep_MaximumHealth");

	Params::RedpointAttributeSetHealth_OnRep_MaximumHealth Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetInteract.OnRep_InteractDistance
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetInteract::OnRep_InteractDistance(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetInteract", "OnRep_InteractDistance");

	Params::RedpointAttributeSetInteract_OnRep_InteractDistance Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetJetpack.OnRep_JetpackLengthTime
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetJetpack::OnRep_JetpackLengthTime(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetJetpack", "OnRep_JetpackLengthTime");

	Params::RedpointAttributeSetJetpack_OnRep_JetpackLengthTime Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetJetpack.OnRep_JetpackStrength
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetJetpack::OnRep_JetpackStrength(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetJetpack", "OnRep_JetpackStrength");

	Params::RedpointAttributeSetJetpack_OnRep_JetpackStrength Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetMovement.OnRep_MovementSpeed
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetMovement::OnRep_MovementSpeed(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetMovement", "OnRep_MovementSpeed");

	Params::RedpointAttributeSetMovement_OnRep_MovementSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetReserveAmmo.OnRep_CurrentReserveAmmo
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetReserveAmmo::OnRep_CurrentReserveAmmo(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetReserveAmmo", "OnRep_CurrentReserveAmmo");

	Params::RedpointAttributeSetReserveAmmo_OnRep_CurrentReserveAmmo Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetReserveAmmo.OnRep_MaximumReserveAmmo
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetReserveAmmo::OnRep_MaximumReserveAmmo(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetReserveAmmo", "OnRep_MaximumReserveAmmo");

	Params::RedpointAttributeSetReserveAmmo_OnRep_MaximumReserveAmmo Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetStun.OnRep_StunRecoveryHealthAmount
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetStun::OnRep_StunRecoveryHealthAmount(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetStun", "OnRep_StunRecoveryHealthAmount");

	Params::RedpointAttributeSetStun_OnRep_StunRecoveryHealthAmount Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointAttributeSetStun.OnRep_StunTime
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointAttributeSetStun::OnRep_StunTime(const struct FGameplayAttributeData& OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointAttributeSetStun", "OnRep_StunTime");

	Params::RedpointAttributeSetStun_OnRep_StunTime Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.DropAllItems
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointBackpackComponent::DropAllItems(bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "DropAllItems");

	Params::RedpointBackpackComponent_DropAllItems Parms{};

	Parms.bForce = bForce;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.DropItem
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class ARedpointBackpackItem*            Item                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URedpointBackpackComponent::DropItem(class ARedpointBackpackItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "DropItem");

	Params::RedpointBackpackComponent_DropItem Parms{};

	Parms.Item = Item;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.GetCurrentItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ARedpointBackpackItem*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ARedpointBackpackItem* URedpointBackpackComponent::GetCurrentItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "GetCurrentItem");

	Params::RedpointBackpackComponent_GetCurrentItem Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.GetItemCount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URedpointBackpackComponent::GetItemCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "GetItemCount");

	Params::RedpointBackpackComponent_GetItemCount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.GetItemIndex
// (Final, Native, Protected)
// Parameters:
// class ARedpointBackpackItem*            Item                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URedpointBackpackComponent::GetItemIndex(class ARedpointBackpackItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "GetItemIndex");

	Params::RedpointBackpackComponent_GetItemIndex Parms{};

	Parms.Item = Item;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.GetItemInSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InSlot                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ARedpointBackpackItem*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ARedpointBackpackItem* URedpointBackpackComponent::GetItemInSlot(int32 InSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "GetItemInSlot");

	Params::RedpointBackpackComponent_GetItemInSlot Parms{};

	Parms.InSlot = InSlot;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.GetSlotCount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 URedpointBackpackComponent::GetSlotCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "GetSlotCount");

	Params::RedpointBackpackComponent_GetSlotCount Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.OnRep_CurrentItem
// (Final, Native, Protected)
// Parameters:
// class ARedpointBackpackItem*            PreviousItem                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointBackpackComponent::OnRep_CurrentItem(class ARedpointBackpackItem* PreviousItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "OnRep_CurrentItem");

	Params::RedpointBackpackComponent_OnRep_CurrentItem Parms{};

	Parms.PreviousItem = PreviousItem;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.OnRep_Items
// (Final, Native, Protected)

void URedpointBackpackComponent::OnRep_Items()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "OnRep_Items");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.PickupItem
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class ARedpointBackpackItem*            Item                                                   (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool URedpointBackpackComponent::PickupItem(class ARedpointBackpackItem* Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "PickupItem");

	Params::RedpointBackpackComponent_PickupItem Parms{};

	Parms.Item = Item;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.RequestItemEquipOnServer
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class ARedpointBackpackItem*            NewItem                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointBackpackComponent::RequestItemEquipOnServer(class ARedpointBackpackItem* NewItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "RequestItemEquipOnServer");

	Params::RedpointBackpackComponent_RequestItemEquipOnServer Parms{};

	Parms.NewItem = NewItem;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.SelectNextItem
// (Native, Public, BlueprintCallable)

void URedpointBackpackComponent::SelectNextItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "SelectNextItem");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.SelectPreviousItem
// (Native, Public, BlueprintCallable)

void URedpointBackpackComponent::SelectPreviousItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "SelectPreviousItem");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.SyncCurrentItemToClient
// (Final, Net, NetReliable, Native, Event, Private, NetClient)
// Parameters:
// class ARedpointBackpackItem*            InItem                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointBackpackComponent::SyncCurrentItemToClient(class ARedpointBackpackItem* InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "SyncCurrentItemToClient");

	Params::RedpointBackpackComponent_SyncCurrentItemToClient Parms{};

	Parms.InItem = InItem;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackComponent.SyncCurrentItemToServer
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void URedpointBackpackComponent::SyncCurrentItemToServer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackComponent", "SyncCurrentItemToServer");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.OnRep_WeaponCurrentClipAmmo
// (Native, Public)
// Parameters:
// int32                                   OldValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARedpointBackpackItem::OnRep_WeaponCurrentClipAmmo(int32 OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "OnRep_WeaponCurrentClipAmmo");

	Params::RedpointBackpackItem_OnRep_WeaponCurrentClipAmmo Parms{};

	Parms.OldValue = OldValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.OnRep_WeaponMaximumClipAmmo
// (Native, Public)
// Parameters:
// int32                                   OldValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARedpointBackpackItem::OnRep_WeaponMaximumClipAmmo(int32 OldValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "OnRep_WeaponMaximumClipAmmo");

	Params::RedpointBackpackItem_OnRep_WeaponMaximumClipAmmo Parms{};

	Parms.OldValue = OldValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.SetWeaponCurrentClipAmmo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   CurrentAmmo                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARedpointBackpackItem::SetWeaponCurrentClipAmmo(int32 CurrentAmmo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "SetWeaponCurrentClipAmmo");

	Params::RedpointBackpackItem_SetWeaponCurrentClipAmmo Parms{};

	Parms.CurrentAmmo = CurrentAmmo;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.SetWeaponMaximumClipAmmo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   MaximumAmmo                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ARedpointBackpackItem::SetWeaponMaximumClipAmmo(int32 MaximumAmmo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "SetWeaponMaximumClipAmmo");

	Params::RedpointBackpackItem_SetWeaponMaximumClipAmmo Parms{};

	Parms.MaximumAmmo = MaximumAmmo;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.GetItemMesh1P
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* ARedpointBackpackItem::GetItemMesh1P() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "GetItemMesh1P");

	Params::RedpointBackpackItem_GetItemMesh1P Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.GetItemMesh3P
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* ARedpointBackpackItem::GetItemMesh3P() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "GetItemMesh3P");

	Params::RedpointBackpackItem_GetItemMesh3P Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.GetWeaponCurrentClipAmmo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ARedpointBackpackItem::GetWeaponCurrentClipAmmo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "GetWeaponCurrentClipAmmo");

	Params::RedpointBackpackItem_GetWeaponCurrentClipAmmo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItem.GetWeaponMaximumClipAmmo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ARedpointBackpackItem::GetWeaponMaximumClipAmmo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointBackpackItem", "GetWeaponMaximumClipAmmo");

	Params::RedpointBackpackItem_GetWeaponMaximumClipAmmo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItemAttachmentInterface.GetAttachmentPoint
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName IRedpointBackpackItemAttachmentInterface::GetAttachmentPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointBackpackItemAttachmentInterface", "GetAttachmentPoint");

	Params::RedpointBackpackItemAttachmentInterface_GetAttachmentPoint Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItemAttachmentInterface.GetFirstPersonMesh
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* IRedpointBackpackItemAttachmentInterface::GetFirstPersonMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointBackpackItemAttachmentInterface", "GetFirstPersonMesh");

	Params::RedpointBackpackItemAttachmentInterface_GetFirstPersonMesh Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItemAttachmentInterface.GetThirdPersonMesh
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* IRedpointBackpackItemAttachmentInterface::GetThirdPersonMesh()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointBackpackItemAttachmentInterface", "GetThirdPersonMesh");

	Params::RedpointBackpackItemAttachmentInterface_GetThirdPersonMesh Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItemAttachmentInterface.IsInFirstPersonPerspective
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IRedpointBackpackItemAttachmentInterface::IsInFirstPersonPerspective()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointBackpackItemAttachmentInterface", "IsInFirstPersonPerspective");

	Params::RedpointBackpackItemAttachmentInterface_IsInFirstPersonPerspective Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointBackpackItemNotificationInterface.OnItemChanged
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ARedpointBackpackItem*            NewItem                                                (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ARedpointBackpackItem*            PreviousItem                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IRedpointBackpackItemNotificationInterface::OnItemChanged(class ARedpointBackpackItem* NewItem, class ARedpointBackpackItem* PreviousItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointBackpackItemNotificationInterface", "OnItemChanged");

	Params::RedpointBackpackItemNotificationInterface_OnItemChanged Parms{};

	Parms.NewItem = NewItem;
	Parms.PreviousItem = PreviousItem;

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

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

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointConsoleCommand.HandleCommand
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<class FString>&            Arguments                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void URedpointConsoleCommand::HandleCommand(const TArray<class FString>& Arguments)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointConsoleCommand", "HandleCommand");

	Params::RedpointConsoleCommand_HandleCommand Parms{};

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

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


// Function RedpointEOSFrameworkExtra.RedpointConsoleCommand.OutputString
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// ERedpointConsoleCommandLogVerbosity     Verbosity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Message                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointConsoleCommand::OutputString(ERedpointConsoleCommandLogVerbosity Verbosity, const class FString& Message)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("RedpointConsoleCommand", "OutputString");

	Params::RedpointConsoleCommand_OutputString Parms{};

	Parms.Verbosity = Verbosity;
	Parms.Message = std::move(Message);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointDamageNotificationInterface.OnDealtDamageToTarget
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   DamageDealt                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IRedpointDamageNotificationInterface::OnDealtDamageToTarget(int32 DamageDealt, class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointDamageNotificationInterface", "OnDealtDamageToTarget");

	Params::RedpointDamageNotificationInterface_OnDealtDamageToTarget Parms{};

	Parms.DamageDealt = DamageDealt;
	Parms.TargetActor = TargetActor;

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

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

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointDamageNotificationInterface.OnKilledTargetActor
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UAbilitySystemComponent*          SourceAbilitySystem                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilitySystemComponent*          TargetAbilitySystem                                    (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IRedpointDamageNotificationInterface::OnKilledTargetActor(class UAbilitySystemComponent* SourceAbilitySystem, class AActor* TargetActor, class UAbilitySystemComponent* TargetAbilitySystem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointDamageNotificationInterface", "OnKilledTargetActor");

	Params::RedpointDamageNotificationInterface_OnKilledTargetActor Parms{};

	Parms.SourceAbilitySystem = SourceAbilitySystem;
	Parms.TargetActor = TargetActor;
	Parms.TargetAbilitySystem = TargetAbilitySystem;

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

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

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointFrameworkExtraBlueprintLibrary.GetAllUserAttributes
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FUniqueNetIdRepl&          TargetUserId                                           (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TMap<class FString, class FString>      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

TMap<class FString, class FString> URedpointFrameworkExtraBlueprintLibrary::GetAllUserAttributes(class UObject* WorldContextObject, const struct FUniqueNetIdRepl& TargetUserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointFrameworkExtraBlueprintLibrary", "GetAllUserAttributes");

	Params::RedpointFrameworkExtraBlueprintLibrary_GetAllUserAttributes Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointFrameworkExtraBlueprintLibrary.InduceStutter
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                                   Seconds                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointFrameworkExtraBlueprintLibrary::InduceStutter(float Seconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointFrameworkExtraBlueprintLibrary", "InduceStutter");

	Params::RedpointFrameworkExtraBlueprintLibrary_InduceStutter Parms{};

	Parms.Seconds = Seconds;

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

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

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointFrameworkExtraBlueprintLibrary.RestartLevel
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void URedpointFrameworkExtraBlueprintLibrary::RestartLevel(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("RedpointFrameworkExtraBlueprintLibrary", "RestartLevel");

	Params::RedpointFrameworkExtraBlueprintLibrary_RestartLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function RedpointEOSFrameworkExtra.RedpointHasBackpackInterface.GetBackpack
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class URedpointBackpackComponent*       ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class URedpointBackpackComponent* IRedpointHasBackpackInterface::GetBackpack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointHasBackpackInterface", "GetBackpack");

	Params::RedpointHasBackpackInterface_GetBackpack Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointIsAliveInterface.IsAlive
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool IRedpointIsAliveInterface::IsAlive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointIsAliveInterface", "IsAlive");

	Params::RedpointIsAliveInterface_IsAlive Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function RedpointEOSFrameworkExtra.RedpointOverridesMaxSpeedInterface.GetMaxSpeed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IRedpointOverridesMaxSpeedInterface::GetMaxSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("RedpointOverridesMaxSpeedInterface", "GetMaxSpeed");

	Params::RedpointOverridesMaxSpeedInterface_GetMaxSpeed Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


SDK_NAMESPACE_END
