Controller.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "UObject/CoreNet.h"
#include "GameFramework/Actor.h"
#include "AI/Navigation/NavAgentInterface.h"
#include "Controller.generated.h"
 
class ACharacter;
class APawn;
class APlayerState;
class FDebugDisplayInfo;
class UDamageType;
 
UDELEGATE(BlueprintAuthorityOnly)
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams( FInstigatedAnyDamageSignature, float, Damage, const UDamageType*, DamageType, AActor*, DamagedActor, AActor*, DamageCauser );
DECLARE_MULTICAST_DELEGATE_OneParam(FPawnChangedSignature, APawn* /*NewPawn*/);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnPossessedPawnChanged, APawn*, OldPawn, APawn*, NewPawn);
 
UCLASS(abstract, notplaceable, NotBlueprintable, HideCategories=(Collision,Rendering,Transformation), MinimalAPI) 
class AController : public AActor, public INavAgentInterface
{
    GENERATED_BODY()
 
public:
    ENGINE_API AController(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    UPROPERTY(replicatedUsing = OnRep_PlayerState, BlueprintReadOnly, Category=Controller)
    TObjectPtr<APlayerState> PlayerState;
    ENGINE_API void SetPlayerState(APlayerState* InPlayerState);
 
    TWeakObjectPtr<class AActor> StartSpot;
 
    UPROPERTY(BlueprintAssignable)
    FInstigatedAnyDamageSignature OnInstigatedAnyDamage;
 
    UPROPERTY(BlueprintAssignable, Category=Pawn)
    FOnPossessedPawnChanged OnPossessedPawnChanged;
 
    UPROPERTY()
    FName StateName;
 
private:
    UPROPERTY(replicatedUsing=OnRep_Pawn)
    TObjectPtr<APawn> Pawn;
    void SetPawn_Direct(APawn* InPawn);
 
    TWeakObjectPtr< APawn > OldPawn;
 
    UPROPERTY()
    TObjectPtr<ACharacter> Character;
 
    UPROPERTY()
    TObjectPtr<USceneComponent> TransformComponent;
 
protected:
    FPawnChangedSignature OnNewPawn;
 
    UPROPERTY()
    FRotator ControlRotation;
 
    ENGINE_API bool IsValidControlRotation(FRotator CheckRotation) const;
 
    UPROPERTY(EditDefaultsOnly, Category="Controller|Transform")
    uint8 bAttachToPawn:1;
 
    uint8 bIsPlayerController:1;
 
    uint8 bCanPossessWithoutAuthority:1;
 
    uint8 IgnoreMoveInput;
 
    uint8 IgnoreLookInput;
 
    ENGINE_API virtual void AttachToPawn(APawn* InPawn);
 
    ENGINE_API virtual void DetachFromPawn();
 
    ENGINE_API virtual void AddPawnTickDependency(APawn* NewPawn);
 
    ENGINE_API virtual void RemovePawnTickDependency(APawn* InOldPawn);
 
    class USceneComponent* GetTransformComponent() const { return TransformComponent; }
 
public:
 
    ENGINE_API virtual void ChangeState(FName NewState);
 
    ENGINE_API bool IsInState(FName InStateName) const;
    
    ENGINE_API FName GetStateName() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API virtual FRotator GetControlRotation() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn, meta=(Tooltip="Set the control rotation."))
    ENGINE_API virtual void SetControlRotation(const FRotator& NewRotation);
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API virtual void SetInitialLocationAndRotation(const FVector& NewLocation, const FRotator& NewRotation);
 
 
    UFUNCTION(BlueprintCallable, Category=Controller)
    ENGINE_API virtual bool LineOfSightTo(const class AActor* Other, FVector ViewPoint = FVector(ForceInit), bool bAlternateChecks = false) const;
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_Pawn();
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_PlayerState();
    
    template < class T >
    T* GetPlayerState() const
    {
        return Cast<T>(PlayerState);
    }
 
    UFUNCTION(Reliable, Client, WithValidation)
    ENGINE_API void ClientSetLocation(FVector NewLocation, FRotator NewRotation);
 
    UFUNCTION(Reliable, Client, WithValidation)
    ENGINE_API void ClientSetRotation(FRotator NewRotation, bool bResetCamera = false);
 
    UFUNCTION(BlueprintCallable, Category=Pawn, meta=(DisplayName="Get Controlled Pawn", ScriptName="GetControlledPawn"))
    ENGINE_API APawn* K2_GetPawn() const;
 
    FPawnChangedSignature& GetOnNewPawnNotifier() { return OnNewPawn; }
 
public:
 
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
 
    //~ Begin AActor Interface
    ENGINE_API virtual void TickActor( float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction ) override;
    ENGINE_API virtual void K2_DestroyActor() override;
    ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
    ENGINE_API virtual void GetActorEyesViewPoint( FVector& out_Location, FRotator& out_Rotation ) const override;
    ENGINE_API virtual FString GetHumanReadableName() const override;
 
    ENGINE_API virtual void PostInitializeComponents() override;
 
    ENGINE_API virtual void Reset() override;
    ENGINE_API virtual void Destroyed() override;
    //~ End AActor Interface
 
    inline TObjectPtr<APawn> GetPawn() const { return Pawn; }
 
    template<class T>
    T* GetPawn() const
    {
        return Cast<T>(Pawn);
    }
 
    inline ACharacter* GetCharacter() const { return Character; }
 
    ENGINE_API virtual void SetPawn(APawn* InPawn);
 
    ENGINE_API void SetPawnFromRep(APawn* InPawn);
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API virtual AActor* GetViewTarget() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API virtual FRotator GetDesiredRotation() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    bool IsPlayerController() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    bool IsLocalPlayerController() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API virtual bool IsLocalController() const;
 
    ENGINE_API virtual void CleanupPlayerState();
 
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category=Pawn, meta=(Keywords="set controller"))
    ENGINE_API virtual void Possess(APawn* InPawn) final; // DEPRECATED(4.22, "Possess is marked virtual final as you should now be overriding OnPossess instead")
 
    UFUNCTION(BlueprintCallable, Category=Pawn, meta=(Keywords="set controller"))
    ENGINE_API virtual void UnPossess() final; // DEPRECATED(4.22, "Possess is marked virtual final as you should now be overriding OnUnPossess instead")
 
protected:
    UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "On Possess"))
    ENGINE_API void ReceivePossess(APawn* PossessedPawn);
 
    ENGINE_API virtual void OnPossess(APawn* InPawn);
 
    UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "On UnPossess"))
    ENGINE_API void ReceiveUnPossess(APawn* UnpossessedPawn);
 
    ENGINE_API virtual void OnUnPossess();
 
public:
    ENGINE_API virtual void PawnPendingDestroy(APawn* inPawn);
 
    ENGINE_API virtual void InstigatedAnyDamage(float Damage, const class UDamageType* DamageType, class AActor* DamagedActor, class AActor* DamageCauser);
 
    ENGINE_API virtual void InitPlayerState();
 
    ENGINE_API virtual void GameHasEnded(class AActor* EndGameFocus = nullptr, bool bIsWinner = false);
 
    UFUNCTION(BlueprintCallable, Category = Pawn)
    ENGINE_API virtual void GetPlayerViewPoint( FVector& Location, FRotator& Rotation ) const;
 
    ENGINE_API virtual void FailedToSpawnPawn();
 
    //~ Begin INavAgentInterface Interface
    ENGINE_API virtual const struct FNavAgentProperties& GetNavAgentPropertiesRef() const override;
    ENGINE_API virtual FVector GetNavAgentLocation() const override;
    ENGINE_API virtual void GetMoveGoalReachTest(const AActor* MovingActor, const FVector& MoveOffset, FVector& GoalOffset, float& GoalRadius, float& GoalHalfHeight) const override;
    ENGINE_API virtual bool ShouldPostponePathUpdates() const override;
    ENGINE_API virtual bool IsFollowingAPath() const override;
    ENGINE_API virtual IPathFollowingAgentInterface* GetPathFollowingAgent() const override;
    //~ End INavAgentInterface Interface
    
    UFUNCTION(BlueprintCallable, Category="AI|Navigation")
    ENGINE_API virtual void StopMovement();
 
    UFUNCTION(BlueprintCallable, Category=Input)
    ENGINE_API virtual void SetIgnoreMoveInput(bool bNewMoveInput);
 
    UFUNCTION(BlueprintCallable, Category=Input, meta=(Keywords = "ClearIgnoreMoveInput"))
    ENGINE_API virtual void ResetIgnoreMoveInput();
 
    UFUNCTION(BlueprintCallable, Category=Input)
    ENGINE_API virtual bool IsMoveInputIgnored() const;
 
    UFUNCTION(BlueprintCallable, Category=Input)
    ENGINE_API virtual void SetIgnoreLookInput(bool bNewLookInput);
 
    UFUNCTION(BlueprintCallable, Category=Input, meta=(Keywords="ClearIgnoreLookInput"))
    ENGINE_API virtual void ResetIgnoreLookInput();
 
    UFUNCTION(BlueprintCallable, Category=Input)
    ENGINE_API virtual bool IsLookInputIgnored() const;
 
    UFUNCTION(BlueprintCallable, Category=Input)
    ENGINE_API virtual void ResetIgnoreInputFlags();
 
    ENGINE_API virtual void CurrentLevelUnloaded();
 
    ENGINE_API virtual bool ShouldParticipateInSeamlessTravel() const;
 
protected:
    ENGINE_API virtual void BeginInactiveState();
 
    ENGINE_API virtual void EndInactiveState();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly)
    ENGINE_API void ReceiveInstigatedAnyDamage(float Damage, const class UDamageType* DamageType, class AActor* DamagedActor, class AActor* DamageCauser);
 
private:
    // Hidden functions that don't make sense to use on this class.
    HIDE_ACTOR_TRANSFORM_FUNCTIONS();
 
};
 
 
// INLINES
 
inline bool AController::IsPlayerController() const
{
    return bIsPlayerController;
}
 
inline bool AController::IsLocalPlayerController() const
{
    return IsPlayerController() && IsLocalController();
}