APlayerControllerBase Class Reference

#include <PlayerControllerBase.h>

Inheritance diagram for APlayerControllerBase:

Public Member Functions
virtual void	GetAudioListenerPosition (FVector &OutLocation, FVector &OutFrontDir, FVector &OutRightDir) const override
virtual void	BindActions (UInputMappingContext *Context)
virtual bool	SetPlayerLookInverted (const bool bInvert=true) override
virtual bool	SetPlayerLookHorizontalInverted (const bool bInvert=true) override
virtual float	SetCameraSensitivity (const float NewValue) override
virtual float	SetCameraHorizontalSensitivity (const float NewValue) override
virtual float	SetCameraVerticalSensitivity (const float NewValue) override
virtual void	SetCameraAimedSensitivityMultiplier (const float NewValue) override
virtual void	SetCameraUseSeparateAxisSensitivity (const bool bValue) override
virtual void	SetAimAssistLevel (const int32 Value) override
virtual void	SetPlayerUsingController (const bool bValue) override
virtual bool	GetPlayerUsingController () override
virtual bool	SaveCurrentPlayerOptions (const FAudioPlayerOptions AudioSettings) override
virtual float	GetCameraSensitivity () const override
virtual float	GetCameraAimedSensitivityMultiplier () const override
virtual float	GetCameraHorizontalSensitivity () const override
virtual float	GetCameraVerticalSensitivity () const override
virtual bool	GetCameraUseSeparateAxisSensitivity () const override
virtual bool	GetPlayerLookInverted () const override
virtual bool	GetPlayerHorizontalInverted () const override
virtual int32	GetAimAssistLevel () const override
virtual FAudioPlayerOptions	GetPlayerAudioSettings () const override
virtual bool	RegisterLayer (const FGameplayTag LayerName, UUserWidget *LayerWidget) override
virtual UUserWidget *	PushContentToLayer (const FGameplayTag LayerName, const TSoftClassPtr< UUserWidget > WidgetClass) override
virtual bool	PopContentFromLayer (const FGameplayTag LayerName) override
virtual bool	ClearLayer (const FGameplayTag LayerName) override
virtual bool	ToggleWidget (const FGameplayTag LayerName, UUserWidget *Widget) override
virtual UUserWidget *	AddWidgetToLayer (const FGameplayTag LayerName, const TSoftClassPtr< UUserWidget > WidgetClass) override
virtual UUserWidget *	GetContentFromLayer (const FGameplayTag LayerName, const TSoftClassPtr< UUserWidget > WidgetClass) override
virtual UUserWidget *	AddWidgetToLayerWithSlot (const FGameplayTag LayerName, const FGameplayTag SlotTag, const TSoftClassPtr< UUserWidget > WidgetClass) override
virtual void	OpenRadialMenu (const FRadialMenuData &Data) override
virtual int32	CloseRadialMenu () override
virtual bool	GetIsRadialMenuOpen () const override
virtual void	SetCharacterMode (const FGameplayTag &Mode) override
virtual FGameplayTag	GetCharacterMode () const override
virtual void	ToggleGameLog () override
virtual FVector2D	GetLookAxis () const override
virtual FVector2D	GetMoveAxis () const override
virtual FVector2D	GetScreenCenter () const override
virtual FVector	GetPawnLocation () const override
virtual void	GetControllerViewPoint (FVector &out_Location, FRotator &out_Rotation) const override
virtual bool	SaveGame () override
virtual bool	LoadGame () override
void	OnCharacterModeChanged (const FGameplayTag &Mode)

Public Attributes
TObjectPtr< UInputMappingContext >	MenuInputMappingContext = nullptr
TObjectPtr< UInputMappingContext >	MainInputMappingContext = nullptr
bool	bDebuggingMode = false
FName	AudioSocket = FName("head")

Protected Member Functions
virtual void	BeginPlay () override
virtual void	SetupInputs ()
virtual void	SetupComponents ()
virtual bool	SavePlayerOptions (const FString &SlotName="Default")
virtual bool	LoadPlayerOptions (const FString &SlotName="Default")
virtual void	ApplySettings (const class USettingsSaveGame *LoadedPlayerSettings)
virtual USettingsSaveGame *	ApplySettingsToSaveGame (class USettingsSaveGame *LoadedPlayerSettings)
virtual void	OnPossess (APawn *NewPawn) override
virtual void	OnRep_Pawn () override
virtual void	SetupInputComponent () override
virtual void	OnPawnSpawn ()
virtual void	OnPawnSpawnComplete ()
virtual float	CalculateCameraSensitivity (const float CameraInput) const
virtual void	MenuConfirmAction (const FInputActionValue &Value)
virtual void	MenuBackAction (const FInputActionValue &Value)
virtual void	SelectionUpAction (const FInputActionValue &Value)
virtual void	ForwardMovementAction (const FInputActionValue &Value)
virtual void	RightMovementAction (const FInputActionValue &Value)
virtual void	CameraUpAction (const FInputActionValue &Value)
virtual void	CameraRightAction (const FInputActionValue &Value)
virtual void	CharacterModeAction (const FInputActionValue &Value)
IHUDInterface *	GetHUDInterface ()
ICharacterBaseInterface *	GetCharacterInterface ()
void	LogDebugError (const FString &Message) const
void	LogDebugError (const FString &Message, const int32 Value) const
void	LogDebugError (const FString &Message, const float Value) const
void	LogDebugWarning (const FString &Message) const
void	LogDebugWarning (const FString &Message, const int32 Value) const
void	LogDebugWarning (const FString &Message, const float Value) const
void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const int32 Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const float Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const bool bValue, const bool bWarning, const bool bError) const
void	LogOnScreenMessage (const int32 Key, const FString &Message, FColor Color=FColor::Green) const
void	SetCategoryName (const FLogCategoryBase &Category)

Protected Attributes
FGameplayTag	CharacterMode = FGameplayTag(CharacterModeTags::Default)
int32	MaxPawnSpawnAttempts = 5
bool	bAimed = false

Private Member Functions
virtual bool	SaveAudioOptions (const FAudioPlayerOptions AudioSettings)
virtual bool	LoadAudioOptions ()

Private Attributes
IHUDInterface *	HUDInterface
FLogCategoryName	CategoryName = LogBasePlayerController.GetCategoryName()
ICharacterBaseInterface *	CharacterBaseInterface
FRadialMenuData	CharacterModesMenuData
FGameplayPlayerOptions	PlayerOptions
FAudioPlayerOptions	PlayerAudioSettings
bool	bUsingController = false
FString	PlayerOptionsSaveName = "_PlayerSettings"
float	MoveAxisY = 0.0f
float	MoveAxisX = 0.0f
float	LookAxisY = 0.0f
float	LookAxisX = 0.0f
float	MultiplayerStartDelay = 0.5f
FTimerHandle	SetupCompleteDelayTimerHandle
int32	PawnSpawnAttempts = 0

Member Function Documentation

AddWidgetToLayer()

UUserWidget * APlayerControllerBase::AddWidgetToLayer ( const FGameplayTag LayerName, const TSoftClassPtr< UUserWidget > WidgetClass )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr || WidgetClass == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::AddWidgetToLayer"));
        return nullptr;
    }
    return GetHUDInterface()->AddWidgetToLayer(LayerName, WidgetClass);
}

AddWidgetToLayerWithSlot()

UUserWidget * APlayerControllerBase::AddWidgetToLayerWithSlot ( const FGameplayTag LayerName, const FGameplayTag SlotTag, const TSoftClassPtr< UUserWidget > WidgetClass )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr || WidgetClass == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::AddWidgetToLayerWithSlot"));
        return nullptr;
    }
    return GetHUDInterface()->AddWidgetToLayerWithSlot(LayerName, SlotTag, WidgetClass);
 
}

ApplySettings()

void APlayerControllerBase::ApplySettings ( const class USettingsSaveGame * LoadedPlayerSettings )

protectedvirtual

{
    PlayerOptions = LoadedPlayerSettings->PlayerOptions;
    // LoadedPlayerSettings->AudioOptions
}

ApplySettingsToSaveGame()

USettingsSaveGame * APlayerControllerBase::ApplySettingsToSaveGame ( class USettingsSaveGame * LoadedPlayerSettings )

protectedvirtual

{
    LoadedPlayerSettings->PlayerOptions = PlayerOptions;
    LoadedPlayerSettings->AudioOptions = PlayerAudioSettings;
    return LoadedPlayerSettings;
}

BeginPlay()

void APlayerControllerBase::BeginPlay ( )

overrideprotectedvirtual

Reimplemented in ACustomPlayerController, and AMenuSystemPlayerController.

{
    Super::BeginPlay();
    DisableInput(this);
    LoadPlayerOptions();
    LoadAudioOptions();
    GetHUDInterface();
    GetCharacterInterface();
    CharacterModesMenuData = FRadialMenuData(CharacterModeTags::CategoryName, CharacterModeTags::DataTableLocation);
}

BindActions()

void APlayerControllerBase::BindActions ( UInputMappingContext * Context )

virtual

Reimplemented in AALSPlayerController, and ACustomPlayerController.

{
    if(Context == nullptr){return;}
    
    const TArray<FEnhancedActionKeyMapping>& Mappings = Context->GetMappings();
    UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(InputComponent);
    if(EnhancedInputComponent == nullptr){UE_LOG(LogBasePlayerController, Error, TEXT("Base Helpers Plugin requires Enhanced Input System to be activated in project settings to function properly"));return;}
    
    // There may be more than one keymapping assigned to one action. So, first filter duplicate action entries to prevent multiple delegate bindings
    TSet<const UInputAction*> UniqueActions;
    for(const FEnhancedActionKeyMapping& Keymapping : Mappings)
    {
        UniqueActions.Add(Keymapping.Action);
    }
    for(const UInputAction* UniqueAction : UniqueActions)
    {
        EnhancedInputComponent->BindAction(UniqueAction, ETriggerEvent::Triggered, Cast<UObject>(this), UniqueAction->GetFName());
    }
}

CalculateCameraSensitivity()

float APlayerControllerBase::CalculateCameraSensitivity ( const float CameraInput ) const

protectedvirtual

Reimplemented in ACustomPlayerController.

{
    float CameraSpeed = CameraInput;
    if(bAimed){CameraSpeed *= GetCameraAimedSensitivityMultiplier();}
    return CameraSpeed;
}

CameraRightAction()

void APlayerControllerBase::CameraRightAction ( const FInputActionValue & Value )

protectedvirtual

Reimplemented in AALSPlayerController, and ACustomPlayerController.

{
    LookAxisX = Value.Get<float>();
}

CameraUpAction()

void APlayerControllerBase::CameraUpAction ( const FInputActionValue & Value )

protectedvirtual

Reimplemented in AALSPlayerController, and ACustomPlayerController.

{
    LookAxisY = Value.Get<float>();
}

CharacterModeAction()

void APlayerControllerBase::CharacterModeAction ( const FInputActionValue & Value )

protectedvirtual

{
    if(CharacterBaseInterface == nullptr){return;}
    const bool bPressed = Value.Get<bool>();
    if(bPressed)
    {
        OpenRadialMenu(CharacterModesMenuData);
    }
    else
    {
        const int32 Index = CloseRadialMenu();
        if(CharacterModesMenuData.Selections.IsValidIndex(Index) == false){UE_LOG(LogPlayerController, Warning, TEXT("Character Mode Out of Bounds PC"));return;}
        SetCharacterMode(CharacterModesMenuData.Selections[Index].GameplayTag);
        // PossessedCustomCharacter->SetCharacterMode(CharacterModesMenuData.Selections[Index].GameplayTag);
    }
}

ClearLayer()

bool APlayerControllerBase::ClearLayer ( const FGameplayTag LayerName )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::ClearLayer"));
        return false;
    }
    return GetHUDInterface()->ClearLayer(LayerName);
}

CloseRadialMenu()

int32 APlayerControllerBase::CloseRadialMenu ( )

overridevirtual

Returns

Selected Menu Item

Implements IPlayerControllerInterface.

{
    int32 Index = -1;
    if(HUDInterface == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::CloseRadialMenu"));
        return Index;
    }
    Index = HUDInterface->CloseRadialMenu();
    if(IsLookInputIgnored())
    {
        SetIgnoreLookInput(false);
    }
    return Index;
}

ForwardMovementAction()

void APlayerControllerBase::ForwardMovementAction ( const FInputActionValue & Value )

protectedvirtual

Save Default values to be able to get Controller Input

Reimplemented in AALSPlayerController.

{
    MoveAxisY = Value.Get<float>();
}

GetAimAssistLevel()

virtual int32 APlayerControllerBase::GetAimAssistLevel ( ) const

inlineoverridevirtual

Implements IPlayerOptions.

    {
        return PlayerOptions.AimAssistLevel;
    };

GetAudioListenerPosition()

void APlayerControllerBase::GetAudioListenerPosition ( FVector & OutLocation, FVector & OutFrontDir, FVector & OutRightDir ) const

overridevirtual

{
    if(GetPawn() != nullptr)
    {
        const ICharacterBaseInterface* CustomCharacter = Cast<ICharacterBaseInterface>(GetPawn());
        if (CustomCharacter != nullptr)
        {
            FVector HeadLocation;
            if (CustomCharacter->GetAudioSocketLocation(AudioSocket, HeadLocation))
            {
                Super::GetAudioListenerPosition(HeadLocation, OutFrontDir, OutRightDir);
                return;
            }
        }
    }
    Super::GetAudioListenerPosition(OutLocation, OutFrontDir, OutRightDir);
}

GetCameraAimedSensitivityMultiplier()

virtual float APlayerControllerBase::GetCameraAimedSensitivityMultiplier ( ) const

inlineoverridevirtual

Implements IPlayerOptions.

    {
        return PlayerOptions.CameraAimedSensitivityMultiplier;
    };

GetCameraHorizontalSensitivity()

virtual float APlayerControllerBase::GetCameraHorizontalSensitivity ( ) const

inlineoverridevirtual

This get Current Options Setting for Sensitivity, not Full Calculated

Implements IPlayerOptions.

    {
        return PlayerOptions.CameraHorizontalSensitivity;
    };

GetCameraSensitivity()

virtual float APlayerControllerBase::GetCameraSensitivity ( ) const

inlineoverridevirtual

This get Current Options Setting for Sensitivity, not Full Calculated

Implements IPlayerOptions.

    {
        return PlayerOptions.CameraSensitivity;
    };

GetCameraUseSeparateAxisSensitivity()

virtual bool APlayerControllerBase::GetCameraUseSeparateAxisSensitivity ( ) const

inlineoverridevirtual

Implements IPlayerOptions.

    {
        return PlayerOptions.bUseSeparateCameraAxisSensitivity;
    };

GetCameraVerticalSensitivity()

virtual float APlayerControllerBase::GetCameraVerticalSensitivity ( ) const

inlineoverridevirtual

This get Current Options Setting for Sensitivity, not Full Calculated

Implements IPlayerOptions.

    {
        return PlayerOptions.CameraVerticalSensitivity;
    };

GetCharacterInterface()

ICharacterBaseInterface * APlayerControllerBase::GetCharacterInterface ( )

protected

{
    if(GetPawn() == nullptr){return nullptr;}
    if(CharacterBaseInterface == nullptr)
    {
        CharacterBaseInterface = Cast<ICharacterBaseInterface>(GetPawn());
    }
    return CharacterBaseInterface;
}

GetCharacterMode()

virtual FGameplayTag APlayerControllerBase::GetCharacterMode ( ) const

inlineoverridevirtual

Implements IPlayerControllerInterface.

{return CharacterMode;};

GetContentFromLayer()

UUserWidget * APlayerControllerBase::GetContentFromLayer ( const FGameplayTag LayerName, const TSoftClassPtr< UUserWidget > WidgetClass )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr || WidgetClass == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::GetContentFromLayer"));
        return nullptr;
    }
    return GetHUDInterface()->GetContentFromLayer(LayerName, WidgetClass);
}

GetControllerViewPoint()

void APlayerControllerBase::GetControllerViewPoint ( FVector & out_Location, FRotator & out_Rotation ) const

overridevirtual

Implements IControllerInterface.

{
    GetPlayerViewPoint(out_Location, out_Rotation);
}

GetHUDInterface()

IHUDInterface * APlayerControllerBase::GetHUDInterface ( )

protected

{
    if(HUDInterface == nullptr)
    {
        HUDInterface = Cast<IHUDInterface>(GetHUD());
    }
    return HUDInterface;
}

GetIsRadialMenuOpen()

bool APlayerControllerBase::GetIsRadialMenuOpen ( ) const

overridevirtual

Implements IPlayerControllerInterface.

{
    if(HUDInterface == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::GetIsRadialMenuOpen"));
        return false;
    }
    return HUDInterface->GetIsRadialMenuOpen();
}

GetLookAxis()

virtual FVector2D APlayerControllerBase::GetLookAxis ( ) const

inlineoverridevirtual

Implements IPlayerControllerInterface.

{return FVector2D(LookAxisX, LookAxisY);};

GetMoveAxis()

virtual FVector2D APlayerControllerBase::GetMoveAxis ( ) const

inlineoverridevirtual

Implements IPlayerControllerInterface.

{return FVector2D(MoveAxisX, MoveAxisY);};

GetPawnLocation()

FVector APlayerControllerBase::GetPawnLocation ( ) const

overridevirtual

Implements IControllerInterface.

{
    return GetFocalLocation();
}

GetPlayerAudioSettings()

virtual FAudioPlayerOptions APlayerControllerBase::GetPlayerAudioSettings ( ) const

inlineoverridevirtual

Implements IPlayerOptions.

{return PlayerAudioSettings;};

GetPlayerHorizontalInverted()

virtual bool APlayerControllerBase::GetPlayerHorizontalInverted ( ) const

inlineoverridevirtual

Implements IPlayerOptions.

    {
        return PlayerOptions.bInvertedHorizontalCamera;
    };

GetPlayerLookInverted()

virtual bool APlayerControllerBase::GetPlayerLookInverted ( ) const

inlineoverridevirtual

Implements IPlayerOptions.

    {
        return PlayerOptions.bInvertedCamera;
    };

GetPlayerUsingController()

virtual bool APlayerControllerBase::GetPlayerUsingController ( )

inlineoverridevirtual

Implements IPlayerOptions.

{return bUsingController;};

GetScreenCenter()

FVector2D APlayerControllerBase::GetScreenCenter ( ) const

overridevirtual

Implements IPlayerControllerInterface.

{
    int32 ScreenWidth, ScreenHeight;
    GetViewportSize(ScreenWidth, ScreenHeight);
    return FVector2D((ScreenWidth / 2), (ScreenHeight / 2));
}

LoadAudioOptions()

bool APlayerControllerBase::LoadAudioOptions ( )

privatevirtual

{
    if(UGameplayStatics::DoesSaveGameExist(AudioOptionsSaveName, 0))
    {
        USaveGame* LoadedSaveGame = UGameplayStatics::LoadGameFromSlot(AudioOptionsSaveName, 0);
        const USettingsSaveGame* LoadedAudioSettings = Cast<USettingsSaveGame>(LoadedSaveGame);
        if(LoadedAudioSettings != nullptr)
        {
            // UOptionsMenuBPLib::SetAudioVolume()
            // LoadedAudioSettings;
            return true;
        }
        return false;
    }
    if(bDebuggingMode){UE_LOG(LogPlayerController, Warning, TEXT("LoadAudioOptions no Save Found.."));}
    return false;
}

LoadGame()

bool APlayerControllerBase::LoadGame ( )

overridevirtual

Implements ISaveLoad.

{
    //@TODO Add Loading Options here
    const bool bComponentsLoaded = USaveLoadBPLib::LoadAllComponents(this);
    if(bComponentsLoaded == false)
    {
        LogDebugError("Load components Failed");
    }
    // SetControlRotation(LoadedControlRotation)
    return true;
}

LoadPlayerOptions()

bool APlayerControllerBase::LoadPlayerOptions ( const FString & SlotName = "Default" )

protectedvirtual

{
    FString FullSlotName = SlotName;
    const FString PlayerControllerSlotName = FullSlotName.Append(PlayerOptionsSaveName);
    if(UGameplayStatics::DoesSaveGameExist(PlayerControllerSlotName, 0))
    {
        USaveGame* LoadedSaveGame = UGameplayStatics::LoadGameFromSlot(PlayerControllerSlotName, 0);
        const USettingsSaveGame* LoadedPlayerProfileSaveGame = Cast<USettingsSaveGame>(LoadedSaveGame);
        if(LoadedPlayerProfileSaveGame != nullptr)
        {
            ApplySettings(LoadedPlayerProfileSaveGame);
            return true;
        }
        return false;
    }
    if(bDebuggingMode){UE_LOG(LogPlayerController, Warning, TEXT("No Player options Save Found.."));}
    return false;
}

LogDebugError() [1/3]

void APlayerControllerBase::LogDebugError ( const FString & Message ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::LogDebugError);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_PlayerControllerBase);
    LogDebugMessage(Message, true, true);
}

LogDebugError() [2/3]

void APlayerControllerBase::LogDebugError ( const FString & Message, const float Value ) const

protected

{
    LogDebugMessage(Message, Value, true, true);
}

LogDebugError() [3/3]

void APlayerControllerBase::LogDebugError ( const FString & Message, const int32 Value ) const

protected

{
    LogDebugMessage(Message, Value, true, true);
}

LogDebugMessage() [1/4]

void APlayerControllerBase::LogDebugMessage ( const FString & Message, const bool bValue, const bool bWarning, const bool bError ) const

protected

{
    LogDebugMessage(FString::Printf(TEXT("%s: %s"), *Message, bValue ? *FString("true") : *FString("false")), bWarning, bError);
}

LogDebugMessage() [2/4]

void APlayerControllerBase::LogDebugMessage ( const FString & Message, const bool bWarning = false, const bool bError = false ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::LogDebugMessage);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_PlayerControllerBase);
    if(bDebuggingMode == false && bError == false){return;}
    FOutputDevice* OutputDevice = GWarn;
    if(OutputDevice == nullptr){return;}
    FString NetModeString;
    switch(GetWorld()->GetNetMode())
    {
    case NM_Standalone:
        NetModeString = FString("SDL");
        break;
    case NM_DedicatedServer:
        NetModeString = FString("DServer");
        break;
    case NM_ListenServer:
        NetModeString = FString("LServer");
        break;
    case NM_Client:
        NetModeString = FString("Client");
        break;
    default:
        NetModeString = FString("Unknown");
        break;
    }
    const FString FullMessage = FString::Printf(TEXT("%s: %s::%s"), *NetModeString, *GetName(), *Message);
    if(bError)
    {
        OutputDevice->Log(CategoryName, ELogVerbosity::Error, FullMessage);
    }
    else if(bWarning)
    {
        OutputDevice->Log(CategoryName, ELogVerbosity::Warning, FullMessage);
    }
    else
    {
        OutputDevice->Log(CategoryName, ELogVerbosity::Log, FullMessage);
    }
 
}

LogDebugMessage() [3/4]

void APlayerControllerBase::LogDebugMessage ( const FString & Message, const float Value, const bool bWarning = false, const bool bError = false ) const

protected

{
    LogDebugMessage(FString::Printf(TEXT("%s: %f"), *Message, Value), bWarning, bError);    
}

LogDebugMessage() [4/4]

void APlayerControllerBase::LogDebugMessage ( const FString & Message, const int32 Value, const bool bWarning = false, const bool bError = false ) const

protected

{
    LogDebugMessage(FString::Printf(TEXT("%s: %i"), *Message, Value), bWarning, bError);
}

LogDebugWarning() [1/3]

void APlayerControllerBase::LogDebugWarning ( const FString & Message ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::LogDebugWarning);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_PlayerControllerBase);
    LogDebugMessage(Message, true);
}

LogDebugWarning() [2/3]

void APlayerControllerBase::LogDebugWarning ( const FString & Message, const float Value ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::LogDebugWarning);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_PlayerControllerBase);
    LogDebugMessage(Message, Value, true);
}

LogDebugWarning() [3/3]

void APlayerControllerBase::LogDebugWarning ( const FString & Message, const int32 Value ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::LogDebugWarning);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_PlayerControllerBase);
    LogDebugMessage(Message, Value, true);
}

LogOnScreenMessage()

void APlayerControllerBase::LogOnScreenMessage ( const int32 Key, const FString & Message, FColor Color = FColor::Green ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::LogOnScreenMessage);
    // SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_PlayerControllerBase);
    if(bDebuggingMode)
    {
        GEngine->AddOnScreenDebugMessage(Key, 2.0f, Color,
            FString::Printf(TEXT(" %s  - in %s of %s"), ToCStr(Message), ToCStr(GetName()), ToCStr(GetOwner()->GetName())));
    }
}

MenuBackAction()

void APlayerControllerBase::MenuBackAction ( const FInputActionValue & Value )

protectedvirtual

{
    const bool bUpSelection = Value.Get<bool>();
    if(GetHUDInterface() == nullptr){UE_LOG(LogBasePlayerController, Error, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::MenuBackAction"));return;}
    GetHUDInterface()->HUDCancel();
    if(bDebuggingMode){UE_LOG(LogBasePlayerController, Warning, TEXT("Menu Back Action"));}
}

MenuConfirmAction()

void APlayerControllerBase::MenuConfirmAction ( const FInputActionValue & Value )

protectedvirtual

{
    if(GetHUDInterface() == nullptr){UE_LOG(LogBasePlayerController, Error, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::MenuConfirmAction"));return;}
    GetHUDInterface()->HUDConfirm();
    if(bDebuggingMode){UE_LOG(LogBasePlayerController, Warning, TEXT("Menu Confirm Action"));}
}

OnCharacterModeChanged()

void APlayerControllerBase::OnCharacterModeChanged

(

const FGameplayTag &

Mode

)

OnPawnSpawn()

void APlayerControllerBase::OnPawnSpawn ( )

protectedvirtual

Reimplemented in ACustomPlayerController.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::OnPawnSpawn);
    if(!IsLocalController())
    {
        GetWorld()->GetTimerManager().ClearTimer(SetupCompleteDelayTimerHandle);
        return;
    }
    if(PawnSpawnAttempts >= MaxPawnSpawnAttempts)
    {
        GetWorld()->GetTimerManager().ClearTimer(SetupCompleteDelayTimerHandle);
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::OnPawnSpawn - Max Pawn Spawn Attempts HIT"));
        return;
    }
    
    LoadPlayerOptions();
    LoadAudioOptions();
    SetupInputs();
    GetHUDInterface();
    GetCharacterInterface();
    SetupComponents();
    // if(MultiplayerGS == nullptr)
    // {
    //  MultiplayerGS = Cast<IMultiplayerGS>(UGameplayStatics::GetGameState(this));
    //  GetWorld()->GetTimerManager().SetTimer(UpdateScoreDelayTimerHandle, this, &ACustomPlayerController::GetScore, MultiplayerDelayTime);
    // }
    // HUD = Cast<ACustomHUD>(GetHUD());
    // if(HUD != nullptr)
    // {
    //  if(PossessedCustomCharacter != nullptr)
    //  {
    //      if(GetCustomPlayerState() != nullptr)
    //      {
    //          HUD->SetPlayerTeamID(GetCustomPlayerState()->GetTeamID());
    //          if(MenuSystem != nullptr)
    //          {
    //              if(MenuSystem->GetIsPlayerLoggedIn())
    //              {
    //                  PossessedCustomCharacter->SetPlayerName(GetCustomPlayerState()->GetUserProfile().DisplayName);
    //                  // PossessedCustomCharacter->SetPlayerName(MenuSystem->GetOnlinePlayerProfile().DisplayName);
    //              }
    //          }
    //      }
    //      HUD->SetupWidgets();
    //      PossessedCustomCharacter->SetupComponents(this, HUD, IsLocalController());
    //  }
    //  if(ChatSystemComponent != nullptr)
    //  {
    //      ChatSystemComponent->SetOwnerPlayerController(this);
    //      if(MenuSystem != nullptr)
    //      {
    //          if(MenuSystem->GetIsPlayerLoggedIn() && GetCustomPlayerState() != nullptr)
    //          {
    //              ChatSystemComponent->SetPlayerUserProfile(GetCustomPlayerState()->GetUserProfile());
    //              // ChatSystemComponent->SetPlayerUserProfile(MenuSystem->GetOnlinePlayerProfile());
    //          }
    //      }
    //      ChatSystemComponent->SetChatBoxWidget(HUD->GetChatBoxWidget());
    //      ChatSystemComponent->ComponentSetup();
    //  }
    // }
    // else
    // {
    //  if(PossessedCustomCharacter != nullptr)
    //  {
    //      PossessedCustomCharacter->SetupComponents(this, nullptr, IsLocalController());
    //  }
    //  UE_LOG(LogTemp,Error,TEXT("HUD Class Failed"));
    // }
    PawnSpawnAttempts++;
 
    // if(PossessedCustomCharacter == nullptr)
    // {
    //  GetWorld()->GetTimerManager().SetTimer(SetupCompleteDelayTimerHandle, this, &ACustomPlayerController::OnPawnSpawn, MultiplayerStartDelay);
    //  return;
    // }
    
    //- Pawn Spawn Complete ->
    GetWorld()->GetTimerManager().SetTimer(SetupCompleteDelayTimerHandle, this, &APlayerControllerBase::OnPawnSpawnComplete, MultiplayerStartDelay);
 
}

OnPawnSpawnComplete()

void APlayerControllerBase::OnPawnSpawnComplete ( )

protectedvirtual

Reimplemented in ACustomPlayerController, and AQuestExamplePlayerController.

{
    EnableInput(this);
    if(CharacterBaseInterface == nullptr)
    {
        UE_LOG(LogBasePlayerController, Warning, TEXT("Character INTERFACE FAILED IN APlayerControllerBase::GetCharacterInterface"));
    }
    if(HUDInterface == nullptr)
    {
        UE_LOG(LogBasePlayerController, Warning, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::GetHUDInterface"));
    }
    if(GetCharacterInterface() != nullptr)
    {
        GetCharacterInterface()->OnPawnSpawned();
    }
    // if(HUD != nullptr)
    // {
    //  HUD->FadeIn();
    // }
    
 
}

OnPossess()

void APlayerControllerBase::OnPossess ( APawn * NewPawn )

overrideprotectedvirtual

Reimplemented in AALSPlayerController, and ACustomPlayerController.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(APlayerControllerBase::OnPossess);
    Super::OnPossess(NewPawn);
    CharacterBaseInterface = nullptr;
    SetupInputs();
    if(GetSpectatorPawn() == nullptr)
    {
        GetWorld()->GetTimerManager().SetTimer(SetupCompleteDelayTimerHandle, this, &APlayerControllerBase::OnPawnSpawn, MultiplayerStartDelay, false);
    }
    OnRep_Pawn();
}

OnRep_Pawn()

void APlayerControllerBase::OnRep_Pawn ( )

overrideprotectedvirtual

Reimplemented in AALSPlayerController, and ACustomPlayerController.

{
    Super::OnRep_Pawn();
    SetupInputs();
    if(GetSpectatorPawn() == nullptr)
    {
        GetWorld()->GetTimerManager().SetTimer(SetupCompleteDelayTimerHandle, this, &APlayerControllerBase::OnPawnSpawn, MultiplayerStartDelay, false);
    }
}

OpenRadialMenu()

void APlayerControllerBase::OpenRadialMenu ( const FRadialMenuData & Data )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(Data.IsEmpty())
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("No Options dummy APlayerControllerBase::OpenRadialMenu"));
        return;
    }
    if(HUDInterface == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::OpenRadialMenu"));
        return;
    }
    HUDInterface->OpenRadialMenu(Data);
    if(HUDInterface->GetIsRadialMenuOpen())
    {
        if(IsLookInputIgnored() == false)
        {
            SetIgnoreLookInput(true);
        }
    }
}

PopContentFromLayer()

bool APlayerControllerBase::PopContentFromLayer ( const FGameplayTag LayerName )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::PopContentFromLayer"));
        return false;
    }
    return GetHUDInterface()->PopContentFromLayer(LayerName);
}

PushContentToLayer()

UUserWidget * APlayerControllerBase::PushContentToLayer ( const FGameplayTag LayerName, const TSoftClassPtr< UUserWidget > WidgetClass )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::PushContentToLayer"));
        return nullptr;
    }
    return GetHUDInterface()->PushContentToLayer(LayerName, WidgetClass);
}

RegisterLayer()

bool APlayerControllerBase::RegisterLayer ( const FGameplayTag LayerName, UUserWidget * LayerWidget )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr || LayerWidget == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::RegisterLayer"));
        return false;
    }
    return GetHUDInterface()->RegisterLayer(LayerName, LayerWidget);
}

RightMovementAction()

void APlayerControllerBase::RightMovementAction ( const FInputActionValue & Value )

protectedvirtual

Reimplemented in AALSPlayerController.

{
    MoveAxisX = Value.Get<float>();
}

SaveAudioOptions()

bool APlayerControllerBase::SaveAudioOptions ( const FAudioPlayerOptions AudioSettings )

privatevirtual

{
    if(UGameplayStatics::DoesSaveGameExist(AudioOptionsSaveName, 0))
    {
        USaveGame* LoadedSaveGame = UGameplayStatics::LoadGameFromSlot(AudioOptionsSaveName, 0);
        USettingsSaveGame* LoadedAudioSettings = Cast<USettingsSaveGame>(LoadedSaveGame);
        if(LoadedAudioSettings != nullptr)
        {
            PlayerAudioSettings = AudioSettings;
            LoadedAudioSettings->AudioOptions = PlayerAudioSettings;
            return UGameplayStatics::SaveGameToSlot(LoadedAudioSettings, AudioOptionsSaveName, 0);
        }
    }
    else
    {
        USaveGame* NewSaveGame = UGameplayStatics::CreateSaveGameObject(USettingsSaveGame::StaticClass());
        USettingsSaveGame* NewAudioSettings = Cast<USettingsSaveGame>(NewSaveGame);
        if(NewAudioSettings != nullptr)
        {
            PlayerAudioSettings = AudioSettings;
            NewAudioSettings->AudioOptions = PlayerAudioSettings;
            return UGameplayStatics::SaveGameToSlot(NewAudioSettings, AudioOptionsSaveName, 0);
        }
    }
    return false;
}

SaveCurrentPlayerOptions()

bool APlayerControllerBase::SaveCurrentPlayerOptions ( const FAudioPlayerOptions AudioSettings )

overridevirtual

Implements IPlayerOptions.

{
    SaveAudioOptions(AudioSettings);
    return SavePlayerOptions();
}

SaveGame()

bool APlayerControllerBase::SaveGame ( )

overridevirtual

Implements ISaveLoad.

{
    const bool bComponentsSaved = USaveLoadBPLib::SaveAllComponents(this);
    if(bComponentsSaved == false)
    {
        LogDebugError("Save components Failed");
    }
    //GetControlRotation();
    // SaveCurrentPlayerOptions(AudioOp)
    return true;
}

SavePlayerOptions()

bool APlayerControllerBase::SavePlayerOptions ( const FString & SlotName = "Default" )

protectedvirtual

{
    FString FullSlotName = SlotName;
    const FString PlayerControllerSlotName = FullSlotName.Append(PlayerOptionsSaveName);
    if(UGameplayStatics::DoesSaveGameExist(PlayerControllerSlotName, 0))
    {
        USaveGame* LoadedSaveGame = UGameplayStatics::LoadGameFromSlot(PlayerControllerSlotName, 0);
        USettingsSaveGame* LoadedPlayerProfileSaveGame = Cast<USettingsSaveGame>(LoadedSaveGame);
        if(LoadedPlayerProfileSaveGame != nullptr)
        {
            return UGameplayStatics::SaveGameToSlot(ApplySettingsToSaveGame(LoadedPlayerProfileSaveGame), PlayerControllerSlotName, 0);
        }
    }
    else
    {
        USaveGame* NewSaveGame = UGameplayStatics::CreateSaveGameObject(USettingsSaveGame::StaticClass());
        USettingsSaveGame* NewPlayerProfileSaveGame = Cast<USettingsSaveGame>(NewSaveGame);
        if(NewPlayerProfileSaveGame != nullptr)
        {
            return UGameplayStatics::SaveGameToSlot(ApplySettingsToSaveGame(NewPlayerProfileSaveGame), PlayerControllerSlotName, 0);
        }
    }
    return false;
}

SelectionUpAction()

void APlayerControllerBase::SelectionUpAction ( const FInputActionValue & Value )

protectedvirtual

Reimplemented in ACustomPlayerController.

{
    const bool bUpSelection = Value.Get<bool>();
    if(GetHUDInterface() == nullptr){UE_LOG(LogBasePlayerController, Error, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::SelectionUpAction"));return;}
    HUDInterface->HUDSelectionVertical(bUpSelection);
}

SetAimAssistLevel()

virtual void APlayerControllerBase::SetAimAssistLevel ( const int32 Value )

inlineoverridevirtual

Implements IPlayerOptions.

Reimplemented in ACustomPlayerController.

    {
        PlayerOptions.AimAssistLevel = Value;
    };

SetCameraAimedSensitivityMultiplier()

virtual void APlayerControllerBase::SetCameraAimedSensitivityMultiplier ( const float NewValue )

inlineoverridevirtual

Implements IPlayerOptions.

    {
        PlayerOptions.CameraAimedSensitivityMultiplier = NewValue;
    };

SetCameraHorizontalSensitivity()

virtual float APlayerControllerBase::SetCameraHorizontalSensitivity ( const float NewValue )

inlineoverridevirtual

Implements IPlayerOptions.

    {
        PlayerOptions.CameraHorizontalSensitivity = NewValue;
        return PlayerOptions.CameraHorizontalSensitivity;
    };

SetCameraSensitivity()

virtual float APlayerControllerBase::SetCameraSensitivity ( const float NewValue )

inlineoverridevirtual

Mouse/Controller Sensitivity,

Returns

new Sensitivity

Implements IPlayerOptions.

    {
        PlayerOptions.CameraSensitivity = NewValue;
        return PlayerOptions.CameraSensitivity;
    };

SetCameraUseSeparateAxisSensitivity()

virtual void APlayerControllerBase::SetCameraUseSeparateAxisSensitivity ( const bool bValue )

inlineoverridevirtual

Implements IPlayerOptions.

    {
        PlayerOptions.bUseSeparateCameraAxisSensitivity = bValue;
    };

SetCameraVerticalSensitivity()

virtual float APlayerControllerBase::SetCameraVerticalSensitivity ( const float NewValue )

inlineoverridevirtual

Implements IPlayerOptions.

    {
        PlayerOptions.CameraVerticalSensitivity = NewValue;
        return PlayerOptions.CameraVerticalSensitivity;
    };

SetCategoryName()

void APlayerControllerBase::SetCategoryName ( const FLogCategoryBase & Category )

inlineprotected

{CategoryName = Category.GetCategoryName();};

SetCharacterMode()

void APlayerControllerBase::SetCharacterMode ( const FGameplayTag & Mode )

overridevirtual

Implements IPlayerControllerInterface.

{
    CharacterMode = Mode;
    OnCharacterModeChanged(Mode);
    if(Mode == CharacterModeTags::Default)
    {
        // Movement
        FlushPressedKeys();
        EnableInput(this);
        SetInputMode(FInputModeGameOnly());
        bShowMouseCursor = false;
        FlushPressedKeys();
    }
    if(Mode == CharacterModeTags::Build)
    {
        
    }
    if(Mode == CharacterModeTags::Command)
    {
        
    }
    if(Mode == CharacterModeTags::Menu)
    {
        
    }
    if(Mode == CharacterModeTags::Talking)
    {
        StopMovement();
        FlushPressedKeys();
        FInputModeUIOnly InputModeUIOnly;
        SetInputMode(FInputModeUIOnly());
        bShowMouseCursor = true;
        StopMovement();
        EnableInput(this);
    }
    if(CharacterBaseInterface != nullptr)
    {
        CharacterBaseInterface->CharacterModeChanged(Mode);
    }
    for(auto& Component: GetComponents())
    {
        UCommonActorComponent* PlayerControllerComponent = Cast<UCommonActorComponent>(Component);
        if(PlayerControllerComponent == nullptr){continue;}
        PlayerControllerComponent->CharacterModeChanged(Mode);
    }
}

SetPlayerLookHorizontalInverted()

virtual bool APlayerControllerBase::SetPlayerLookHorizontalInverted ( const bool bInvert = true )

inlineoverridevirtual

Implements IPlayerOptions.

    {
        PlayerOptions.bInvertedHorizontalCamera = bInvert;
        return PlayerOptions.bInvertedHorizontalCamera;
    };

SetPlayerLookInverted()

virtual bool APlayerControllerBase::SetPlayerLookInverted ( const bool bInvert = true )

inlineoverridevirtual

Inverts the player look, returns if the if inverted

Implements IPlayerOptions.

    {
        PlayerOptions.bInvertedCamera = bInvert;
        return PlayerOptions.bInvertedCamera;
    };

SetPlayerUsingController()

virtual void APlayerControllerBase::SetPlayerUsingController ( const bool bValue )

inlineoverridevirtual

Implements IPlayerOptions.

{bIsPlayerController = bValue;};

SetupComponents()

void APlayerControllerBase::SetupComponents ( )

protectedvirtual

{
    for(auto& Component: GetComponents())
    {
        UCommonActorComponent* PlayerControllerComponent = Cast<UCommonActorComponent>(Component);
        if(PlayerControllerComponent == nullptr){continue;}
        PlayerControllerComponent->SetupComponent();
    }
}

SetupInputComponent()

void APlayerControllerBase::SetupInputComponent ( )

overrideprotectedvirtual

Reimplemented in AALSPlayerController, and ACustomPlayerController.

{
    Super::SetupInputComponent();
    UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(InputComponent);
    if(EnhancedInputComponent == nullptr)
    {
        UE_LOG(LogBasePlayerController, Fatal, TEXT("Base Helpers Plugin requires Enhanced Input System to be activated in project settings to function properly"));
        return;
    }
    EnhancedInputComponent->ClearActionEventBindings();
    EnhancedInputComponent->ClearActionValueBindings();
    EnhancedInputComponent->ClearDebugKeyBindings();
    BindActions(MenuInputMappingContext);
    BindActions(MainInputMappingContext);
}

SetupInputs()

void APlayerControllerBase::SetupInputs ( )

protectedvirtual

Reimplemented in AALSPlayerController.

{
    if(GetPawn() == nullptr){UE_LOG(LogBaseHelpers, Error, TEXT("Get Pawn failed in PC Base - Setup Inputs"));return;}
    if(UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer()))
    {
        FModifyContextOptions Options;
        Options.bForceImmediately = 1;
        Subsystem->AddMappingContext(MenuInputMappingContext, 1, Options);
        Subsystem->AddMappingContext(MainInputMappingContext, 2, Options);
    }
}

ToggleGameLog()

void APlayerControllerBase::ToggleGameLog ( )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr){UE_LOG(LogBasePlayerController, Error, TEXT("HUD INTERFACE FAILED IN APlayerControllerBase::ToggleGameLog"));return;}
    GetHUDInterface()->ToggleGameLog();
}

ToggleWidget()

bool APlayerControllerBase::ToggleWidget ( const FGameplayTag LayerName, UUserWidget * Widget )

overridevirtual

Implements IPlayerControllerInterface.

{
    if(GetHUDInterface() == nullptr || Widget == nullptr)
    {
        UE_LOG(LogBasePlayerController, Error, TEXT("APlayerControllerBase::ToggleWidget"));
        return false;
    }
    return GetHUDInterface()->ToggleWidget(LayerName, Widget);
}

Member Data Documentation

AudioSocket

FName APlayerControllerBase::AudioSocket = FName("head")

bAimed

bool APlayerControllerBase::bAimed = false

protected

bDebuggingMode

bool APlayerControllerBase::bDebuggingMode = false

bUsingController

bool APlayerControllerBase::bUsingController = false

private

CategoryName

FLogCategoryName APlayerControllerBase::CategoryName = LogBasePlayerController.GetCategoryName()

private

CharacterBaseInterface

ICharacterBaseInterface* APlayerControllerBase::CharacterBaseInterface

private

CharacterMode

FGameplayTag APlayerControllerBase::CharacterMode = FGameplayTag(CharacterModeTags::Default)

protected

CharacterModesMenuData

FRadialMenuData APlayerControllerBase::CharacterModesMenuData

private

HUDInterface

IHUDInterface* APlayerControllerBase::HUDInterface

private

LookAxisX

float APlayerControllerBase::LookAxisX = 0.0f

private

LookAxisY

float APlayerControllerBase::LookAxisY = 0.0f

private

MainInputMappingContext

TObjectPtr<UInputMappingContext> APlayerControllerBase::MainInputMappingContext = nullptr

MaxPawnSpawnAttempts

int32 APlayerControllerBase::MaxPawnSpawnAttempts = 5

protected

MenuInputMappingContext

TObjectPtr<UInputMappingContext> APlayerControllerBase::MenuInputMappingContext = nullptr

MoveAxisX

float APlayerControllerBase::MoveAxisX = 0.0f

private

MoveAxisY

float APlayerControllerBase::MoveAxisY = 0.0f

private

MultiplayerStartDelay

float APlayerControllerBase::MultiplayerStartDelay = 0.5f

private

PawnSpawnAttempts

int32 APlayerControllerBase::PawnSpawnAttempts = 0

private

PlayerAudioSettings

FAudioPlayerOptions APlayerControllerBase::PlayerAudioSettings

private

PlayerOptions

FGameplayPlayerOptions APlayerControllerBase::PlayerOptions

private

PlayerOptionsSaveName

FString APlayerControllerBase::PlayerOptionsSaveName = "_PlayerSettings"

private

SetupCompleteDelayTimerHandle

FTimerHandle APlayerControllerBase::SetupCompleteDelayTimerHandle

private

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Public/Character/PlayerControllerBase.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Private/Character/PlayerControllerBase.cpp