CharacterComponent.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 "AIController.h"
#include "CommonActorComponent.h"
#include "Components/ActorComponent.h"
#include "Data/BaseData.h"
#include "CharacterComponent.generated.h"
 
 
class IControllerInterface;
class ICharacterBaseInterface;
struct FGameplayTag;
struct FRadialMenuData;
class IPlayerControllerInterface;
struct FRadialWheelMenuData;
class IHUDInterface;
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnRequestFriendlyActors, TArray<AActor*>&, Actors);
DECLARE_LOG_CATEGORY_EXTERN(LogCharacterComponent, Display, All);
 
//@TODO Check to make sure IsLocallyControlled isn't being incorrectly set on Server/Client
USTRUCT(BlueprintType)
struct FCharacterComponentRequirements
{
    GENERATED_BODY()
 
    //@TODO Add in Controller etc. all needed for SetupComponent, so they can all input one Var
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bController = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bPlayerController = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bAIController = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bSkeletalMesh = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bAnimationInstance = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bPawn = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bHUDReference = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bHasWidgets = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character")
    bool bShouldDestroyOnDeath = false;
 
    bool GetAnyRequirementsSet() const
    {
        if(bController || bPlayerController || bAIController || bSkeletalMesh || bAnimationInstance
            || bPawn || bHUDReference)
        {
            return true;
        }
        return false;
    }
 
    bool GetHasFoundRequirements(const FCharacterComponentRequirements& Requirements) const
    {
        if(Requirements.bController && bController == false)
        {
            if(Requirements.bPlayerController && bPlayerController == false)
            {
                return false;
            }
            if(Requirements.bAIController && bAIController == false)
            {
                return false;
            }
            return false;
        }
        if(Requirements.bPawn && bPawn == false)
        {
            return false;
        }
        if(Requirements.bAnimationInstance && bAnimationInstance == false)
        {
            return false;
        }
        if(Requirements.bSkeletalMesh && bSkeletalMesh == false)
        {
            return false;
        }
        if(Requirements.bHUDReference && bHUDReference == false)
        {
            return false;
        }
        return true;
    }
};
 
UCLASS(Blueprintable, BlueprintType, ClassGroup=(BucciGames), meta=(BlueprintSpawnableComponent), Abstract)
class BASEHELPERS_API UCharacterComponent : public UCommonActorComponent
{
    GENERATED_BODY()
 
public: 
    UCharacterComponent();
 
    virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
 
 
    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>(GetPawnChecked<APawn>()->GetController());
    }
    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>(GetPawnChecked<APawn>()->GetController());
    }
    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>(GetOwner());
    }
    template <class T>
    T* GetPawnChecked() const
    {
        static_assert(TPointerIsConvertibleFromTo<T, APawn>::Value, "'T' template parameter to GetPawnChecked must be derived from APawn");
        return CastChecked<T>(GetOwner());
    }
    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;
    
    // /** Returns the point of view for either a player or controlled pawn */
    // 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 = GetController<APlayerController>();
        return PC ? Cast<T>(PC->Player) : nullptr;
    }
 
    
    UPROPERTY(BlueprintAssignable, Category="Character Component")
    FOnRequestFriendlyActors OnRequestFriendlyActors;
 
    // UFUNCTION(BlueprintCallable, Category="Character Component")
    // virtual void SetupComponentAuto();
 
    UFUNCTION(BlueprintCallable, Category="Character Component")
    virtual void SetupComponentWidgets();
 
    //- Override for using as Begin play    //
    virtual void ComponentSetupComplete() override;
    //- Use instead of BeginPlay() in children  //
    //@ TODO use delegate instead 
    UFUNCTION(BlueprintImplementableEvent, Category="Character Component")
    void OnComponentSetupComplete();
    
    void SetIsCrouched(const bool bCrouching);
    void SetIsDead(const bool bDead);
    void SetIsKnockedOut(const bool bKnocked, const UDamageType* DamageType);
    //@ TODO Change to set when component setup
    // UFUNCTION(BlueprintCallable, Category="Character Component")
    // void SetIsLocallyControlled(const bool bIsLocallyControlled){if(bIsLocallyControlled){bLocallyControlled = bIsLocallyControlled;};};
 
 
    //- Returns all Perceived Friendly Actors   //
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    TArray<AActor*> GetFriendlyActors() const;
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    float GetLastAnimationDuration() const {return LastAnimationDuration;}
 
    
    //- Player Camera   //
    virtual FVector GetCameraTraceLocation() const;
    /* The Camera Trace Location with the Distance to the player Added */
    virtual FVector GetPlayerTraceLocation() const;
    virtual FRotator GetCameraTraceRotation() const;
    virtual FTransform GetCameraTraceTransform() const;
 
 
    //@TODO Remove blueprint callable from most of these fucntions, Don't need to call from a bp, as it would call from 10 components
    
    virtual void OpenRadialMenu(const FRadialMenuData& Data);
    virtual int32 CloseRadialMenu();
    bool GetIsRadialMenuOpen() const;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Traits")
    bool bUseCharacterTraits = true;
 
protected:
    virtual void BeginPlay() override;
 
    virtual void AutoDetect() override;
    virtual void Server_AutoDetect() override;
 
    
    virtual void ComponentActivated(UActorComponent* Component, const bool bReset) override;
    virtual void ComponentDeactivated(UActorComponent* Component) override;
    
    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;
 
    
    
    //-         Getters         //
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    USceneComponent* GetThrowPoint() const;
 
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    AController* GetOwnerController() const;
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    APlayerController* GetOwnerPlayerController() const;
    UFUNCTION(BlueprintPure,BlueprintCallable, Category = "Character")
    USkeletalMeshComponent* GetOwnerMesh() const;
    // UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    // UAnimInstance* GetOwnerAnimInstance() const;
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    AAIController* GetOwnerAIController() const;
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    APawn* GetOwnerPawn() const;
    // UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    // AActor* GetOwnerHUDReference() const{return OwnerHUDReference;};
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    FString GetOwnerName() const {return OwnerObjectName;};
    // UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    // FString GetOwnerDisplayName() const {return OwnerDisplayName;};
 
    //-         Getters         //
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    bool GetIsDead() const {return bIsDead;};
    UFUNCTION(BlueprintPure, Category = "Character")
    bool GetIsOwnerKnockedOut() const {return bIsKnockedOut;};
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    bool GetIsNPC() const {return bIsNPC;};
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Character")
    bool GetIsCrouched() const {return bIsCrouching;};
 
    //- Return if Succeeded //
    UFUNCTION(BlueprintCallable, Category = "Character")
    virtual bool GetOwnerCharacterSkills(FCharacterBaseSkills& Traits);
 
 
 
    
    UFUNCTION(BlueprintCallable, Category="Character")
    virtual void OwnerKnockedOut(const UDamageType* DamageType);
    UFUNCTION(BlueprintCallable, Category="Character")
    virtual void OwnerWakeUp();
    UFUNCTION(BlueprintCallable, Category="Character")
    virtual void OwnerDeath();
    UFUNCTION(BlueprintImplementableEvent, Category="Character")
    void OnDeathEvent();
 
    void SetInputModeGameAndUI(const bool bGameAndUI, const bool bShowMouse, class UWidget* InWidgetToFocus = nullptr) const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character|Setup")
    FCharacterComponentRequirements ComponentRequirements;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character|Setup")
    FCharacterComponentRequirements ComponentResults;
 
    //@TODO do the same with SetupWidgets(), have bHasWidgets to setup?
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character|Setup")
    bool bHasWidgets = false;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character|Setup")
    bool bUsesHUDWidgets = false;
    bool bBindAnimationEvent = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character|Debugging")
    bool bUsingEnhancedInput = true;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character|Debugging")
    float MultiplayerStartDelay = 0.5f;
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Character|Debugging")
    // bool bShowTraceLocations = true;
 
    
    
    //- Play Animation //
    UFUNCTION()
    float PlayMontageAnimation(UAnimMontage* MontageToPlay, const float InPlayRate = 1.0f, const EMontagePlayReturnType ReturnValueType = EMontagePlayReturnType::Duration, const float InTimeToStartMontageAt = 0.0f, const bool bStopAllMontages = true);
    UFUNCTION()
    void StopMontageAnimation(const float InBlendOutTime, const UAnimMontage* Montage);
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Animation")
    float LastAnimationDuration = 0.0f;
 
    UFUNCTION(Category="Character")
    virtual void OnMontageNotifyBegin(FName NotifyName, const FBranchingPointNotifyPayload& BranchingPointPayload);
    UFUNCTION(Category="Character")
    virtual void OnMontageNotifyEnd(FName NotifyName, const FBranchingPointNotifyPayload& BranchingPointPayload);
 
    // IControllerInterface* GetControllerInterface();
    IHUDInterface* GetHUDInterface();
    // IPlayerControllerInterface* GetPlayerControllerInterface();
    ICharacterBaseInterface* GetCharacterBaseInterface();
    IControllerInterface* GetControllerInterface() const;
    // IHUDInterface* GetHUDInterface() const;
    IPlayerControllerInterface* GetPlayerControllerInterface() const;
    ICharacterBaseInterface* GetCharacterBaseInterface() const;
 
private:
 
    UFUNCTION(Server, Reliable, Category="Character Component")
    void Server_SetOwnerMesh(USkeletalMeshComponent* SkeletalMesh);
 
    // bool DetectOwnerPawn();
    bool DetectOwnerMesh();
    bool DetectOwnerAnimInst();
    // bool DetectOwnerController();
    bool DetectOwnerHUD();
    bool BindAnimation();
 
    void SetOwnerMesh(USkeletalMeshComponent* SkeletalMesh);
    void SetAnimInstance(UAnimInstance* AnimationInstance);
    // void SetController(AController* Controller);
    void SetIsNPC(const bool bNPC){bIsNPC = bNPC;};
    void SetHUDReference(AActor* HUDReference);
 
    void TrySetupAgain();
    
    // bool CheckComponentIsSetup(const FString& ComponentName) const;
    bool bIsNPC = false;
    bool bIsDead = false;
    bool bIsKnockedOut = false;
    bool bIsCrouching = false;
    // UPROPERTY()
    // TObjectPtr<AController> OwnerController = nullptr;
    // UPROPERTY()
    // TObjectPtr<APlayerController> OwnerPlayerController = nullptr;
    // UPROPERTY()
    // TObjectPtr<AAIController> OwnerAIController = nullptr;
    UPROPERTY(Replicated)
    TObjectPtr<USkeletalMeshComponent> OwnerMesh = nullptr;
    UPROPERTY()
    TObjectPtr<UAnimInstance> MainAnimInstance = nullptr;
    // UPROPERTY()
    // TObjectPtr<APawn> OwnerPawn = nullptr;
    UPROPERTY()
    TObjectPtr<AActor> OwnerHUDReference = nullptr;
 
 
    //@ New Way 
    IHUDInterface* HUDInterface;
    IPlayerControllerInterface* PlayerControllerInterface;
    ICharacterBaseInterface* CharacterBaseInterface;
    // UPROPERTY(Replicated)
    IControllerInterface* ControllerInterface;
 
    // TObjectPtr<AActor> ControllerActor = nullptr;
    
    UPROPERTY(VisibleAnywhere, Category="Character")
    FString OwnerObjectName = "Name";
    // UPROPERTY(VisibleAnywhere, Category="Character")
    // FString OwnerDisplayName = "DisplayName";
 
    UPROPERTY(EditAnywhere, Category="Character|Setup")
    int32 SetupAttempts = 5;
    UPROPERTY(EditAnywhere, Category="Character|Setup")
    float SetupAttemptDelay = 1.0f;
 
    int32 CurrentSetupAttempt = 0;
    FTimerHandle SetupCompleteDelayTimerHandle;
    FTimerHandle UpdateCameraTimerHandle;
    FTimerHandle SetupComponentDelayTimerHandle;
 
};