PlayerControllerComponent.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 "CommonActorComponent.h"
#include "Components/ActorComponent.h"
#include "PlayerControllerComponent.generated.h"
 
struct FGameplayTag;
DECLARE_LOG_CATEGORY_EXTERN(LogPlayerControllerComp, Display, All);
 
 
UCLASS(ClassGroup=(BucciGames), meta=(BlueprintSpawnableComponent), Abstract)
class BASEHELPERS_API UPlayerControllerComponent : public UCommonActorComponent
{
    GENERATED_BODY()
 
    //Taken from GameFramework Component 
public:
    template <class T>
    T* GetGameInstance() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, UGameInstance>::Value, "'T' template parameter to GetGameInstance must be derived from UGameInstance");
        AActor* Owner = GetOwner();
        return Owner ? Owner->GetGameInstance<T>() : nullptr;
    }
    template <class T>
    T* GetGameInstanceChecked() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, UGameInstance>::Value, "'T' template parameter to GetGameInstance must be derived from UGameInstance");
        AActor* Owner = GetOwner();
        check(Owner);
        T* GameInstance = Owner->GetGameInstance<T>();
        check(GameInstance);
        return GameInstance;
    }
    
    
    //Taken from Controller Component 
    template <class T>
    T* GetController() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, AController>::Value, "'T' template parameter to GetController must be derived from AController");
        return Cast<T>(GetOwner());
    }
 
    template <class T>
    T* GetControllerChecked() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, AController>::Value, "'T' template parameter to GetControllerChecked must be derived from AController");
        return CastChecked<T>(GetOwner());
    }
 
    // Controller accessors
    // Usable for any type of AController owner, only valid if called during gameplay
 
    template <class T>
    T* GetPawn() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, APawn>::Value, "'T' template parameter to GetPawn must be derived from APawn");
        return Cast<T>(GetControllerChecked<AController>()->GetPawn());
    }
 
    template <class T>
    T* GetViewTarget() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, AActor>::Value, "'T' template parameter to GetViewTarget must be derived from APawn");
        return Cast<T>(GetControllerChecked<AController>()->GetViewTarget());
    }
 
    template <class T>
    T* GetPawnOrViewTarget() const
    {
        if (T* Pawn = GetPawn<T>())
        {
            return Pawn;
        }
        else
        {
            return GetViewTarget<T>();
        }
    }
    template <class T>
    T* GetPlayerState() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, APlayerState>::Value, "'T' template parameter to GetPlayerState must be derived from APlayerState");
        return GetControllerChecked<AController>()->GetPlayerState<T>();
    }
 
    bool IsLocalController() const;
 
    void GetPlayerViewPoint(FVector& Location, FRotator& Rotation) const;
 
    // PlayerController accessors
    // Only returns correct values for APlayerController owners
 
    template <class T>
    T* GetPlayer() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, UPlayer>::Value, "'T' template parameter to GetPlayer must be derived from UPlayer");
        APlayerController* PC = Cast<APlayerController>(GetOwner());
        return PC ? Cast<T>(PC->Player) : nullptr;
    }
 
 
public:
    UPlayerControllerComponent();
    
    //~~        ISaveLoad       ~~//
    virtual bool SaveGame() override;
    virtual bool LoadGame() override;
    //~~        ISaveLoad       ~~//
 
    virtual void ComponentSetupComplete() override;
    
    
    UFUNCTION(BlueprintImplementableEvent, Category="Controller Component", meta=(DisplayName = "On Component Deactivated"))
    void OnComponentDeactivatedEvent(UActorComponent* Component);
    UFUNCTION(BlueprintImplementableEvent, Category="Controller Component", meta=(DisplayName = "On Component Activated"))
    void OnComponentActivatedEvent(UActorComponent* Component, const bool bReset);
 
    //- Player Camera   //
    UFUNCTION(BlueprintCallable, Category="Controller Component")
    virtual FVector GetCameraTraceLocation() const;
    /* The Camera Trace Location with the Distance to the player Added */
    UFUNCTION(BlueprintCallable, Category="Controller Component")
    virtual FVector GetPlayerTraceLocation() const;
    UFUNCTION(BlueprintCallable, Category="Controller Component")
    virtual FRotator GetCameraTraceRotation() const;
    UFUNCTION(BlueprintCallable, Category="Controller Component")
    virtual FTransform GetCameraTraceTransform() const;
 
    UUserWidget* PushContentToLayer(const FGameplayTag& LayerName, const TSoftClassPtr<UUserWidget>& WidgetClass) const;
    UUserWidget* AddWidgetToLayer(const FGameplayTag& LayerName,const TSoftClassPtr<UUserWidget>& WidgetClass) const;
    UUserWidget* GetContentFromLayer(const FGameplayTag& LayerName, const TSoftClassPtr<UUserWidget>& WidgetClass) const;
    UUserWidget* AddWidgetToLayerWithSlot(const FGameplayTag& LayerName, const FGameplayTag& SlotTag, const TSoftClassPtr<UUserWidget>& WidgetClass) const;
 
    // UFUNCTION(BlueprintCallable, Category="Controller Component|Widgets")
    bool ToggleWidget(const FGameplayTag& LayerName, const TSoftClassPtr<UUserWidget>& WidgetClass) const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Controller Component")
    bool bAllowAIControllers = false;
 
protected:
    virtual void BeginPlay() override;
 
    virtual void AutoDetect() override;
 
 
    
    //@ TODO if needed replace with GetOwnerHUD REf and Get AActor* or *IHUDInterface
    // UFUNCTION(BlueprintCallable, Category="Controller Component")
    // class AHUD* GetOwnerHUD() const; 
    UFUNCTION(BlueprintCallable, Category="Controller Component")
    FVector2D GetScreenCenter() const;
 
    class IPlayerControllerInterface* GetPlayerControllerInterface();
    class IControllerInterface* GetControllerInterface();
 
private:
 
    class IPlayerControllerInterface* PlayerControllerInterface = nullptr;
    class IControllerInterface* ControllerInterface = nullptr;
};