Pawn.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "Templates/SubclassOf.h"
#include "UObject/CoreNet.h"
#include "Engine/EngineTypes.h"
#include "GameFramework/Actor.h"
#include "AI/Navigation/NavAgentInterface.h"
 
#include "Pawn.generated.h"
 
class AController;
class APhysicsVolume;
class APlayerController;
class APlayerState;
class FDebugDisplayInfo;
class UCanvas;
class UDamageType;
class UInputComponent;
class UPawnMovementComponent;
class UPawnNoiseEmitterComponent;
class UPlayer;
class UPrimitiveComponent;
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogDamage, Warning, All);
 
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam(FPawnRestartedSignature, APawn, ReceiveRestartedDelegate, APawn*, Pawn);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_ThreeParams(FPawnControllerChangedSignature, APawn, ReceiveControllerChangedDelegate, APawn*, Pawn, AController*, OldController, AController*, NewController);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPawnBeginPlay, APawn*);
 
UCLASS(config=Game, BlueprintType, Blueprintable, hideCategories=(Navigation), meta=(ShortTooltip="A Pawn is an actor that can be 'possessed' and receive input from a controller."), MinimalAPI)
class APawn : public AActor, public INavAgentInterface
{
    GENERATED_BODY()
 
public:
    ENGINE_API APawn(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
    ENGINE_API virtual void PreReplication( IRepChangedPropertyTracker & ChangedPropertyTracker ) override;
 
    UFUNCTION(BlueprintCallable, meta=(Tooltip="Return our PawnMovementComponent, if we have one."), Category=Pawn)
    ENGINE_API virtual UPawnMovementComponent* GetMovementComponent() const;
 
    virtual UPrimitiveComponent* GetMovementBase() const { return nullptr; }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Pawn)
    uint32 bUseControllerRotationPitch:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Pawn)
    uint32 bUseControllerRotationYaw:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Pawn)
    uint32 bUseControllerRotationRoll:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Pawn)
    uint32 bCanAffectNavigationGeneration : 1;
 
private:
    uint32 bInputEnabled:1;
 
    uint32 bProcessingOutsideWorldBounds : 1;
 
protected:
    UPROPERTY(Transient)
    uint32 bIsLocalViewTarget : 1;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    float BaseEyeHeight;
 
    UPROPERTY(EditAnywhere, Category=Pawn)
    TEnumAsByte<EAutoReceiveInput::Type> AutoPossessPlayer;
 
    UPROPERTY(EditAnywhere, Category=Pawn)
    EAutoPossessAI AutoPossessAI;
 
protected:
    UPROPERTY(replicated)
    uint16 RemoteViewPitch16;
 
public:
 
    UE_DEPRECATED(5.6, "This property is deprecated, use GetRemoteViewPitch()/RemoteViewPitch16 instead.")
    UPROPERTY(replicated)
    uint8 RemoteViewPitch;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(DisplayName="AI Controller Class"), Category=Pawn)
    TSubclassOf<AController> AIControllerClass;
 
    ENGINE_API virtual UPawnNoiseEmitterComponent* GetPawnNoiseEmitterComponent() const;
 
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category=AI)
    ENGINE_API void PawnMakeNoise(float Loudness, FVector NoiseLocation, bool bUseNoiseMakerLocation = true, AActor* NoiseMaker = nullptr);
    
    UFUNCTION(BlueprintCallable, Category = "Pawn")
    ENGINE_API APlayerController* GetLocalViewingPlayerController() const;
 
    // Is this pawn the ViewTarget of a local PlayerController?  Helpful for determining whether the pawn is
    // visible/critical for any VFX.  NOTE: Technically there may be some cases where locally controlled pawns return
    // false for this, such as if you are using a remote camera view of some sort.  But generally it will be true for
    // locally controlled pawns, and it will always be true for pawns that are being spectated in-game or in Replays.
    UFUNCTION(BlueprintCallable, Category = "Pawn")
    ENGINE_API bool IsLocallyViewed() const;
 
    ENGINE_API bool IsLocalPlayerControllerViewingAPawn() const;
 
    static ENGINE_API FOnPawnBeginPlay OnPawnBeginPlay;
 
private:
    UPROPERTY(replicatedUsing=OnRep_PlayerState, BlueprintReadOnly, Category=Pawn, meta=(AllowPrivateAccess="true"))
    TObjectPtr<APlayerState> PlayerState;
 
public:
 
    ENGINE_API void SetPlayerState(APlayerState* NewPlayerState);
 
    APlayerState* GetPlayerState() const { return PlayerState; }
 
    TObjectPtr<APlayerState> GetPlayerStateObjPtr() const { return PlayerState; }
 
    template<class T>
    T* GetPlayerState() const { return Cast<T>(PlayerState); }
 
    template<class T>
    T* GetPlayerStateChecked() const { return CastChecked<T>(PlayerState); }
 
protected:
    virtual void OnPlayerStateChanged(APlayerState* NewPlayerState, APlayerState* OldPlayerState) { }
 
public:
 
    UPROPERTY(BlueprintReadOnly, transient, Category="Pawn")
    TObjectPtr<AController> LastHitBy;
 
    UPROPERTY(replicatedUsing=OnRep_Controller)
    TObjectPtr<AController> Controller;
 
    UPROPERTY(transient)
    TObjectPtr<AController> PreviousController;
 
    float AllowedYawError;
 
    ENGINE_API virtual void TurnOff();
 
    ENGINE_API virtual void PawnStartFire(uint8 FireModeNum = 0);
 
    inline uint16 GetRemoteViewPitch() const { return RemoteViewPitch16; }
 
    ENGINE_API void SetRemoteViewPitch(double NewRemoteViewPitch);
 
    ENGINE_API virtual APhysicsVolume* GetPhysicsVolume() const override;
 
    UFUNCTION(BlueprintPure, Category=Pawn)
    static ENGINE_API AActor* GetMovementBaseActor(const APawn* Pawn);
 
    ENGINE_API virtual bool ReachedDesiredRotation();
 
    ENGINE_API virtual float GetDefaultHalfHeight() const;
 
    UE_DEPRECATED(4.24, "IsControlled is deprecated. To check if this pawn is controlled by anything, then call IsPawnControlled. To check if this pawn is controlled only by the player then call IsPlayerControlled")
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API bool IsControlled() const;
 
    UFUNCTION(BlueprintCallable, Category = Pawn)
    ENGINE_API virtual bool IsPawnControlled() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    AController* GetController() const;
    
    template < class T >
    T* GetController() const
    {
        return Cast<T>(GetController());
    }
 
    ENGINE_API void SetController(AController* InController);
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API FRotator GetControlRotation() const;
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_Controller();
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_PlayerState();
 
    //~ Begin AActor Interface.
    ENGINE_API virtual FVector GetVelocity() const override;
    ENGINE_API virtual void Reset() override;
    ENGINE_API virtual FString GetHumanReadableName() const override;
    ENGINE_API virtual bool ShouldTickIfViewportsOnly() const override;
    ENGINE_API virtual bool IsNetRelevantFor(const AActor* RealViewer, const AActor* ViewTarget, const FVector& SrcLocation) const override;
    ENGINE_API virtual void PostNetReceiveLocationAndRotation() override;
    ENGINE_API virtual void PostNetReceiveVelocity(const FVector& NewVelocity) override;
    ENGINE_API virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
    ENGINE_API virtual void GetActorEyesViewPoint( FVector& Location, FRotator& Rotation ) const override;
    ENGINE_API virtual void OutsideWorldBounds() override;
    ENGINE_API virtual void BeginPlay() override;
    ENGINE_API virtual void Destroyed() override;
    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    ENGINE_API virtual void PreInitializeComponents() override;
    ENGINE_API virtual void PostInitializeComponents() override;
    ENGINE_API virtual const AActor* GetNetOwner() const override;
    ENGINE_API virtual UPlayer* GetNetOwningPlayer() override;
    ENGINE_API virtual UPlayer* GetNetOwningPlayerAnyRole() override;
    ENGINE_API virtual class UNetConnection* GetNetConnection() const override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PostRegisterAllComponents() override;
    ENGINE_API virtual float TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) override;
    ENGINE_API virtual void BecomeViewTarget(APlayerController* PC) override;
    ENGINE_API virtual void EndViewTarget(APlayerController* PC) override;
    ENGINE_API virtual void EnableInput(APlayerController* PlayerController) override;
    ENGINE_API virtual void DisableInput(APlayerController* PlayerController) override;
    ENGINE_API virtual void TeleportSucceeded(bool bIsATest) override;
    ENGINE_API virtual bool IsBasedOnActor(const AActor* Other) const override;
 
    ENGINE_API virtual bool CanBeBaseForCharacter(APawn* APawn) const override;
    //~ End AActor Interface
 
    UFUNCTION(BlueprintCallable, Category="AI|Navigation", meta=(AdvancedDisplay="bForceUpdate"))
    ENGINE_API void SetCanAffectNavigationGeneration(bool bNewValue, bool bForceUpdate = false);
 
    virtual void UpdateNavigationRelevance() {}
 
    //~ Begin INavAgentInterface Interface
    ENGINE_API virtual const FNavAgentProperties& GetNavAgentPropertiesRef() const override;
    UFUNCTION(BlueprintCallable, Category=Pawn)
    virtual FVector GetNavAgentLocation() const override { return GetActorLocation() - FVector(0.f, 0.f, BaseEyeHeight); }
    ENGINE_API virtual void GetMoveGoalReachTest(const AActor* MovingActor, const FVector& MoveOffset, FVector& GoalOffset, float& GoalRadius, float& GoalHalfHeight) const override;
    //~ End INavAgentInterface Interface
 
    ENGINE_API void UpdateNavAgent();
 
    ENGINE_API virtual bool ShouldTakeDamage(float Damage, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) const;
 
#if WITH_EDITOR
    ENGINE_API virtual void EditorApplyRotation(const FRotator& DeltaRotation, bool bAltDown, bool bShiftDown, bool bCtrlDown) override;
    ENGINE_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
    ENGINE_API virtual FVector GetGravityDirection() const;
 
    ENGINE_API virtual FQuat GetGravityTransform() const;
 
    ENGINE_API virtual void SetPlayerDefaults();
 
    ENGINE_API virtual void RecalculateBaseEyeHeight();
 
    bool InputEnabled() const { return bInputEnabled; }
 
 
    ENGINE_API virtual void PossessedBy(AController* NewController);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly, meta=(DisplayName= "Possessed"))
    ENGINE_API void ReceivePossessed(AController* NewController);
 
    ENGINE_API virtual void UnPossessed();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly, meta=(DisplayName= "Unpossessed"))
    ENGINE_API void ReceiveUnpossessed(AController* OldController);
 
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void ReceiveControllerChanged(AController* OldController, AController* NewController);
 
    UPROPERTY(BlueprintAssignable, Category = Pawn)
    FPawnControllerChangedSignature ReceiveControllerChangedDelegate;
 
    ENGINE_API virtual void NotifyControllerChanged();
 
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void ReceiveRestarted();
 
    UPROPERTY(BlueprintAssignable, Category = Pawn)
    FPawnRestartedSignature ReceiveRestartedDelegate;
 
    ENGINE_API virtual void NotifyRestarted();
 
    ENGINE_API virtual void Restart();
 
    ENGINE_API virtual void PawnClientRestart();
 
    ENGINE_API void DispatchRestart(bool bCallClientRestart);
 
 
    UFUNCTION(BlueprintPure, Category=Pawn)
    ENGINE_API virtual bool IsLocallyControlled() const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = Pawn)
    ENGINE_API FPlatformUserId GetPlatformUserId() const;
  
    UFUNCTION(BlueprintPure, Category=Pawn)
    ENGINE_API virtual bool IsPlayerControlled() const;
 
    UFUNCTION(BlueprintPure, Category = Pawn)
    ENGINE_API virtual bool IsBotControlled() const;
 
    ENGINE_API virtual FRotator GetViewRotation() const;
 
    ENGINE_API virtual FVector GetPawnViewLocation() const;
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API virtual FRotator GetBaseAimRotation() const;
 
    ENGINE_API virtual bool InFreeCam() const;
 
    ENGINE_API virtual void FaceRotation(FRotator NewControlRotation, float DeltaTime = 0.f);
 
    UFUNCTION(BlueprintCallable, Category=Pawn, meta=(Keywords = "Delete"))
    ENGINE_API virtual void DetachFromControllerPendingDestroy();
 
    UFUNCTION(BlueprintCallable, Category=Pawn)
    ENGINE_API virtual void SpawnDefaultController();
 
protected:
    ENGINE_API virtual AController* GetDamageInstigator(AController* InstigatedBy, const UDamageType& DamageType) const;
 
    ENGINE_API virtual UInputComponent* CreatePlayerInputComponent();
 
    ENGINE_API virtual void DestroyPlayerInputComponent();
 
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) { /* No bindings by default.*/ }
 
public:
    UFUNCTION(BlueprintCallable, Category="Pawn|Input", meta=(Keywords="AddInput"))
    ENGINE_API virtual void AddMovementInput(FVector WorldDirection, float ScaleValue = 1.0f, bool bForce = false);
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Input", meta=(Keywords="GetMovementInput GetInput"))
    ENGINE_API FVector GetPendingMovementInputVector() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Input", meta=(Keywords="GetMovementInput GetInput"))
    ENGINE_API FVector GetLastMovementInputVector() const;
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Input", meta=(Keywords="ConsumeInput"))
    ENGINE_API virtual FVector ConsumeMovementInputVector();
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Input", meta=(Keywords="up down addpitch"))
    ENGINE_API virtual void AddControllerPitchInput(float Val);
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Input", meta=(Keywords="left right turn addyaw"))
    ENGINE_API virtual void AddControllerYawInput(float Val);
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Input", meta=(Keywords="addroll"))
    ENGINE_API virtual void AddControllerRollInput(float Val);
 
    UFUNCTION(BlueprintCallable, Category="Pawn|Input")
    ENGINE_API virtual bool IsMoveInputIgnored() const;
 
    UFUNCTION(BlueprintCallable, Category = "Pawn|Input")
    ENGINE_API TSubclassOf<UInputComponent> GetOverrideInputComponentClass() const;
 
protected:
    UPROPERTY(Transient)
    FVector ControlInputVector;
 
    UPROPERTY(Transient)
    FVector LastControlInputVector;
 
    UPROPERTY(EditDefaultsOnly, Category = "Pawn|Input")
    TSubclassOf<UInputComponent> OverrideInputComponentClass;
 
public:
    ENGINE_API void Internal_AddMovementInput(FVector WorldAccel, bool bForce = false);
 
    inline FVector Internal_GetPendingMovementInputVector() const { return ControlInputVector; }
 
    inline FVector Internal_GetLastMovementInputVector() const { return LastControlInputVector; }
 
    ENGINE_API FVector Internal_ConsumeMovementInputVector();
 
    ENGINE_API void MoveIgnoreActorAdd(AActor* ActorToIgnore);
 
    ENGINE_API void MoveIgnoreActorRemove(AActor* ActorToIgnore);
 
};
 
 
// Pawn inlines
 
inline AController* APawn::GetController() const
{
    return Controller;
}