// Function ConanSandbox.GUIModuleController.ActivateModule
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   ModuleName                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           Activate                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           Force                          (Parm, ZeroConstructor, IsPlainOldData)
// class UWindowRoot*             ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UWindowRoot* UGUIModuleController::ActivateModule(const struct FName& ModuleName, bool Activate, bool Force)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.GUIModuleController.ActivateModule");

    UGUIModuleController_ActivateModule_Params params;
    params.ModuleName = ModuleName;
    params.Activate = Activate;
    params.Force = Force;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.WaitForServerdDayCycleToCatchUp
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::WaitForServerdDayCycleToCatchUp()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.WaitForServerdDayCycleToCatchUp");

    AConanCharacter_WaitForServerdDayCycleToCatchUp_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ValidateFeatVersion
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AConanCharacter::ValidateFeatVersion()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ValidateFeatVersion");

    AConanCharacter_ValidateFeatVersion_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.UseItem
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::UseItem()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.UseItem");

    AConanCharacter_UseItem_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.UpdateSpeaking
// (Final, Native, Private)
// Parameters:
// bool                           speaking                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::UpdateSpeaking(bool speaking)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.UpdateSpeaking");

    AConanCharacter_UpdateSpeaking_Params params;
    params.speaking = speaking;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.UpdateRotationWhenThirdPersonPassiveGamepad
// (Native, Public, BlueprintCallable)

void AConanCharacter::UpdateRotationWhenThirdPersonPassiveGamepad()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.UpdateRotationWhenThirdPersonPassiveGamepad");

    AConanCharacter_UpdateRotationWhenThirdPersonPassiveGamepad_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.UpdateMaxMovementSpeed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AConanCharacter::UpdateMaxMovementSpeed()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.UpdateMaxMovementSpeed");

    AConanCharacter_UpdateMaxMovementSpeed_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.UpdateGuildMapmarkerPosition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          mapUpdateRange                 (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::UpdateGuildMapmarkerPosition(float mapUpdateRange)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.UpdateGuildMapmarkerPosition");

    AConanCharacter_UpdateGuildMapmarkerPosition_Params params;
    params.mapUpdateRange = mapUpdateRange;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.UpdateClientGUIControlMode
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EGUIControlMode>   newMode                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::UpdateClientGUIControlMode(TEnumAsByte<EGUIControlMode> newMode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.UpdateClientGUIControlMode");

    AConanCharacter_UpdateClientGUIControlMode_Params params;
    params.newMode = newMode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.TakeAllLootItems
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// class AActor*                  LootContainer                  (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::TakeAllLootItems(class AActor* LootContainer)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.TakeAllLootItems");

    AConanCharacter_TakeAllLootItems_Params params;
    params.LootContainer = LootContainer;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SurfaceTypeChanged
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FHitResult              HitResult                      (ConstParm, Parm, IsPlainOldData)

void AConanCharacter::SurfaceTypeChanged(const struct FHitResult& HitResult)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SurfaceTypeChanged");

    AConanCharacter_SurfaceTypeChanged_Params params;
    params.HitResult = HitResult;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.StartDoubleJumpTimeoutTimer
// (Native, Public, BlueprintCallable)

void AConanCharacter::StartDoubleJumpTimeoutTimer()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.StartDoubleJumpTimeoutTimer");

    AConanCharacter_StartDoubleJumpTimeoutTimer_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.StaminaDegenerationBitmaskToggle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            BitMask                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::StaminaDegenerationBitmaskToggle(int BitMask)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.StaminaDegenerationBitmaskToggle");

    AConanCharacter_StaminaDegenerationBitmaskToggle_Params params;
    params.BitMask = BitMask;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.StaminaDegenerationBitmaskSet
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            BitMask                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::StaminaDegenerationBitmaskSet(int BitMask)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.StaminaDegenerationBitmaskSet");

    AConanCharacter_StaminaDegenerationBitmaskSet_Params params;
    params.BitMask = BitMask;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.StaminaDegenerationBitmaskClear
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            BitMask                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::StaminaDegenerationBitmaskClear(int BitMask)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.StaminaDegenerationBitmaskClear");

    AConanCharacter_StaminaDegenerationBitmaskClear_Params params;
    params.BitMask = BitMask;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SpawnTemplateItem
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int                            TemplateId                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            quantity                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          durabilityPercentage           (Parm, ZeroConstructor, IsPlainOldData)
// float                          durability                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ShowNotification               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::SpawnTemplateItem(int TemplateId, int quantity, float durabilityPercentage, float durability, bool ShowNotification)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SpawnTemplateItem");

    AConanCharacter_SpawnTemplateItem_Params params;
    params.TemplateId = TemplateId;
    params.quantity = quantity;
    params.durabilityPercentage = durabilityPercentage;
    params.durability = durability;
    params.ShowNotification = ShowNotification;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.SlotItemContainerSizeStatChanged
// (Final, Native, Private)
// Parameters:
// class AActor*                  Actor                          (Parm, ZeroConstructor, IsPlainOldData)
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            NewValue                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            deltaValue                     (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SlotItemContainerSizeStatChanged(class AActor* Actor, ECharIntStatID statID, int NewValue, int deltaValue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SlotItemContainerSizeStatChanged");

    AConanCharacter_SlotItemContainerSizeStatChanged_Params params;
    params.Actor = Actor;
    params.statID = statID;
    params.NewValue = NewValue;
    params.deltaValue = deltaValue;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SlotIntStatChanged
// (Final, Native, Public)
// Parameters:
// class UStatHolder*             StatHolder                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            NewValue                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            deltaValue                     (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SlotIntStatChanged(class UStatHolder* StatHolder, ECharIntStatID statID, int NewValue, int deltaValue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SlotIntStatChanged");

    AConanCharacter_SlotIntStatChanged_Params params;
    params.StatHolder = StatHolder;
    params.statID = statID;
    params.NewValue = NewValue;
    params.deltaValue = deltaValue;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SlotInteractioActorGUIModuleActivated
// (Final, Native, Public)
// Parameters:
// class UGUIModule*              module                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           activated                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SlotInteractioActorGUIModuleActivated(class UGUIModule* module, bool activated)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SlotInteractioActorGUIModuleActivated");

    AConanCharacter_SlotInteractioActorGUIModuleActivated_Params params;
    params.module = module;
    params.activated = activated;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SlotInteractingActorDestroyed
// (Final, Native, Public)
// Parameters:
// class AActor*                  DestroyedActor                 (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SlotInteractingActorDestroyed(class AActor* DestroyedActor)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SlotInteractingActorDestroyed");

    AConanCharacter_SlotInteractingActorDestroyed_Params params;
    params.DestroyedActor = DestroyedActor;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.SignalClientOnDamageTakenDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// class AActor*                  Attacker                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SignalClientOnDamageTakenDelegate__DelegateSignature(class AActor* Attacker)
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.SignalClientOnDamageTakenDelegate__DelegateSignature");

    AConanCharacter_SignalClientOnDamageTakenDelegate__DelegateSignature_Params params;
    params.Attacker = Attacker;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.SignalCharacterIsBuildingThrallDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           isBuildingThrall               (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SignalCharacterIsBuildingThrallDelegate__DelegateSignature(bool isBuildingThrall)
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.SignalCharacterIsBuildingThrallDelegate__DelegateSignature");

    AConanCharacter_SignalCharacterIsBuildingThrallDelegate__DelegateSignature_Params params;
    params.isBuildingThrall = isBuildingThrall;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.SignalCharacterIsBuildingDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           isBuilding                     (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SignalCharacterIsBuildingDelegate__DelegateSignature(bool isBuilding)
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.SignalCharacterIsBuildingDelegate__DelegateSignature");

    AConanCharacter_SignalCharacterIsBuildingDelegate__DelegateSignature_Params params;
    params.isBuilding = isBuilding;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ShowCharacterBiography
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                 characterObject                (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ShowCharacterBiography(class UObject* characterObject)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ShowCharacterBiography");

    AConanCharacter_ShowCharacterBiography_Params params;
    params.characterObject = characterObject;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ShouldNotBeSpawnedOffline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::ShouldNotBeSpawnedOffline()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ShouldNotBeSpawnedOffline");

    AConanCharacter_ShouldNotBeSpawnedOffline_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.SetUROEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           enableURO                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetUROEnabled(bool enableURO)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetUROEnabled");

    AConanCharacter_SetUROEnabled_Params params;
    params.enableURO = enableURO;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 stat                           (Parm, ZeroConstructor)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetStat(const struct FString& stat, float Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetStat");

    AConanCharacter_SetStat_Params params;
    params.stat = stat;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetStaminaRecentlyExhausted
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::SetStaminaRecentlyExhausted()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetStaminaRecentlyExhausted");

    AConanCharacter_SetStaminaRecentlyExhausted_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetKillerName
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FText                   killerNameInput                (ConstParm, Parm, OutParm, ReferenceParm)
// class AConanCharacter*         killer                         (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetKillerName(const struct FText& killerNameInput, class AConanCharacter* killer)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetKillerName");

    AConanCharacter_SetKillerName_Params params;
    params.killerNameInput = killerNameInput;
    params.killer = killer;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetIntStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetIntStat(ECharIntStatID statID, int Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetIntStat");

    AConanCharacter_SetIntStat_Params params;
    params.statID = statID;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetInteractingActor
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Actor                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   guiModuleName                  (Parm, ZeroConstructor, IsPlainOldData)
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetInteractingActor(class AActor* Actor, const struct FName& guiModuleName, class UObject* WorldContextObject)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetInteractingActor");

    AConanCharacter_SetInteractingActor_Params params;
    params.Actor = Actor;
    params.guiModuleName = guiModuleName;
    params.WorldContextObject = WorldContextObject;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetHealthRegen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Input                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetHealthRegen(float Input)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetHealthRegen");

    AConanCharacter_SetHealthRegen_Params params;
    params.Input = Input;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetGuildId
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUniqueID*               guildId                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetGuildId(class UUniqueID* guildId)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetGuildId");

    AConanCharacter_SetGuildId_Params params;
    params.guildId = guildId;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetFloatStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetFloatStat(ECharFloatStatID statID, float Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetFloatStat");

    AConanCharacter_SetFloatStat_Params params;
    params.statID = statID;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetDirectionalMovementMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bUseDirectionalMovementMode    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           Force                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetDirectionalMovementMode(bool bUseDirectionalMovementMode, bool Force)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetDirectionalMovementMode");

    AConanCharacter_SetDirectionalMovementMode_Params params;
    params.bUseDirectionalMovementMode = bUseDirectionalMovementMode;
    params.Force = Force;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetClimbingStaminaCostModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetClimbingStaminaCostModifier(float Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetClimbingStaminaCostModifier");

    AConanCharacter_SetClimbingStaminaCostModifier_Params params;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetCharacterState
// (Native, Public, BlueprintCallable)
// Parameters:
// ECharacterState                newState                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::SetCharacterState(ECharacterState newState)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetCharacterState");

    AConanCharacter_SetCharacterState_Params params;
    params.newState = newState;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.SetCharacterSpawnTableID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   SpawnTableID                   (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetCharacterSpawnTableID(const struct FName& SpawnTableID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetCharacterSpawnTableID");

    AConanCharacter_SetCharacterSpawnTableID_Params params;
    params.SpawnTableID = SpawnTableID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetCharacterName
// (Native, Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FText                   Name                           (ConstParm, Parm, OutParm, ReferenceParm)

void AConanCharacter::SetCharacterName(const struct FText& Name)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetCharacterName");

    AConanCharacter_SetCharacterName_Params params;
    params.Name = Name;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetCharacterIsBuildingThrall
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           isBuildingThrall               (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetCharacterIsBuildingThrall(bool isBuildingThrall)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetCharacterIsBuildingThrall");

    AConanCharacter_SetCharacterIsBuildingThrall_Params params;
    params.isBuildingThrall = isBuildingThrall;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetCharacterIsBuilding
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           isBuilding                     (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetCharacterIsBuilding(bool isBuilding)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetCharacterIsBuilding");

    AConanCharacter_SetCharacterIsBuilding_Params params;
    params.isBuilding = isBuilding;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.SetBase
// (Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*     NewBase                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FName                   BoneName                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// bool                           bNotifyActor                   (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::SetBase(class UPrimitiveComponent* NewBase, const struct FName& BoneName, bool bNotifyActor)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.SetBase");

    AConanCharacter_SetBase_Params params;
    params.NewBase = NewBase;
    params.BoneName = BoneName;
    params.bNotifyActor = bNotifyActor;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerUpdateFeatVersion
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AConanCharacter::ServerUpdateFeatVersion()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerUpdateFeatVersion");

    AConanCharacter_ServerUpdateFeatVersion_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerUpdateClientGUIControlMode
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TEnumAsByte<EGUIControlMode>   newMode                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerUpdateClientGUIControlMode(TEnumAsByte<EGUIControlMode> newMode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerUpdateClientGUIControlMode");

    AConanCharacter_ServerUpdateClientGUIControlMode_Params params;
    params.newMode = newMode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerUpdateCharacterBio
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// struct FText                   newBio                         (ConstParm, Parm, ReferenceParm)
// class AConanPlayerController*  lastToEdit                     (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerUpdateCharacterBio(const struct FText& newBio, class AConanPlayerController* lastToEdit)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerUpdateCharacterBio");

    AConanCharacter_ServerUpdateCharacterBio_Params params;
    params.newBio = newBio;
    params.lastToEdit = lastToEdit;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerSetIntStat
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerSetIntStat(ECharIntStatID statID, int Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerSetIntStat");

    AConanCharacter_ServerSetIntStat_Params params;
    params.statID = statID;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerSetFloatStat
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerSetFloatStat(ECharFloatStatID statID, float Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerSetFloatStat");

    AConanCharacter_ServerSetFloatStat_Params params;
    params.statID = statID;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerSetDirectionalMovementMode
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           bMovementMode                  (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerSetDirectionalMovementMode(bool bMovementMode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerSetDirectionalMovementMode");

    AConanCharacter_ServerSetDirectionalMovementMode_Params params;
    params.bMovementMode = bMovementMode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerSetBiographySharing
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// EBiographySharing              newSharingPolicy               (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerSetBiographySharing(EBiographySharing newSharingPolicy)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerSetBiographySharing");

    AConanCharacter_ServerSetBiographySharing_Params params;
    params.newSharingPolicy = newSharingPolicy;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerSetBiographyAccess
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// EBiographyAccess               newSharingPolicy               (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerSetBiographyAccess(EBiographyAccess newSharingPolicy)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerSetBiographyAccess");

    AConanCharacter_ServerSetBiographyAccess_Params params;
    params.newSharingPolicy = newSharingPolicy;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerSendGuildInvite
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int64_t                        PlayerId                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerSendGuildInvite(int64_t PlayerId)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerSendGuildInvite");

    AConanCharacter_ServerSendGuildInvite_Params params;
    params.PlayerId = PlayerId;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerResetAllFeats
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AConanCharacter::ServerResetAllFeats()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerResetAllFeats");

    AConanCharacter_ServerResetAllFeats_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerRepairItem
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            itemID                         (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerRepairItem(int itemID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerRepairItem");

    AConanCharacter_ServerRepairItem_Params params;
    params.itemID = itemID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerRepairCraftingQueueItem
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UItemInventory*          inventory                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// uint32_t                       Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class UCraftingQueue*          CraftingQueue                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AConanCharacter::ServerRepairCraftingQueueItem(class UItemInventory* inventory, uint32_t Slot, class UCraftingQueue* CraftingQueue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerRepairCraftingQueueItem");

    AConanCharacter_ServerRepairCraftingQueueItem_Params params;
    params.inventory = inventory;
    params.Slot = Slot;
    params.CraftingQueue = CraftingQueue;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerRemoveRecipeFromQueue
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UCraftingQueue*          queue                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerRemoveRecipeFromQueue(class UCraftingQueue* queue, int Index, int Count)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerRemoveRecipeFromQueue");

    AConanCharacter_ServerRemoveRecipeFromQueue_Params params;
    params.queue = queue;
    params.Index = Index;
    params.Count = Count;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerRemoveAllRecipes
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UCraftingQueue*          queue                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AConanCharacter::ServerRemoveAllRecipes(class UCraftingQueue* queue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerRemoveAllRecipes");

    AConanCharacter_ServerRemoveAllRecipes_Params params;
    params.queue = queue;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerPurchaseFeat
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            featID                         (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerPurchaseFeat(int featID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerPurchaseFeat");

    AConanCharacter_ServerPurchaseFeat_Params params;
    params.featID = featID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerPromoteToGuildMaster
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int64_t                        newGuildMaster                 (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerPromoteToGuildMaster(int64_t newGuildMaster)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerPromoteToGuildMaster");

    AConanCharacter_ServerPromoteToGuildMaster_Params params;
    params.newGuildMaster = newGuildMaster;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerPromoteGuildMember
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int64_t                        characterIdToPromote           (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerPromoteGuildMember(int64_t characterIdToPromote)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerPromoteGuildMember");

    AConanCharacter_ServerPromoteGuildMember_Params params;
    params.characterIdToPromote = characterIdToPromote;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerProcessGuildInviteResponse
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TEnumAsByte<EInviteResponse>   response                       (Parm, ZeroConstructor, IsPlainOldData)
// class UUniqueID*               guildId                        (Parm, ZeroConstructor, IsPlainOldData)
// class UUniqueID*               senderId                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerProcessGuildInviteResponse(TEnumAsByte<EInviteResponse> response, class UUniqueID* guildId, class UUniqueID* senderId)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerProcessGuildInviteResponse");

    AConanCharacter_ServerProcessGuildInviteResponse_Params params;
    params.response = response;
    params.guildId = guildId;
    params.senderId = senderId;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerLeaveGuild
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AConanCharacter::ServerLeaveGuild()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerLeaveGuild");

    AConanCharacter_ServerLeaveGuild_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerKickPlayer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int64_t                        playerToKick                   (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerKickPlayer(int64_t playerToKick)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerKickPlayer");

    AConanCharacter_ServerKickPlayer_Params params;
    params.playerToKick = playerToKick;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerIsFeatVersionUpToDate
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AConanCharacter::ServerIsFeatVersionUpToDate()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerIsFeatVersionUpToDate");

    AConanCharacter_ServerIsFeatVersionUpToDate_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerInteractionDisabled
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class AActor*                  Actor                          (Parm, ZeroConstructor, IsPlainOldData)
// class APlayerController*       playerInstigator               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           clearInteractionActor          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerInteractionDisabled(class AActor* Actor, class APlayerController* playerInstigator, bool clearInteractionActor)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerInteractionDisabled");

    AConanCharacter_ServerInteractionDisabled_Params params;
    params.Actor = Actor;
    params.playerInstigator = playerInstigator;
    params.clearInteractionActor = clearInteractionActor;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerGetThrallCharacterLayout
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UItemInventory*          inventory                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerGetThrallCharacterLayout(class UItemInventory* inventory, int Index)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerGetThrallCharacterLayout");

    AConanCharacter_ServerGetThrallCharacterLayout_Params params;
    params.inventory = inventory;
    params.Index = Index;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerGetPlayersValidForGuildInvite
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UUniqueID*               guildId                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerGetPlayersValidForGuildInvite(class UUniqueID* guildId)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerGetPlayersValidForGuildInvite");

    AConanCharacter_ServerGetPlayersValidForGuildInvite_Params params;
    params.guildId = guildId;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerFindNamedOwnerForLandClaim
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// int64_t                        LandClaimOwnerId               (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerFindNamedOwnerForLandClaim(int64_t LandClaimOwnerId)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerFindNamedOwnerForLandClaim");

    AConanCharacter_ServerFindNamedOwnerForLandClaim_Params params;
    params.LandClaimOwnerId = LandClaimOwnerId;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerExitClimbing
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AConanCharacter::ServerExitClimbing()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerExitClimbing");

    AConanCharacter_ServerExitClimbing_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerEditMessageOfTheDay
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FText                   newMessage                     (ConstParm, Parm, ReferenceParm)

void AConanCharacter::ServerEditMessageOfTheDay(const struct FText& newMessage)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerEditMessageOfTheDay");

    AConanCharacter_ServerEditMessageOfTheDay_Params params;
    params.newMessage = newMessage;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerEditGuildName
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FText                   newName                        (ConstParm, Parm, ReferenceParm)

void AConanCharacter::ServerEditGuildName(const struct FText& newName)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerEditGuildName");

    AConanCharacter_ServerEditGuildName_Params params;
    params.newName = newName;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerDyeItem
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// class UItemInventory*          inventory                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            Color                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            Channel                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerDyeItem(int Index, class UItemInventory* inventory, int Color, int Channel)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerDyeItem");

    AConanCharacter_ServerDyeItem_Params params;
    params.Index = Index;
    params.inventory = inventory;
    params.Color = Color;
    params.Channel = Channel;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerDropInventoryItem
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UItemInventory*          inventory                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerDropInventoryItem(class UItemInventory* inventory, int Index)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerDropInventoryItem");

    AConanCharacter_ServerDropInventoryItem_Params params;
    params.inventory = inventory;
    params.Index = Index;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerDestroyGuild
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EMessageBoxDialogResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerDestroyGuild(EMessageBoxDialogResult Result)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerDestroyGuild");

    AConanCharacter_ServerDestroyGuild_Params params;
    params.Result = Result;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerDemoteGuildMember
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int64_t                        characterIdToDemote            (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerDemoteGuildMember(int64_t characterIdToDemote)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerDemoteGuildMember");

    AConanCharacter_ServerDemoteGuildMember_Params params;
    params.characterIdToDemote = characterIdToDemote;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerCreateGuild
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FString                 guildName                      (Parm, ZeroConstructor)

void AConanCharacter::ServerCreateGuild(const struct FString& guildName)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerCreateGuild");

    AConanCharacter_ServerCreateGuild_Params params;
    params.guildName = guildName;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerCheckTimeOfDay
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)

void AConanCharacter::ServerCheckTimeOfDay()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerCheckTimeOfDay");

    AConanCharacter_ServerCheckTimeOfDay_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerAddRecipeToQueue
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UCraftingQueue*          queue                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerAddRecipeToQueue(class UCraftingQueue* queue, int Index, int Count)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerAddRecipeToQueue");

    AConanCharacter_ServerAddRecipeToQueue_Params params;
    params.queue = queue;
    params.Index = Index;
    params.Count = Count;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ServerAddArtisanRecipeToQueue
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UCraftingQueue*          queue                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UItemInventory*          sourceInventory                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ServerAddArtisanRecipeToQueue(class UCraftingQueue* queue, class UItemInventory* sourceInventory, int Index, int Count)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ServerAddArtisanRecipeToQueue");

    AConanCharacter_ServerAddArtisanRecipeToQueue_Params params;
    params.queue = queue;
    params.sourceInventory = sourceInventory;
    params.Index = Index;
    params.Count = Count;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.RootMotionAutoFrozen__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void AConanCharacter::RootMotionAutoFrozen__DelegateSignature()
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.RootMotionAutoFrozen__DelegateSignature");

    AConanCharacter_RootMotionAutoFrozen__DelegateSignature_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.RollDice
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            numberOfDice                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            numberOfEyes                   (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::RollDice(int numberOfDice, int numberOfEyes)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.RollDice");

    AConanCharacter_RollDice_Params params;
    params.numberOfDice = numberOfDice;
    params.numberOfEyes = numberOfEyes;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.Roll
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            MinValue                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            MaxValue                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::Roll(int MinValue, int MaxValue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.Roll");

    AConanCharacter_Roll_Params params;
    params.MinValue = MinValue;
    params.MaxValue = MaxValue;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ResetKiller
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::ResetKiller()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ResetKiller");

    AConanCharacter_ResetKiller_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.RemoveIntStatModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierID>   modifierID                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierOperator> operatorID                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::RemoveIntStatModifier(ECharIntStatID statID, TEnumAsByte<EStatModifierID> modifierID, TEnumAsByte<EStatModifierOperator> operatorID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.RemoveIntStatModifier");

    AConanCharacter_RemoveIntStatModifier_Params params;
    params.statID = statID;
    params.modifierID = modifierID;
    params.operatorID = operatorID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.RemoveFloatStatModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierID>   modifierID                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierOperator> operatorID                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::RemoveFloatStatModifier(ECharFloatStatID statID, TEnumAsByte<EStatModifierID> modifierID, TEnumAsByte<EStatModifierOperator> operatorID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.RemoveFloatStatModifier");

    AConanCharacter_RemoveFloatStatModifier_Params params;
    params.statID = statID;
    params.modifierID = modifierID;
    params.operatorID = operatorID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.RemoveCarriedCharacter
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AConanCharacter*         Character                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::RemoveCarriedCharacter(class AConanCharacter* Character)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.RemoveCarriedCharacter");

    AConanCharacter_RemoveCarriedCharacter_Params params;
    params.Character = Character;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.RemoveAllIntStatModifiers
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::RemoveAllIntStatModifiers(ECharIntStatID statID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.RemoveAllIntStatModifiers");

    AConanCharacter_RemoveAllIntStatModifiers_Params params;
    params.statID = statID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.RemoveAllFloatStatModifiers
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::RemoveAllFloatStatModifiers(ECharFloatStatID statID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.RemoveAllFloatStatModifiers");

    AConanCharacter_RemoveAllFloatStatModifiers_Params params;
    params.statID = statID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ReceiveSprintStaminaCostModifier
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AConanCharacter::ReceiveSprintStaminaCostModifier()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveSprintStaminaCostModifier");

    AConanCharacter_ReceiveSprintStaminaCostModifier_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ReceiveGetStaminaRegenMod
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AConanCharacter::ReceiveGetStaminaRegenMod()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveGetStaminaRegenMod");

    AConanCharacter_ReceiveGetStaminaRegenMod_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ReceiveGetHealthRegen
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AConanCharacter::ReceiveGetHealthRegen()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveGetHealthRegen");

    AConanCharacter_ReceiveGetHealthRegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ReceiveFCDamageEvent
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EFCDamageType>     FCDamageType                   (Parm, ZeroConstructor, IsPlainOldData)
// class UDamageType*             DamageType                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AController*             InstigatedBy                   (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ReceiveFCDamageEvent(float Damage, TEnumAsByte<EFCDamageType> FCDamageType, class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveFCDamageEvent");

    AConanCharacter_ReceiveFCDamageEvent_Params params;
    params.Damage = Damage;
    params.FCDamageType = FCDamageType;
    params.DamageType = DamageType;
    params.InstigatedBy = InstigatedBy;
    params.DamageCauser = DamageCauser;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ReceiveDataLoaded
// (Event, Public, BlueprintEvent)

void AConanCharacter::ReceiveDataLoaded()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveDataLoaded");

    AConanCharacter_ReceiveDataLoaded_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ReceiveClimbingStaminaCostModifier
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AConanCharacter::ReceiveClimbingStaminaCostModifier()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveClimbingStaminaCostModifier");

    AConanCharacter_ReceiveClimbingStaminaCostModifier_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ReceiveChargeHoldStaminaCostModifier
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AConanCharacter::ReceiveChargeHoldStaminaCostModifier()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveChargeHoldStaminaCostModifier");

    AConanCharacter_ReceiveChargeHoldStaminaCostModifier_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ReceiveCanHealthRegen
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::ReceiveCanHealthRegen()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ReceiveCanHealthRegen");

    AConanCharacter_ReceiveCanHealthRegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.RecalculateCarriedPeopleWeight
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AConanCharacter::RecalculateCarriedPeopleWeight()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.RecalculateCarriedPeopleWeight");

    AConanCharacter_RecalculateCarriedPeopleWeight_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.PrintStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 stat                           (Parm, ZeroConstructor)

void AConanCharacter::PrintStat(const struct FString& stat)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.PrintStat");

    AConanCharacter_PrintStat_Params params;
    params.stat = stat;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnRootMotionEnd
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::OnRootMotionEnd()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnRootMotionEnd");

    AConanCharacter_OnRootMotionEnd_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnRootMotionBegin
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::OnRootMotionBegin()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnRootMotionBegin");

    AConanCharacter_OnRootMotionBegin_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnRep_InternalCharacterName
// (Final, Native, Private, Const)

void AConanCharacter::OnRep_InternalCharacterName()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnRep_InternalCharacterName");

    AConanCharacter_OnRep_InternalCharacterName_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnPurgeMusicRequested
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           Start                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnPurgeMusicRequested(bool Start)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnPurgeMusicRequested");

    AConanCharacter_OnPurgeMusicRequested_Params params;
    params.Start = Start;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnPurgeEventTrigered
// (Event, Public, BlueprintEvent)
// Parameters:
// EPurgeEventType                EventType                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnPurgeEventTrigered(EPurgeEventType EventType)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnPurgeEventTrigered");

    AConanCharacter_OnPurgeEventTrigered_Params params;
    params.EventType = EventType;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnPlayerTargeted
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                  TargetingActor                 (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnPlayerTargeted(class AActor* TargetingActor)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnPlayerTargeted");

    AConanCharacter_OnPlayerTargeted_Params params;
    params.TargetingActor = TargetingActor;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnPlayerTargetCleared
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                  TargetingActor                 (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnPlayerTargetCleared(class AActor* TargetingActor)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnPlayerTargetCleared");

    AConanCharacter_OnPlayerTargetCleared_Params params;
    params.TargetingActor = TargetingActor;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnMouseEnabled
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           IsEnabled                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnMouseEnabled(bool IsEnabled)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnMouseEnabled");

    AConanCharacter_OnMouseEnabled_Params params;
    params.IsEnabled = IsEnabled;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnItemRepairFinished
// (Final, Native, Private)
// Parameters:
// class UGameItem*               Item                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          repairXp                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnItemRepairFinished(class UGameItem* Item, float repairXp)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnItemRepairFinished");

    AConanCharacter_OnItemRepairFinished_Params params;
    params.Item = Item;
    params.repairXp = repairXp;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnGuildIdReplicated
// (Final, Native, Public)

void AConanCharacter::OnGuildIdReplicated()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnGuildIdReplicated");

    AConanCharacter_OnGuildIdReplicated_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnDoubleJumpTimeout
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::OnDoubleJumpTimeout()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnDoubleJumpTimeout");

    AConanCharacter_OnDoubleJumpTimeout_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnDoubleJumped
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AConanCharacter::OnDoubleJumped()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnDoubleJumped");

    AConanCharacter_OnDoubleJumped_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnCorruptionChanged
// (Final, Native, Public)
// Parameters:
// EnergyTypes                    Type                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnCorruptionChanged(EnergyTypes Type, float Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnCorruptionChanged");

    AConanCharacter_OnCorruptionChanged_Params params;
    params.Type = Type;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnCharacterIdReplicated
// (Final, Native, Public)

void AConanCharacter::OnCharacterIdReplicated()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnCharacterIdReplicated");

    AConanCharacter_OnCharacterIdReplicated_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnAttemptedToWalkOffNavMesh
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// class UCharacterMovementComponent* MovementComponent              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 OldLocation                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 NewLocation                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           IsContinuousCheck              (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::OnAttemptedToWalkOffNavMesh(class UCharacterMovementComponent* MovementComponent, const struct FVector& OldLocation, const struct FVector& NewLocation, bool IsContinuousCheck)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnAttemptedToWalkOffNavMesh");

    AConanCharacter_OnAttemptedToWalkOffNavMesh_Params params;
    params.MovementComponent = MovementComponent;
    params.OldLocation = OldLocation;
    params.NewLocation = NewLocation;
    params.IsContinuousCheck = IsContinuousCheck;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnAttackEnd
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::OnAttackEnd()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnAttackEnd");

    AConanCharacter_OnAttackEnd_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.OnAttackBegin
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::OnAttackBegin()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.OnAttackBegin");

    AConanCharacter_OnAttackBegin_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.MulticastOnTargetChanged
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class AConanCharacter*         NewTarget                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::MulticastOnTargetChanged(class AConanCharacter* NewTarget)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.MulticastOnTargetChanged");

    AConanCharacter_MulticastOnTargetChanged_Params params;
    params.NewTarget = NewTarget;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.MulticastOnBuildingTargetChanged
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class APlaceableBase*          NewTarget                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::MulticastOnBuildingTargetChanged(class APlaceableBase* NewTarget)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.MulticastOnBuildingTargetChanged");

    AConanCharacter_MulticastOnBuildingTargetChanged_Params params;
    params.NewTarget = NewTarget;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.MulticastClimbingEdgeTransition
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// float                          EdgeRelativeHeight             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           WasInitialTrace                (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::MulticastClimbingEdgeTransition(float EdgeRelativeHeight, bool WasInitialTrace)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.MulticastClimbingEdgeTransition");

    AConanCharacter_MulticastClimbingEdgeTransition_Params params;
    params.EdgeRelativeHeight = EdgeRelativeHeight;
    params.WasInitialTrace = WasInitialTrace;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.MoveUp
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AConanCharacter::MoveUp()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.MoveUp");

    AConanCharacter_MoveUp_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.MoveLootToInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UItemInventory*          lootInventory                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UItemInventory*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UItemInventory* AConanCharacter::MoveLootToInventory(class UItemInventory* lootInventory)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.MoveLootToInventory");

    AConanCharacter_MoveLootToInventory_Params params;
    params.lootInventory = lootInventory;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.MoveDown
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AConanCharacter::MoveDown()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.MoveDown");

    AConanCharacter_MoveDown_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.KillCharacter
// (Native, Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// TEnumAsByte<EHitlocation>      HitLocation                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FText                   killerNameInput                (ConstParm, Parm, OutParm, ReferenceParm)
// class AConanCharacter*         killer                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AConanCharacter::KillCharacter(TEnumAsByte<EHitlocation> HitLocation, const struct FText& killerNameInput, class AConanCharacter* killer)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.KillCharacter");

    AConanCharacter_KillCharacter_Params params;
    params.HitLocation = HitLocation;
    params.killerNameInput = killerNameInput;
    params.killer = killer;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.K2_SprintStaminaCostModifier
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          Modifier                       (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_SprintStaminaCostModifier(float* Modifier)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_SprintStaminaCostModifier");

    AConanCharacter_K2_SprintStaminaCostModifier_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (Modifier != nullptr)
        *Modifier = params.Modifier;
}


// Function ConanSandbox.ConanCharacter.K2_InState
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECharacterState                CheckState                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           InState                        (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_InState(ECharacterState CheckState, bool* InState)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_InState");

    AConanCharacter_K2_InState_Params params;
    params.CheckState = CheckState;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (InState != nullptr)
        *InState = params.InState;
}


// Function ConanSandbox.ConanCharacter.K2_HandleStaminaRegen
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::K2_HandleStaminaRegen()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_HandleStaminaRegen");

    AConanCharacter_K2_HandleStaminaRegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.K2_HandleSprintStamina
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// unsigned char                  CharacterSubState              (Parm, ZeroConstructor, IsPlainOldData)
// bool                           Entered                        (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_HandleSprintStamina(unsigned char CharacterSubState, bool Entered)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_HandleSprintStamina");

    AConanCharacter_K2_HandleSprintStamina_Params params;
    params.CharacterSubState = CharacterSubState;
    params.Entered = Entered;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.K2_GetStaminaRegenMod
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          Value                          (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetStaminaRegenMod(float* Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetStaminaRegenMod");

    AConanCharacter_K2_GetStaminaRegenMod_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

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


// Function ConanSandbox.ConanCharacter.K2_GetStaminaRegen
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          Value                          (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetStaminaRegen(float* Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetStaminaRegen");

    AConanCharacter_K2_GetStaminaRegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

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


// Function ConanSandbox.ConanCharacter.K2_GetStaminaMax
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetStaminaMax(int* ReturnValue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetStaminaMax");

    AConanCharacter_K2_GetStaminaMax_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (ReturnValue != nullptr)
        *ReturnValue = params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.K2_GetStaminaDegen
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          Value                          (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetStaminaDegen(float* Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetStaminaDegen");

    AConanCharacter_K2_GetStaminaDegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

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


// Function ConanSandbox.ConanCharacter.K2_GetStaminaCurrent
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            StaminaCurrent                 (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetStaminaCurrent(int* StaminaCurrent)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetStaminaCurrent");

    AConanCharacter_K2_GetStaminaCurrent_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (StaminaCurrent != nullptr)
        *StaminaCurrent = params.StaminaCurrent;
}


// Function ConanSandbox.ConanCharacter.K2_GetStaminaAttackCost
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            StaminaCost                    (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetStaminaAttackCost(int* StaminaCost)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetStaminaAttackCost");

    AConanCharacter_K2_GetStaminaAttackCost_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (StaminaCost != nullptr)
        *StaminaCost = params.StaminaCost;
}


// Function ConanSandbox.ConanCharacter.K2_GetHealthRegen
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          Value                          (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetHealthRegen(float* Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetHealthRegen");

    AConanCharacter_K2_GetHealthRegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

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


// Function ConanSandbox.ConanCharacter.K2_GetHealthMax
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_GetHealthMax(int* ReturnValue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_GetHealthMax");

    AConanCharacter_K2_GetHealthMax_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (ReturnValue != nullptr)
        *ReturnValue = params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.K2_ClimbingStaminaCostModifier
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          Modifier                       (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_ClimbingStaminaCostModifier(float* Modifier)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_ClimbingStaminaCostModifier");

    AConanCharacter_K2_ClimbingStaminaCostModifier_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (Modifier != nullptr)
        *Modifier = params.Modifier;
}


// Function ConanSandbox.ConanCharacter.K2_CanSprint
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           Value                          (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_CanSprint(bool* Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_CanSprint");

    AConanCharacter_K2_CanSprint_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

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


// Function ConanSandbox.ConanCharacter.K2_CanRegenerateStamina
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           isRegenPositive                (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_CanRegenerateStamina(bool* isRegenPositive)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_CanRegenerateStamina");

    AConanCharacter_K2_CanRegenerateStamina_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (isRegenPositive != nullptr)
        *isRegenPositive = params.isRegenPositive;
}


// Function ConanSandbox.ConanCharacter.K2_AdjustStaminaRegenMod
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Input                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_AdjustStaminaRegenMod(float Input)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_AdjustStaminaRegenMod");

    AConanCharacter_K2_AdjustStaminaRegenMod_Params params;
    params.Input = Input;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.K2_AdjustStaminaForAttack
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AConanCharacter*         Actor                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::K2_AdjustStaminaForAttack(class AConanCharacter* Actor)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.K2_AdjustStaminaForAttack");

    AConanCharacter_K2_AdjustStaminaForAttack_Params params;
    params.Actor = Actor;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.IsUnarmed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::IsUnarmed()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.IsUnarmed");

    AConanCharacter_IsUnarmed_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.IsThirdPersonPassiveGamepad
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::IsThirdPersonPassiveGamepad()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.IsThirdPersonPassiveGamepad");

    AConanCharacter_IsThirdPersonPassiveGamepad_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.IsPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::IsPlayer()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.IsPlayer");

    AConanCharacter_IsPlayer_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.IsNonThrallNPC
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::IsNonThrallNPC()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.IsNonThrallNPC");

    AConanCharacter_IsNonThrallNPC_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.IsGuildFull
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AGuild*                  Guild                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::IsGuildFull(class AGuild* Guild)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.IsGuildFull");

    AConanCharacter_IsGuildFull_Params params;
    params.Guild = Guild;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.IsDisconnected
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::IsDisconnected()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.IsDisconnected");

    AConanCharacter_IsDisconnected_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.InterruptHealthRegen
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::InterruptHealthRegen()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.InterruptHealthRegen");

    AConanCharacter_InterruptHealthRegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.InSubstateInternal
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// unsigned char                  NumSubState                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::InSubstateInternal(unsigned char NumSubState)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.InSubstateInternal");

    AConanCharacter_InSubstateInternal_Params params;
    params.NumSubState = NumSubState;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.HUDShowFIFO
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// struct FText                   Text                           (ConstParm, Parm, OutParm, ReferenceParm)

void AConanCharacter::STATIC_HUDShowFIFO(class UObject* WorldContextObject, const struct FText& Text)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HUDShowFIFO");

    AConanCharacter_HUDShowFIFO_Params params;
    params.WorldContextObject = WorldContextObject;
    params.Text = Text;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.HaveValidTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::HaveValidTarget()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HaveValidTarget");

    AConanCharacter_HaveValidTarget_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.HasWeaponsEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::HasWeaponsEquipped()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HasWeaponsEquipped");

    AConanCharacter_HasWeaponsEquipped_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.HasShieldEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::HasShieldEquipped()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HasShieldEquipped");

    AConanCharacter_HasShieldEquipped_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.HasNoItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::HasNoItem()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HasNoItem");

    AConanCharacter_HasNoItem_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.HasItemInAnInventory
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int                            TemplateId                     (Parm, ZeroConstructor, IsPlainOldData)
// class UItemInventory*          OutInventory                   (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::HasItemInAnInventory(int TemplateId, class UItemInventory** OutInventory)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HasItemInAnInventory");

    AConanCharacter_HasItemInAnInventory_Params params;
    params.TemplateId = TemplateId;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (OutInventory != nullptr)
        *OutInventory = params.OutInventory;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.HasDLC
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   DLCPackageName                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::HasDLC(const struct FName& DLCPackageName)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HasDLC");

    AConanCharacter_HasDLC_Params params;
    params.DLCPackageName = DLCPackageName;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.HandleHealthRegen
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::HandleHealthRegen()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HandleHealthRegen");

    AConanCharacter_HandleHealthRegen_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.HandleDirectionalMovement
// (Native, Protected, HasOutParms, BlueprintCallable)
// Parameters:
// float                          inMovementModeMultiplier       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// float                          inScale                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// EConanCharacterMovementDirection inDirection                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bShouldForce                   (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::HandleDirectionalMovement(float inMovementModeMultiplier, float inScale, EConanCharacterMovementDirection inDirection, bool bShouldForce)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.HandleDirectionalMovement");

    AConanCharacter_HandleDirectionalMovement_Params params;
    params.inMovementModeMultiplier = inMovementModeMultiplier;
    params.inScale = inScale;
    params.inDirection = inDirection;
    params.bShouldForce = bShouldForce;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.GiveDismantleReimbursement
// (Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FBuildableHealthEntry> HealthPool                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void AConanCharacter::GiveDismantleReimbursement(TArray<struct FBuildableHealthEntry> HealthPool)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GiveDismantleReimbursement");

    AConanCharacter_GiveDismantleReimbursement_Params params;
    params.HealthPool = HealthPool;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.GetTotalIntStatModification
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          totalMultiplier                (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// int                            totalAdder                     (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::GetTotalIntStatModification(ECharIntStatID statID, float* totalMultiplier, int* totalAdder)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetTotalIntStatModification");

    AConanCharacter_GetTotalIntStatModification_Params params;
    params.statID = statID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (totalMultiplier != nullptr)
        *totalMultiplier = params.totalMultiplier;
    if (totalAdder != nullptr)
        *totalAdder = params.totalAdder;
}


// Function ConanSandbox.ConanCharacter.GetTotalFloatStatModification
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          totalMultiplier                (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// float                          totalAdder                     (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::GetTotalFloatStatModification(ECharFloatStatID statID, float* totalMultiplier, float* totalAdder)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetTotalFloatStatModification");

    AConanCharacter_GetTotalFloatStatModification_Params params;
    params.statID = statID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (totalMultiplier != nullptr)
        *totalMultiplier = params.totalMultiplier;
    if (totalAdder != nullptr)
        *totalAdder = params.totalAdder;
}


// Function ConanSandbox.ConanCharacter.GetTiltRotator
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator AConanCharacter::GetTiltRotator()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetTiltRotator");

    AConanCharacter_GetTiltRotator_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetThrallComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UThrallComponent*        ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UThrallComponent* AConanCharacter::GetThrallComponent()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetThrallComponent");

    AConanCharacter_GetThrallComponent_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetTargetTiltRotator
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator AConanCharacter::GetTargetTiltRotator()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetTargetTiltRotator");

    AConanCharacter_GetTargetTiltRotator_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetSubstateList
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<unsigned char>          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<unsigned char> AConanCharacter::GetSubstateList()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetSubstateList");

    AConanCharacter_GetSubstateList_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetStatHolder
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UStatHolder*             ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UStatHolder* AConanCharacter::GetStatHolder()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetStatHolder");

    AConanCharacter_GetStatHolder_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetStaminaData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FStaminaData            ReturnValue                    (Parm, OutParm, ReturnParm)

struct FStaminaData AConanCharacter::GetStaminaData()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetStaminaData");

    AConanCharacter_GetStaminaData_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetShortcutBarInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UShortcutBarInventory*   ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UShortcutBarInventory* AConanCharacter::GetShortcutBarInventory()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetShortcutBarInventory");

    AConanCharacter_GetShortcutBarInventory_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetRecipeInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class URecipeManager*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class URecipeManager* AConanCharacter::GetRecipeInventory()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetRecipeInventory");

    AConanCharacter_GetRecipeInventory_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetProgressionSystem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UProgressionSystem*      ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UProgressionSystem* AConanCharacter::GetProgressionSystem()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetProgressionSystem");

    AConanCharacter_GetProgressionSystem_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetPrioritizedUID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUniqueID*               ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UUniqueID* AConanCharacter::GetPrioritizedUID()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetPrioritizedUID");

    AConanCharacter_GetPrioritizedUID_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetNPCKillerPrefix
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString AConanCharacter::GetNPCKillerPrefix()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetNPCKillerPrefix");

    AConanCharacter_GetNPCKillerPrefix_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetNavigationFilter
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UClass*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UClass* AConanCharacter::GetNavigationFilter()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetNavigationFilter");

    AConanCharacter_GetNavigationFilter_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetKillerNameClient
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FText                   serverKillerName               (Parm)
// struct FUniqueNetIdRepl        serverKillerId                 (Parm)
// struct FText                   ReturnValue                    (Parm, OutParm, ReturnParm)

struct FText AConanCharacter::GetKillerNameClient(const struct FText& serverKillerName, const struct FUniqueNetIdRepl& serverKillerId)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetKillerNameClient");

    AConanCharacter_GetKillerNameClient_Params params;
    params.serverKillerName = serverKillerName;
    params.serverKillerId = serverKillerId;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetKillerName
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FText                   ReturnValue                    (Parm, OutParm, ReturnParm)

struct FText AConanCharacter::GetKillerName()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetKillerName");

    AConanCharacter_GetKillerName_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetKillerId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FUniqueNetIdRepl        ReturnValue                    (Parm, OutParm, ReturnParm)

struct FUniqueNetIdRepl AConanCharacter::GetKillerId()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetKillerId");

    AConanCharacter_GetKillerId_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetIsInThirdPerson
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::GetIsInThirdPerson()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetIsInThirdPerson");

    AConanCharacter_GetIsInThirdPerson_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetIntStatModification
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierID>   modifierID                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          totalMultiplier                (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// int                            totalAdder                     (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::GetIntStatModification(ECharIntStatID statID, TEnumAsByte<EStatModifierID> modifierID, float* totalMultiplier, int* totalAdder)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetIntStatModification");

    AConanCharacter_GetIntStatModification_Params params;
    params.statID = statID;
    params.modifierID = modifierID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (totalMultiplier != nullptr)
        *totalMultiplier = params.totalMultiplier;
    if (totalAdder != nullptr)
        *totalAdder = params.totalAdder;
}


// Function ConanSandbox.ConanCharacter.GetIntStatChangeSignal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UIntStatChangeSignalNode* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UIntStatChangeSignalNode* AConanCharacter::GetIntStatChangeSignal(ECharIntStatID statID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetIntStatChangeSignal");

    AConanCharacter_GetIntStatChangeSignal_Params params;
    params.statID = statID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetIntStat
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierMode> mode                           (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AConanCharacter::GetIntStat(ECharIntStatID statID, TEnumAsByte<EStatModifierMode> mode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetIntStat");

    AConanCharacter_GetIntStat_Params params;
    params.statID = statID;
    params.mode = mode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetInteractingActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* AConanCharacter::GetInteractingActor()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetInteractingActor");

    AConanCharacter_GetInteractingActor_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetHungerSystem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UHungerSystem*           ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UHungerSystem* AConanCharacter::GetHungerSystem()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetHungerSystem");

    AConanCharacter_GetHungerSystem_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetHealthData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FHealthData             ReturnValue                    (Parm, OutParm, ReturnParm)

struct FHealthData AConanCharacter::GetHealthData()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetHealthData");

    AConanCharacter_GetHealthData_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetGuildId
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UUniqueID*               ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UUniqueID* AConanCharacter::GetGuildId()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetGuildId");

    AConanCharacter_GetGuildId_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetGuild
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AGuild*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AGuild* AConanCharacter::GetGuild()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetGuild");

    AConanCharacter_GetGuild_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetGroundNormal
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector AConanCharacter::GetGroundNormal()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetGroundNormal");

    AConanCharacter_GetGroundNormal_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetGameState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AConanGameState*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AConanGameState* AConanCharacter::GetGameState()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetGameState");

    AConanCharacter_GetGameState_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetFocusPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector AConanCharacter::GetFocusPoint()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetFocusPoint");

    AConanCharacter_GetFocusPoint_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetFloatStatModification
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierID>   modifierID                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          totalMultiplier                (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// float                          totalAdder                     (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::GetFloatStatModification(ECharFloatStatID statID, TEnumAsByte<EStatModifierID> modifierID, float* totalMultiplier, float* totalAdder)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetFloatStatModification");

    AConanCharacter_GetFloatStatModification_Params params;
    params.statID = statID;
    params.modifierID = modifierID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (totalMultiplier != nullptr)
        *totalMultiplier = params.totalMultiplier;
    if (totalAdder != nullptr)
        *totalAdder = params.totalAdder;
}


// Function ConanSandbox.ConanCharacter.GetFloatStatChangeSignal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UFloatStatChangeSignalNode* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UFloatStatChangeSignalNode* AConanCharacter::GetFloatStatChangeSignal(ECharFloatStatID statID)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetFloatStatChangeSignal");

    AConanCharacter_GetFloatStatChangeSignal_Params params;
    params.statID = statID;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetFloatStat
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierMode> mode                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AConanCharacter::GetFloatStat(ECharFloatStatID statID, TEnumAsByte<EStatModifierMode> mode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetFloatStat");

    AConanCharacter_GetFloatStat_Params params;
    params.statID = statID;
    params.mode = mode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetFeatInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFeatInventory*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UFeatInventory* AConanCharacter::GetFeatInventory()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetFeatInventory");

    AConanCharacter_GetFeatInventory_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetFallbackPlayerStartLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector AConanCharacter::GetFallbackPlayerStartLocation()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetFallbackPlayerStartLocation");

    AConanCharacter_GetFallbackPlayerStartLocation_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetEquipmentInventoryNative
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UEquipmentInventory*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UEquipmentInventory* AConanCharacter::GetEquipmentInventoryNative()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetEquipmentInventoryNative");

    AConanCharacter_GetEquipmentInventoryNative_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetEmoteInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UEmoteInventory*         ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UEmoteInventory* AConanCharacter::GetEmoteInventory()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetEmoteInventory");

    AConanCharacter_GetEmoteInventory_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetDistanceFromCamera
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AConanCharacter::GetDistanceFromCamera()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetDistanceFromCamera");

    AConanCharacter_GetDistanceFromCamera_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetDamageCausers
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AConanCharacter*> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<class AConanCharacter*> AConanCharacter::GetDamageCausers()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetDamageCausers");

    AConanCharacter_GetDamageCausers_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetCraftingQueueInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCraftingQueue*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCraftingQueue* AConanCharacter::GetCraftingQueueInventory()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetCraftingQueueInventory");

    AConanCharacter_GetCraftingQueueInventory_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetClientGUIControlMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EGUIControlMode>   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EGUIControlMode> AConanCharacter::GetClientGUIControlMode()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetClientGUIControlMode");

    AConanCharacter_GetClientGUIControlMode_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetChildren
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<class AActor*>          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<class AActor*> AConanCharacter::GetChildren()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetChildren");

    AConanCharacter_GetChildren_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetCharacterState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECharacterState                ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

ECharacterState AConanCharacter::GetCharacterState()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetCharacterState");

    AConanCharacter_GetCharacterState_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetCharacterName
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString AConanCharacter::GetCharacterName()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetCharacterName");

    AConanCharacter_GetCharacterName_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetCachedHitResultForGroundSurface
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TEnumAsByte<EPhysicalSurface>  OutSurfaceType                 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// class AActor*                  HitActor                       (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           Success                        (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::GetCachedHitResultForGroundSurface(TEnumAsByte<EPhysicalSurface>* OutSurfaceType, class AActor** HitActor, bool* Success)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetCachedHitResultForGroundSurface");

    AConanCharacter_GetCachedHitResultForGroundSurface_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    if (OutSurfaceType != nullptr)
        *OutSurfaceType = params.OutSurfaceType;
    if (HitActor != nullptr)
        *HitActor = params.HitActor;
    if (Success != nullptr)
        *Success = params.Success;
}


// Function ConanSandbox.ConanCharacter.GetBuildSystemComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBuildSystemComponent*   ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBuildSystemComponent* AConanCharacter::GetBuildSystemComponent()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetBuildSystemComponent");

    AConanCharacter_GetBuildSystemComponent_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetBuildingReplicationComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBuildingReplicationComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBuildingReplicationComponent* AConanCharacter::GetBuildingReplicationComponent()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetBuildingReplicationComponent");

    AConanCharacter_GetBuildingReplicationComponent_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetBackpackInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UItemInventory*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UItemInventory* AConanCharacter::GetBackpackInventory()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetBackpackInventory");

    AConanCharacter_GetBackpackInventory_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.GetActorPersistenceComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UActorPersistenceComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UActorPersistenceComponent* AConanCharacter::GetActorPersistenceComponent()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.GetActorPersistenceComponent");

    AConanCharacter_GetActorPersistenceComponent_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ForceTickPoseAndRefreshBonesWhenRendered
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::ForceTickPoseAndRefreshBonesWhenRendered()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ForceTickPoseAndRefreshBonesWhenRendered");

    AConanCharacter_ForceTickPoseAndRefreshBonesWhenRendered_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ForceAlwaysTickPoseAndRefreshBones
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::ForceAlwaysTickPoseAndRefreshBones()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ForceAlwaysTickPoseAndRefreshBones");

    AConanCharacter_ForceAlwaysTickPoseAndRefreshBones_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ForceAlwaysTickPose
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::ForceAlwaysTickPose()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ForceAlwaysTickPose");

    AConanCharacter_ForceAlwaysTickPose_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.FindNamedOwnerForLandClaimSuccess
// (Final, Native, Private)
// Parameters:
// struct FString                 OwnerName                      (Parm, ZeroConstructor)
// struct FString                 CharName                       (Parm, ZeroConstructor)
// bool                           FromLoad                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::FindNamedOwnerForLandClaimSuccess(const struct FString& OwnerName, const struct FString& CharName, bool FromLoad)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.FindNamedOwnerForLandClaimSuccess");

    AConanCharacter_FindNamedOwnerForLandClaimSuccess_Params params;
    params.OwnerName = OwnerName;
    params.CharName = CharName;
    params.FromLoad = FromLoad;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ExitSubstateInternal
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// unsigned char                  NumSubState                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::ExitSubstateInternal(unsigned char NumSubState)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ExitSubstateInternal");

    AConanCharacter_ExitSubstateInternal_Params params;
    params.NumSubState = NumSubState;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.EnterSubstateInternal
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// unsigned char                  NumSubState                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::EnterSubstateInternal(unsigned char NumSubState)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.EnterSubstateInternal");

    AConanCharacter_EnterSubstateInternal_Params params;
    params.NumSubState = NumSubState;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.DamageDelivered
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AConanCharacter*         DamageTo                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           Killed                         (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::DamageDelivered(class AConanCharacter* DamageTo, bool Killed)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.DamageDelivered");

    AConanCharacter_DamageDelivered_Params params;
    params.DamageTo = DamageTo;
    params.Killed = Killed;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ConvertedToThrall
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AConanCharacter::ConvertedToThrall()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ConvertedToThrall");

    AConanCharacter_ConvertedToThrall_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSignalUIofGuildFailure
// (Net, NetReliable, Native, Event, Public, NetClient)

void AConanCharacter::ClientSignalUIofGuildFailure()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSignalUIofGuildFailure");

    AConanCharacter_ClientSignalUIofGuildFailure_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSignalUIofDBFailure
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// struct FText                   Text                           (ConstParm, Parm, ReferenceParm)

void AConanCharacter::ClientSignalUIofDBFailure(const struct FText& Text)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSignalUIofDBFailure");

    AConanCharacter_ClientSignalUIofDBFailure_Params params;
    params.Text = Text;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSignalPlayerListReady
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// TArray<struct FPlayerInfo>     playerList                     (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void AConanCharacter::ClientSignalPlayerListReady(TArray<struct FPlayerInfo> playerList)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSignalPlayerListReady");

    AConanCharacter_ClientSignalPlayerListReady_Params params;
    params.playerList = playerList;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSignalGuildCreated
// (Net, NetReliable, Native, Event, Public, NetClient)

void AConanCharacter::ClientSignalGuildCreated()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSignalGuildCreated");

    AConanCharacter_ClientSignalGuildCreated_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientShowRecreationWarning
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// int                            guildMembers                   (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ClientShowRecreationWarning(int guildMembers)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientShowRecreationWarning");

    AConanCharacter_ClientShowRecreationWarning_Params params;
    params.guildMembers = guildMembers;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientShowMessage
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// struct FText                   Title                          (ConstParm, Parm, ReferenceParm)
// struct FText                   Text                           (ConstParm, Parm, ReferenceParm)

void AConanCharacter::ClientShowMessage(const struct FText& Title, const struct FText& Text)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientShowMessage");

    AConanCharacter_ClientShowMessage_Params params;
    params.Title = Title;
    params.Text = Text;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientShowLandClaimEnteredMessage
// (Final, Net, NetReliable, Native, Event, Private, NetClient)
// Parameters:
// struct FText                   landClaimOwner                 (ConstParm, Parm, ReferenceParm)

void AConanCharacter::ClientShowLandClaimEnteredMessage(const struct FText& landClaimOwner)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientShowLandClaimEnteredMessage");

    AConanCharacter_ClientShowLandClaimEnteredMessage_Params params;
    params.landClaimOwner = landClaimOwner;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSetTimeofDayToServerTime
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)

void AConanCharacter::ClientSetTimeofDayToServerTime()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSetTimeofDayToServerTime");

    AConanCharacter_ClientSetTimeofDayToServerTime_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSetInteractingActor
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// class AActor*                  Actor                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   guiModuleName                  (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ClientSetInteractingActor(class AActor* Actor, const struct FName& guiModuleName, class UObject* WorldContextObject)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSetInteractingActor");

    AConanCharacter_ClientSetInteractingActor_Params params;
    params.Actor = Actor;
    params.guiModuleName = guiModuleName;
    params.WorldContextObject = WorldContextObject;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSetFloatStat
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ClientSetFloatStat(ECharFloatStatID statID, float Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSetFloatStat");

    AConanCharacter_ClientSetFloatStat_Params params;
    params.statID = statID;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientSendThrallCharacterLayout
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class UItemInventory*          inventory                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FCharacterLayout        CharacterLayout                (Parm)

void AConanCharacter::ClientSendThrallCharacterLayout(class UItemInventory* inventory, int Index, const struct FCharacterLayout& CharacterLayout)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientSendThrallCharacterLayout");

    AConanCharacter_ClientSendThrallCharacterLayout_Params params;
    params.inventory = inventory;
    params.Index = Index;
    params.CharacterLayout = CharacterLayout;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientReceiveGuildInvite
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// class UUniqueID*               senderId                       (Parm, ZeroConstructor, IsPlainOldData)
// class UUniqueID*               guildId                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 senderName                     (Parm, ZeroConstructor)
// struct FString                 guildName                      (Parm, ZeroConstructor)

void AConanCharacter::ClientReceiveGuildInvite(class UUniqueID* senderId, class UUniqueID* guildId, const struct FString& senderName, const struct FString& guildName)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientReceiveGuildInvite");

    AConanCharacter_ClientReceiveGuildInvite_Params params;
    params.senderId = senderId;
    params.guildId = guildId;
    params.senderName = senderName;
    params.guildName = guildName;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientPossessedBy
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class AController*             NewController                  (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ClientPossessedBy(class AController* NewController)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientPossessedBy");

    AConanCharacter_ClientPossessedBy_Params params;
    params.NewController = NewController;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientHUDShowNotification
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// struct FText                   Text                           (ConstParm, Parm, ReferenceParm)
// bool                           positive                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ClientHUDShowNotification(const struct FText& Text, bool positive)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientHUDShowNotification");

    AConanCharacter_ClientHUDShowNotification_Params params;
    params.Text = Text;
    params.positive = positive;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientHUDShowFIFOEx
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// EFIFOStyle                     Style                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FText                   Text                           (ConstParm, Parm, ReferenceParm)
// struct FText                   Header                         (ConstParm, Parm, ReferenceParm)

void AConanCharacter::ClientHUDShowFIFOEx(EFIFOStyle Style, const struct FText& Text, const struct FText& Header)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientHUDShowFIFOEx");

    AConanCharacter_ClientHUDShowFIFOEx_Params params;
    params.Style = Style;
    params.Text = Text;
    params.Header = Header;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientHUDShowFIFOAtLocation
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// struct FText                   Text                           (ConstParm, Parm, ReferenceParm)
// EFIFOLocation                  Location                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ClientHUDShowFIFOAtLocation(const struct FText& Text, EFIFOLocation Location)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientHUDShowFIFOAtLocation");

    AConanCharacter_ClientHUDShowFIFOAtLocation_Params params;
    params.Text = Text;
    params.Location = Location;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientHUDShowFIFO
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// struct FText                   Text                           (ConstParm, Parm, ReferenceParm)

void AConanCharacter::ClientHUDShowFIFO(const struct FText& Text)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientHUDShowFIFO");

    AConanCharacter_ClientHUDShowFIFO_Params params;
    params.Text = Text;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientHUDLootNotification
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// int                            TemplateId                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            quantity                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ClientHUDLootNotification(int TemplateId, int quantity)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientHUDLootNotification");

    AConanCharacter_ClientHUDLootNotification_Params params;
    params.TemplateId = TemplateId;
    params.quantity = quantity;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientEventUnpossessed
// (Event, Public, BlueprintEvent)

void AConanCharacter::ClientEventUnpossessed()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientEventUnpossessed");

    AConanCharacter_ClientEventUnpossessed_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClientClearCharacterLevel
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)

void AConanCharacter::ClientClearCharacterLevel()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClientClearCharacterLevel");

    AConanCharacter_ClientClearCharacterLevel_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ClearDoubleJumpTimeoutTimer
// (Native, Public, BlueprintCallable)

void AConanCharacter::ClearDoubleJumpTimeoutTimer()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ClearDoubleJumpTimeoutTimer");

    AConanCharacter_ClearDoubleJumpTimeoutTimer_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.CheckLandClaimAtCharacterLocation
// (Final, Native, Private, BlueprintCallable)

void AConanCharacter::CheckLandClaimAtCharacterLocation()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.CheckLandClaimAtCharacterLocation");

    AConanCharacter_CheckLandClaimAtCharacterLocation_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.CheckIfWaterVolume
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APhysicsVolume*          NewVolume                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::CheckIfWaterVolume(class APhysicsVolume* NewVolume)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.CheckIfWaterVolume");

    AConanCharacter_CheckIfWaterVolume_Params params;
    params.NewVolume = NewVolume;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.CharacterStateChangedEvent__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// ECharacterState                OldState                       (Parm, ZeroConstructor, IsPlainOldData)
// ECharacterState                newState                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::CharacterStateChangedEvent__DelegateSignature(ECharacterState OldState, ECharacterState newState)
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.CharacterStateChangedEvent__DelegateSignature");

    AConanCharacter_CharacterStateChangedEvent__DelegateSignature_Params params;
    params.OldState = OldState;
    params.newState = newState;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.CharacterPossessedOnClient__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// class AController*             NewController                  (Parm, ZeroConstructor, IsPlainOldData)
// class AConanCharacter*         Character                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::CharacterPossessedOnClient__DelegateSignature(class AController* NewController, class AConanCharacter* Character)
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.CharacterPossessedOnClient__DelegateSignature");

    AConanCharacter_CharacterPossessedOnClient__DelegateSignature_Params params;
    params.NewController = NewController;
    params.Character = Character;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.CharacterNameChanged__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void AConanCharacter::CharacterNameChanged__DelegateSignature()
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.CharacterNameChanged__DelegateSignature");

    AConanCharacter_CharacterNameChanged__DelegateSignature_Params params;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// DelegateFunction ConanSandbox.ConanCharacter.CharacterMovedSignature__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// float                          DeltaSeconds                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 OldLocation                    (Parm, IsPlainOldData)
// struct FVector                 OldVelocity                    (Parm, IsPlainOldData)

void AConanCharacter::CharacterMovedSignature__DelegateSignature(float DeltaSeconds, const struct FVector& OldLocation, const struct FVector& OldVelocity)
{
    static auto fn = UObject::FindObject<UFunction>("DelegateFunction ConanSandbox.ConanCharacter.CharacterMovedSignature__DelegateSignature");

    AConanCharacter_CharacterMovedSignature__DelegateSignature_Params params;
    params.DeltaSeconds = DeltaSeconds;
    params.OldLocation = OldLocation;
    params.OldVelocity = OldVelocity;

    auto flags = fn->FunctionFlags;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.CharacterDeleted
// (Final, Native, Public, BlueprintCallable)

void AConanCharacter::CharacterDeleted()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.CharacterDeleted");

    AConanCharacter_CharacterDeleted_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.CharacterCreated
// (Native, Public, BlueprintCallable)

void AConanCharacter::CharacterCreated()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.CharacterCreated");

    AConanCharacter_CharacterCreated_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.CanShowBiography
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AConanCharacter*         Character                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::CanShowBiography(class AConanCharacter* Character)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.CanShowBiography");

    AConanCharacter_CanShowBiography_Params params;
    params.Character = Character;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.CanEnterState
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// ECharacterState                OldState                       (Parm, ZeroConstructor, IsPlainOldData)
// ECharacterState                newState                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::CanEnterState(ECharacterState OldState, ECharacterState newState)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.CanEnterState");

    AConanCharacter_CanEnterState_Params params;
    params.OldState = OldState;
    params.newState = newState;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.CanDoubleJump
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::CanDoubleJump()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.CanDoubleJump");

    AConanCharacter_CanDoubleJump_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.ApplyPitchRoll
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ApplyPitchRoll(float DeltaTime)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ApplyPitchRoll");

    AConanCharacter_ApplyPitchRoll_Params params;
    params.DeltaTime = DeltaTime;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.ApplyNewMovementSpeed
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                          NewSpeed                       (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::ApplyNewMovementSpeed(float NewSpeed)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.ApplyNewMovementSpeed");

    AConanCharacter_ApplyNewMovementSpeed_Params params;
    params.NewSpeed = NewSpeed;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.AllowHealthbarTimeout
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::AllowHealthbarTimeout()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AllowHealthbarTimeout");

    AConanCharacter_AllowHealthbarTimeout_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.AdjustStaminaCurrent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            StaminaChange                  (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::AdjustStaminaCurrent(int StaminaChange)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AdjustStaminaCurrent");

    AConanCharacter_AdjustStaminaCurrent_Params params;
    params.StaminaChange = StaminaChange;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.AdjustHealthRegen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Input                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::AdjustHealthRegen(float Input)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AdjustHealthRegen");

    AConanCharacter_AdjustHealthRegen_Params params;
    params.Input = Input;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.AdjustHealth
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            HealthValue                    (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::AdjustHealth(int HealthValue)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AdjustHealth");

    AConanCharacter_AdjustHealth_Params params;
    params.HealthValue = HealthValue;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.AddToIntStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::AddToIntStat(ECharIntStatID statID, int Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AddToIntStat");

    AConanCharacter_AddToIntStat_Params params;
    params.statID = statID;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.AddToFloatStat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::AddToFloatStat(ECharFloatStatID statID, float Value)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AddToFloatStat");

    AConanCharacter_AddToFloatStat_Params params;
    params.statID = statID;
    params.Value = Value;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanCharacter.AddIntStatMultiplier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierID>   modifierID                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierUpdateMode> updateMode                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::AddIntStatMultiplier(ECharIntStatID statID, TEnumAsByte<EStatModifierID> modifierID, float Value, TEnumAsByte<EStatModifierUpdateMode> updateMode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AddIntStatMultiplier");

    AConanCharacter_AddIntStatMultiplier_Params params;
    params.statID = statID;
    params.modifierID = modifierID;
    params.Value = Value;
    params.updateMode = updateMode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.AddIntStatModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharIntStatID                 statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierID>   modifierID                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierOperator> operatorID                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            Value                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierUpdateMode> updateMode                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::AddIntStatModifier(ECharIntStatID statID, TEnumAsByte<EStatModifierID> modifierID, TEnumAsByte<EStatModifierOperator> operatorID, int Value, TEnumAsByte<EStatModifierUpdateMode> updateMode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AddIntStatModifier");

    AConanCharacter_AddIntStatModifier_Params params;
    params.statID = statID;
    params.modifierID = modifierID;
    params.operatorID = operatorID;
    params.Value = Value;
    params.updateMode = updateMode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.AddFloatStatModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharFloatStatID               statID                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierID>   modifierID                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierOperator> operatorID                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EStatModifierUpdateMode> updateMode                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AConanCharacter::AddFloatStatModifier(ECharFloatStatID statID, TEnumAsByte<EStatModifierID> modifierID, TEnumAsByte<EStatModifierOperator> operatorID, float Value, TEnumAsByte<EStatModifierUpdateMode> updateMode)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AddFloatStatModifier");

    AConanCharacter_AddFloatStatModifier_Params params;
    params.statID = statID;
    params.modifierID = modifierID;
    params.operatorID = operatorID;
    params.Value = Value;
    params.updateMode = updateMode;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;

    return params.ReturnValue;
}


// Function ConanSandbox.ConanCharacter.AddCarriedCharacter
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AConanCharacter*         Character                      (Parm, ZeroConstructor, IsPlainOldData)

void AConanCharacter::AddCarriedCharacter(class AConanCharacter* Character)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanCharacter.AddCarriedCharacter");

    AConanCharacter_AddCarriedCharacter_Params params;
    params.Character = Character;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanBasicAIController.UpdateBBKeysFromPawn
// (Final, Native, Public, BlueprintCallable)

void AConanBasicAIController::UpdateBBKeysFromPawn()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanBasicAIController.UpdateBBKeysFromPawn");

    AConanBasicAIController_UpdateBBKeysFromPawn_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanBasicAIController.StopEmote
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bForceStop                     (Parm, ZeroConstructor, IsPlainOldData)

void AConanBasicAIController::StopEmote(bool bForceStop)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanBasicAIController.StopEmote");

    AConanBasicAIController_StopEmote_Params params;
    params.bForceStop = bForceStop;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanBasicAIController.SetHomeLocation
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 NewHomeLocation                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void AConanBasicAIController::SetHomeLocation(const struct FVector& NewHomeLocation)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanBasicAIController.SetHomeLocation");

    AConanBasicAIController_SetHomeLocation_Params params;
    params.NewHomeLocation = NewHomeLocation;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanBasicAIController.RequestBestMoveSpeed
// (Native, Public, BlueprintCallable)

void AConanBasicAIController::RequestBestMoveSpeed()
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanBasicAIController.RequestBestMoveSpeed");

    AConanBasicAIController_RequestBestMoveSpeed_Params params;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}


// Function ConanSandbox.ConanBasicAIController.PlayEmote
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ECharacterEmotes               EmoteToPLay                    (Parm, ZeroConstructor, IsPlainOldData)

void AConanBasicAIController::PlayEmote(ECharacterEmotes EmoteToPLay)
{
    static auto fn = UObject::FindObject<UFunction>("Function ConanSandbox.ConanBasicAIController.PlayEmote");

    AConanBasicAIController_PlayEmote_Params params;
    params.EmoteToPLay = EmoteToPLay;

    auto flags = fn->FunctionFlags;
    fn->FunctionFlags |= 0x400;

    UObject::ProcessEvent(fn, &params);

    fn->FunctionFlags = flags;
}