PlayerControllerBase.h

Go to the documentation of this file.

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameplayTagContainer.h"
#include "InputActionValue.h"
#include "Data/BaseGameplayTags.h"
#include "Data/SettingsSaveGame.h"
#include "GameFramework/PlayerController.h"
#include "Interfaces/ControllerInterface.h"
#include "Interfaces/InputKeyInterface.h"
#include "Interfaces/PlayerControllerInterface.h"
#include "Interfaces/PlayerOptions.h"
#include "Interfaces/SaveLoad.h"
#include "PlayerControllerBase.generated.h"
 
class ICharacterBaseInterface;
class IHUDInterface;
class UInputMappingContext;
 
DECLARE_LOG_CATEGORY_CLASS(LogBasePlayerController, Display, All);
 
UCLASS()
class BASEHELPERS_API APlayerControllerBase : public APlayerController, public IPlayerOptions, public IControllerInterface, public IPlayerControllerInterface, public ISaveLoad//, public IInputKeyInterface
{
    GENERATED_BODY()
 
public:
 
    virtual void GetAudioListenerPosition(FVector& OutLocation, FVector& OutFrontDir, FVector& OutRightDir) const override;
 
    
    virtual void BindActions(UInputMappingContext* Context);
 
    //~     Player Options Interface    ~//
    virtual bool SetPlayerLookInverted(const bool bInvert = true) override
    {
        PlayerOptions.bInvertedCamera = bInvert;
        return PlayerOptions.bInvertedCamera;
    };
    virtual bool SetPlayerLookHorizontalInverted(const bool bInvert = true) override
    {
        PlayerOptions.bInvertedHorizontalCamera = bInvert;
        return PlayerOptions.bInvertedHorizontalCamera;
    };
    virtual float SetCameraSensitivity(const float NewValue) override
    {
        PlayerOptions.CameraSensitivity = NewValue;
        return PlayerOptions.CameraSensitivity;
    };
    virtual float SetCameraHorizontalSensitivity(const float NewValue) override
    {
        PlayerOptions.CameraHorizontalSensitivity = NewValue;
        return PlayerOptions.CameraHorizontalSensitivity;
    };
    virtual float SetCameraVerticalSensitivity(const float NewValue) override
    {
        PlayerOptions.CameraVerticalSensitivity = NewValue;
        return PlayerOptions.CameraVerticalSensitivity;
    };
    virtual void SetCameraAimedSensitivityMultiplier(const float NewValue) override
    {
        PlayerOptions.CameraAimedSensitivityMultiplier = NewValue;
    };
 
    virtual void SetCameraUseSeparateAxisSensitivity(const bool bValue) override
    {
        PlayerOptions.bUseSeparateCameraAxisSensitivity = bValue;
    };
    virtual void SetAimAssistLevel(const int32 Value) override
    {
        PlayerOptions.AimAssistLevel = Value;
    };
    virtual void SetPlayerUsingController(const bool bValue) override {bIsPlayerController = bValue;};
    virtual bool GetPlayerUsingController() override {return bUsingController;};
    virtual bool SaveCurrentPlayerOptions(const FAudioPlayerOptions AudioSettings) override;
    
    virtual float GetCameraSensitivity() const override
    {
        return PlayerOptions.CameraSensitivity;
    };
    virtual float GetCameraAimedSensitivityMultiplier() const override
    {
        return PlayerOptions.CameraAimedSensitivityMultiplier;
    };
    virtual float GetCameraHorizontalSensitivity() const override
    {
        return PlayerOptions.CameraHorizontalSensitivity;
    };
    virtual float GetCameraVerticalSensitivity() const override
    {
        return PlayerOptions.CameraVerticalSensitivity;
    };
    virtual bool GetCameraUseSeparateAxisSensitivity() const override
    {
        return PlayerOptions.bUseSeparateCameraAxisSensitivity;
    };
    virtual bool GetPlayerLookInverted() const override
    {
        return PlayerOptions.bInvertedCamera;
    };
    virtual bool GetPlayerHorizontalInverted() const override
    {
        return PlayerOptions.bInvertedHorizontalCamera;
    };
    virtual int32 GetAimAssistLevel() const override
    {
        return PlayerOptions.AimAssistLevel;
    };
 
    virtual FAudioPlayerOptions GetPlayerAudioSettings() const override {return PlayerAudioSettings;};
 
    //~     Player Options Interface    ~//
 
 
    //~     Player Controller Interface     ~//
    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 {return CharacterMode;};
    virtual void ToggleGameLog() override;
 
    virtual FVector2D GetLookAxis() const override {return FVector2D(LookAxisX, LookAxisY);};
    virtual FVector2D GetMoveAxis() const override {return FVector2D(MoveAxisX, MoveAxisY);};
    virtual FVector2D GetScreenCenter() const override;
    //~     Player Controller Interface     ~//
 
    //~     Controller Interface        ~//
    virtual FVector GetPawnLocation() const override;
    virtual void GetControllerViewPoint(FVector& out_Location, FRotator& out_Rotation) const override;
    //~     Controller Interface        ~//
 
 
    //~         ISaveLoad       ~//
    virtual bool SaveGame() override;
    virtual bool LoadGame() override;
    //~         ISaveLoad       ~//
 
    UFUNCTION(BlueprintImplementableEvent, Category="Controller")
    void OnCharacterModeChanged(const FGameplayTag& Mode);
    
    
protected:
    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;
 
 
    //~     Actions     ~//
    UFUNCTION()
    virtual void MenuConfirmAction(const FInputActionValue& Value);
    UFUNCTION()
    virtual void MenuBackAction(const FInputActionValue& Value);
    UFUNCTION()
    virtual void SelectionUpAction(const FInputActionValue& Value);
    UFUNCTION()
    virtual void ForwardMovementAction(const FInputActionValue& Value);
    UFUNCTION()
    virtual void RightMovementAction(const FInputActionValue& Value);
    UFUNCTION()
    virtual void CameraUpAction(const FInputActionValue& Value);
    UFUNCTION()
    virtual void CameraRightAction(const FInputActionValue& Value);
    UFUNCTION()
    virtual void CharacterModeAction(const FInputActionValue& Value);
    //~     Actions     ~//
    
 
    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){CategoryName = Category.GetCategoryName();};
 
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Character")
    FGameplayTag CharacterMode = FGameplayTag(CharacterModeTags::Default);
    
    // /** Gets the Player Controllers Input Mapping    */
    // virtual UInputMappingContext* GetInputActions() override;
    // virtual EGameControllerType GetControllerType() override;
    // virtual float GetInputAxisAmount(const bool bController, const bool bLeftStick) override;
    // virtual float GetInputAxisAmount(const TObjectPtr<UInputAction>& AxisAction);
    // virtual float GetInputAxisAmount(const bool bController, const bool bLeftStick) override;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Multiplayer")
    int32 MaxPawnSpawnAttempts = 5;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Controller|Status")
    bool bAimed = false;
 
public:
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Input")
    TObjectPtr<UInputMappingContext> MenuInputMappingContext = nullptr;
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Input")
    TObjectPtr<UInputMappingContext> MainInputMappingContext = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Controller|Debugging")
    bool bDebuggingMode = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Controller|Debugging")
    FName AudioSocket = FName("head");
 
 
    
private:
 
    virtual bool SaveAudioOptions(const FAudioPlayerOptions AudioSettings);
    virtual bool LoadAudioOptions();
 
    IHUDInterface* HUDInterface;
 
    FLogCategoryName CategoryName = LogBasePlayerController.GetCategoryName();
 
    ICharacterBaseInterface* CharacterBaseInterface;
    FRadialMenuData CharacterModesMenuData;
    //@TODO Change to object?
    // TWeakObjectPtr<UObject> CharacterBase;
 
    
    UPROPERTY(VisibleAnywhere, Category="Player Options")
    FGameplayPlayerOptions PlayerOptions;
    UPROPERTY(VisibleAnywhere, Category="Player Options")
    FAudioPlayerOptions PlayerAudioSettings;
 
    UPROPERTY(EditAnywhere, Category="Player Options")
    bool bUsingController = false;
    
    
    UPROPERTY(VisibleAnywhere, Category="Player Options")
    FString PlayerOptionsSaveName = "_PlayerSettings";
 
    UPROPERTY(VisibleAnywhere, Category="Controller|Input")
    float MoveAxisY = 0.0f;
    UPROPERTY(VisibleAnywhere, Category="Controller|Input")
    float MoveAxisX = 0.0f;
    UPROPERTY(VisibleAnywhere, Category="Controller|Input")
    float LookAxisY = 0.0f;
    UPROPERTY(VisibleAnywhere, Category="Controller|Input")
    float LookAxisX = 0.0f;
 
    UPROPERTY(EditAnywhere, Category = "Controller|Delay")
    float MultiplayerStartDelay = 0.5f;
 
    FTimerHandle SetupCompleteDelayTimerHandle;
    int32 PawnSpawnAttempts = 0;
 
};