leap/documentation/_project_x_vehicle_8h_source.html

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.


#pragma once


#include "ProjectX.h"

#include "GameFramework/Character.h"

#include "OwnedInterface.h"

#include "HealthInterface.h"

#include "LockOnTargetInterface.h"

#include "SpawnTargetInterface.h"

#include "TeamInterface.h"

#include "InteractableInterface.h"

#include "SpottableInterface.h"

#include "TrackableInterface.h"

#include "KillCamInterface.h"

#include "ObjectInfoInterface.h"

#include "ProjectXVehicle.generated.h"


class USkinnedMeshComponent;

class AProjectXCharacter;

class AKillCameraActor;

class UMeshComponent;

class UVehicleSeatComponent;

class UInteractableComponent;

class USpringArmComponent;

class UCameraComponent;

class UDamageHistoryComponent;

class UAfflictionComponent;

class UMapMarkerComponent;

class UMapIconWidget;

class URadarIconWidget;

class UCameraModifier;

enum class EAccelerationDirection : uint8;


DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FVehicleHierarchyUpdated, class AProjectXVehicle*, Vehicle);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FVehicleBoostChanged, float, CurrentBoost);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FDriverChangedSignature, class AProjectXVehicle*, Vehicle, class AProjectXCharacter*, OldDriver);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FVehicleLocomotionChangeSignature, bool, bToggle);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FPassengerChangedSignature, class AProjectXVehicle*, Vehicle, class UVehicleSeatComponent*, Seat, class AProjectXCharacter*, PreviousPassenger);

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FVehicleDiedEvent);

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FVehicleBoostSignature);


UENUM(BlueprintType)

enum class EAccelerationDirection : uint8

{

    Up = 0,

    Right = 1,

    Down = 2,

    Left = 3,

    Forward = 4,

    Back = 5

};


UCLASS()

class PROJECTX_API AProjectXVehicle : public ACharacter, public IOwnedInterface, public IHealthInterface, public ISpawnTargetInterface, public ILockOnTargetInterface, public ISpottableInterface, public ITrackableInterface, public ITeamInterface, public IInteractableInterface, public IKillCamInterface, public IObjectInfoInterface

{

    GENERATED_UCLASS_BODY()


public:

    //Returns this vehicle's seats (doesn't go through the hierarchy of vehicles)

    FORCEINLINE const TArray<TWeakObjectPtr<UVehicleSeatComponent>>& GetSeats() const { return Seats; }

    virtual TArray<UMeshComponent*> GetKillCamMeshes() const override;

    virtual FRotator GetViewRotation() const override;

    virtual FVector GetPawnViewLocation() const override;

    virtual APlayerState* GetOwnedPlayerState() const override;

    virtual float GetHealth() const override;

    virtual float GetMaxHealth() const override;

    virtual int32 GetTeam() const override;

    virtual bool IsDead() const override;

    virtual bool IsArmored() const override { return bArmored; }

    virtual const FText& GetObjectName() const { return VehicleName; };

    virtual const FString GetOwnerName() const;

    virtual AKillCameraActor* SpawnKillCamActor() override;

    virtual bool CanSpawnPlayer(const AProjectXPlayerState* Instigator) const override;

    virtual bool GetCanSpawnOnCombatTarget() const override;

    virtual bool GetSpawnLocation(AProjectXPlayerState* SpawnInstigator, FTransform& Transform) const override;

    virtual bool ShouldTakeDamage(float Damage, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) const override;

    virtual float InternalTakeRadialDamage(float Damage, FRadialDamageEvent const& RadialDamageEvent, class AController* EventInstigator, class AActor* DamageCauser) override;

    virtual bool GetRespawnInformation(struct FRespawnInformation& RespawnInfo);

    virtual float TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) override;

    virtual void SetHealth(const float NewHealth) override;

    virtual void SetMaxHealth(const float NewHealth) override;

    virtual void SetHealthRegenRate(float NewRate) override { HealthRegenRate = NewRate; }


    virtual void Die(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser, APlayerState* InstigatorPlayerState);

    virtual UAfflictionComponent* GetAfflictionComponent() const override;

    virtual void InitFromRespawnInformation(const struct FRespawnInformation& RespawnInfo);

    /* Returns the latest team value this vehicle had */

    virtual int32 GetCachedTeam() const;

    virtual void HandleCollisionDamagesVehicle(const FHitResult& Hit);

    virtual void HandleCollisionDamagesOthers(const FHitResult& Hit);

    virtual void HandleCollisionPushesCharacter(const FHitResult& Hit);

    virtual void OnOwnerLeave() override;

    virtual void TemporarilyIgnoreCharacterFromVehicleCollisions(TWeakObjectPtr<AProjectXCharacter> Character);


    virtual bool CanBeLockedOn(const AActor* LockInstigator) const override;

    virtual bool CanBeRepaired(const AActor* RepairInstigator) const override;

    virtual FText GetHighlightText(const UPrimitiveComponent* Component, const APlayerController* EventSender) const override;

    virtual bool CanBeInteractedWith(const UPrimitiveComponent* Component, const APlayerController* EventSender) const override;

    virtual FVector2D GetLockOnScreenPercentage() override { return LockOnScreenPercentage; }

    virtual float GetLockOnMaxDistance() { return MaxLockOnRange; }

    virtual FPawnLockOnSignature& GetLockOnTentativeStartDelegate() override { return OnLockOnTentativeStart; }

    virtual FPawnLockOnSignature& GetLockOnTentativeEndDelegate() override { return OnLockOnTentativeEnd; }

    virtual FPawnLockOnSignature& GetLockOnStartDelegate() override { return OnLockOnStart; }

    virtual FPawnLockOnSignature& GetLockOnEndDelegate() override { return OnLockOnEnd; }

    virtual FPawnImminentMissileWarningSignature& GetImminentMissileWarningStartDelegate() override { return OnImminentMissileWarningStart; }

    virtual FPawnImminentMissileWarningSignature& GetImminentMissileWarningEndDelegate() override { return OnImminentMissileWarningEnd; }

    virtual FPawnIncomingProjectileSignature& GetIncomingProjectileStartDelegate() override { return OnIncomingProjectileStart; }

    virtual FPawnIncomingProjectileSignature& GetIncomingProjectileEndDelegate() override { return OnIncomingProjectileEnd; }

    virtual ESpotReply CanBeSpotted(const AActor* SpotInstigator, ESpotType SpotType) const override;

    virtual FVector GetSpottingTraceOffset() const override { return GetActorLocation(); }

    virtual TSoftObjectPtr<UTexture2D> GetMapIcon() const override { return VehicleMapIcon; }

    virtual TSoftObjectPtr<UTexture2D> GetRadarIcon() const override { return VehicleRadarIcon; }

    virtual TSoftObjectPtr<UTexture2D> GetHudIcon() const override { return VehicleHudIcon; }

    virtual AActor* GetTrackableInterfaceActor() override { return this; }

    virtual TArray<AActor*> GetIgnoredActors();

    virtual FVector GetVelocity() const override;


    void UpdateVisibilityModifier(bool NewVisibility) { bVisible = NewVisibility; }

    void MoveIgnoreActorsRemoveVehicle(AActor* const ActorToIgnore);

    void MoveIgnoreActorsAddVehicle(AActor* const ActorToIgnore);


    UFUNCTION(BlueprintCallable, Category = Seat)

    FORCEINLINE FText GetVehicleName() const { return VehicleName; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE AProjectXCharacter* GetDriver() const { return Driver.Get(); }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE UVehicleSeatComponent* GetDriverSeat() const { return DriverSeat; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE UWeaponComponent* GetVehicleWeaponComponent() const { return VehicleWeaponComponent; }

    UFUNCTION(BlueprintPure, Category = "Vehicle|Spawn")

    FORCEINLINE bool GetPlayerCanSpawnInside() const { return bPlayerCanSpawnInside; }

    UFUNCTION(BlueprintPure, Category = "Vehicle|Spawn")

    FORCEINLINE bool GetPlayerCanSpawnNearby() const { return bPlayerCanSpawnNearby; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE bool IsOccupant(const AProjectXCharacter* Character) const { return GetSeatByOccupant(Character) != NULL; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual bool IsAccelerating(const EAccelerationDirection Direction) const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE bool IsMovingForward() const { return !GetVelocity().IsZero() && (GetVelocity().GetSafeNormal2D() | GetActorForwardVector()) > -0.1; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE bool IsMovingBackwards() const { return !GetVelocity().IsZero() && (GetVelocity().GetSafeNormal2D() | -GetActorForwardVector()) > -0.1; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE bool IsMoving() const { return !GetVelocity().IsZero(); }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual bool IsVisible() const { return bVisible; }

    UFUNCTION(BlueprintPure, Category = "Vehicle|Spawn")

    FORCEINLINE bool HasOwnerVehicle() const { return GetParentActor() ? GetParentActor()->IsA(AProjectXVehicle::StaticClass()) : false;}

    UFUNCTION(BlueprintPure, Category = "Vehicle|Spawn")

    FORCEINLINE AProjectXVehicle* GetOwnerVehicle() const { return Cast<AProjectXVehicle>(GetParentActor());}

    UFUNCTION(BlueprintCallable, Category = "Vehicle|UI")

    FORCEINLINE TSoftObjectPtr<UTexture2D> GetSeatsHUDIcon() const { return VehicleSeatsHUDIcon; }

    UFUNCTION(BlueprintCallable, Category = "Vehicle|Controls")

    FORCEINLINE float GetExitTime() const {return ExitTime;}

    UFUNCTION(BlueprintPure, Category = "Vehicle")

    bool CanExitVehicle() const;

    UFUNCTION(BlueprintPure, Category = "Vehicle")

    bool IsInteractionDisabled() const { return !bCanBeInteractedWith; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FVector GetVehicleRelativeAcceleration() const;

    //Is this vehicle used for display only? Like in a store or armory

    UFUNCTION(BlueprintPure, Category = "Vehicle")

    FORCEINLINE bool GetIsDisplayOnly() const { return bDisplayOnly; }


    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual FVector GetAimTargetPoint() const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual bool IsBoosting() const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual float GetBoostMultiplier() const { return BoostMultiplier; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual float GetCurrentBoost() const { return Boost; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual float GetBoostRegenRate() const { return BoostRegenRate; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual float GetMaxBoost() const { return MaxBoost; }

    /* Gets all seats from the entire vehicle hierarchy */

    TArray<TWeakObjectPtr<UVehicleSeatComponent>> GetSeatList() const;

    /* Gets the vehicle hierarchy this vehicle belongs to */

    TArray<AProjectXVehicle*> GetVehicleHierarchy() const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    TArray<UVehicleSeatComponent*> K2_GetSeats() const;

    /* Gets all occupants from the entire vehicle hierarchy */

    UFUNCTION(BlueprintPure, Category = Vehicle)

    TArray<AProjectXCharacter*> GetOccupants() const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FRotator GetWeaponInterpolatedRotation(float DeltaTime, const FRotator& CurrentRotation, const FRotator& TargetRotation, UVehicleSeatComponent* Seat);

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual bool CanEnterVehicle(AProjectXCharacter* Character) const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual bool HasAvailableSeat() const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual bool HasAnyOccupants() const;

    /* Does the provided vehicle belong to this vehicle's hierarchy? */

    UFUNCTION(BlueprintPure, Category = Vehicle)

    bool IsVehicleInHierarchy(const AProjectXVehicle* Vehicle) const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual UVehicleSeatComponent* GetSeatByOccupant(const AProjectXCharacter* Character) const;

    //Returns the best possible seat based on the distance from the character to the vehicle. If the character is NULL, returns the best seat based on its capabilities, like a driver seat, gunner seat...

    UFUNCTION(BlueprintPure, Category = Vehicle)

    virtual UVehicleSeatComponent* GetBestAvailableSeat(const AProjectXCharacter* Character) const;

    //Attempts to enter a vehicle with a specified pawn at a specified seat. Returns true if successful.

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual bool EnterVehicle(AProjectXCharacter* Character, UVehicleSeatComponent* PreferredSeat = NULL);

    //Attempts to leave a vehicle with a specified pawn. Returns true if successful. Use bForceLeave if the pawn needs to be forcibly ejected from the vehicle.

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual bool LeaveVehicle(AProjectXCharacter* Character, bool bForceLeave = false, bool bEject = false);

    //Attempts to make specified passenger pawn the driver of this vehicle. Returns true if successful.

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual bool AttemptToBecomeDriver(AProjectXCharacter* Character);

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual void AddComponentForCollisionComputations(UPrimitiveComponent* const PrimitiveComponent);

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual void UpdateCanInteractWith(bool bCanInteract){bCanBeInteractedWith = bCanInteract;}

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FRotator GetClampedAimRotationToVehicleForward(const FRotator& ForwardRotation, const FVector& ForwardLocation) const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    bool IsAPersonalVehicle() const;


    UFUNCTION(BlueprintPure, BlueprintNativeEvent, Category = Vehicle)

    bool GetProjectileTransform(FTransform& Transform, FName& SocketName, UVehicleSeatComponent* Seat, bool CosmeticOnly = false);

    UFUNCTION(BlueprintImplementableEvent, BlueprintCallable)

    void DriverChangedEvent(AProjectXCharacter* PreviousDriver, AProjectXCharacter* NewDriver);

    UFUNCTION(BlueprintImplementableEvent)

    void PlayWeaponFireEffects(UWeaponInstanceVehicle* Weapon);

    UFUNCTION(BlueprintImplementableEvent)

    void OnDeathEvent();

    UFUNCTION(BlueprintImplementableEvent)

    void OnMoveUp();

    UFUNCTION(BlueprintImplementableEvent)

    void K2_VehicleSetAsDisplay();

    UFUNCTION(BlueprintImplementableEvent, Category = Vehicle)

    FVector GetAimStartPoint() const;

    UFUNCTION(BlueprintImplementableEvent, Category = "Vehicle|KillCam")

    FVector GetKillCamWidgetPlacementPivot() const;

    UFUNCTION(BlueprintPure, Category = Vehicle)

    const FString& GetVehicleID() const { return VehicleID; }

    UFUNCTION(BlueprintPure,Category = Vehicle, meta = (DisplayName = "GetVehicleID", ScriptName = "GetVehicleID"))

    static FString GetVehicleIDStatic(TSubclassOf<AProjectXVehicle> VehicleClass) { { return (VehicleClass && VehicleClass->GetDefaultObject<AProjectXVehicle>()) ? VehicleClass->GetDefaultObject<AProjectXVehicle>()->GetVehicleID() : ""; } }


    UPROPERTY(BlueprintAssignable, Category = Vehicle)

    FDriverChangedSignature OnDriverChanged;

    UPROPERTY(BlueprintAssignable, Category = "Locomotion Events")

    FVehicleLocomotionChangeSignature OnBoostingChanged;

    UPROPERTY(BlueprintAssignable, Category = Vehicle)

    FPassengerChangedSignature OnPassengerChanged;

    UPROPERTY(BlueprintAssignable)

    FLandedSignature OnLand;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnLockOnSignature OnLockOnTentativeStart;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnLockOnSignature OnLockOnTentativeEnd;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnLockOnSignature OnLockOnStart;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnLockOnSignature OnLockOnEnd;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnImminentMissileWarningSignature OnImminentMissileWarningStart;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnImminentMissileWarningSignature OnImminentMissileWarningEnd;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnIncomingProjectileSignature OnIncomingProjectileStart;

    UPROPERTY(BlueprintAssignable, Category = "Lock On Events")

    FPawnIncomingProjectileSignature OnIncomingProjectileEnd;

    UPROPERTY(BlueprintAssignable)

    FVehicleDiedEvent OnVehicleDied;

    UPROPERTY(BlueprintAssignable)

    FVehicleBoostChanged OnVehicleBoostChanged;

    UPROPERTY(BlueprintAssignable)

    FVehicleBoostSignature OnVehicleStartedBoosting;

    UPROPERTY(BlueprintAssignable)

    FVehicleBoostSignature OnVehicleStoppedBoosting;


protected:

    friend class UVehicleSeatComponent;

    virtual bool DriverEnter(AProjectXCharacter* Character);

    virtual bool DriverLeave(AProjectXCharacter* Character, bool bForceLeave);


    virtual void SetDriving(bool bNewDriving);

    virtual void PostInitializeComponents() override;

    virtual void PreReplication(IRepChangedPropertyTracker & ChangedPropertyTracker) override;

    virtual void BeginPlay() override;

    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

    virtual void Tick(float DeltaTime) override;

    virtual void TickHealthRegen(float DeltaTime);

    virtual void TickBoost(float DeltaTime);

    virtual void ToggleBoost(bool bToggle);

    virtual void SendActorLookRotationAndPosition();

    virtual void OnSwitchMovementMode(bool bNewDriving);


    virtual void StartBoosting();

    virtual void StopBoosting();

    virtual void MoveForward(float Val);

    virtual void MoveRight(float Val);

    virtual void TurnAtRate(float Rate);

    virtual void LookUpAtRate(float Rate);

    virtual void Turn(float Value);

    virtual void LookUp(float Value);

    virtual void MoveUp(float Vaue);

    virtual void StopJumping() override;

    virtual void Jump() override;

    virtual void Landed(const FHitResult& Hit) override;


    //Finds a friendly exit for a given pawn. Returns false if it could not find a friendly exit (still will provide a valid exit location).

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual bool FindExitDestination(AProjectXCharacter* Character, FTransform& Transform) const;

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual void SetAsDisplayOnly();

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual void SetDisplayDriver(AProjectXCharacter* CosmeticDriver);

    //Gets closest entry location for a given pawn. Returns a byte denoting from where the player will be entering (if applicable).

    UFUNCTION(BlueprintCallable, Category = Vehicle)

    virtual UVehicleSeatComponent* GetClosestEntryLocation(AProjectXCharacter* Character, FVector& Location) const;

    virtual FName GetClosestSeatName(const APlayerController* QueryController) const;


    void PassengersChanged(UVehicleSeatComponent* Seat, AProjectXCharacter* PreviousPassenger);

    virtual void OnVehicleEmpty();

    virtual void StartSelfDestruction(UWorld* World);

    virtual void StopSelfDestruction(UWorld* World);


    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE bool IsHoverVehicle() const { return bHasGravityInFlyingMode; }

    UFUNCTION(BlueprintPure, Category = Vehicle)

    FORCEINLINE bool DoesVehicleMoveRelativeToSelf() const { return bMoveVehicleRelative; }


    UFUNCTION(Client, Reliable)

    void Client_StopJumping();

    UFUNCTION(Server, Reliable)

    void Server_ProcessHit(const FHitResult& Hit);

    UFUNCTION(Server, Reliable)

    void Server_ToggleBoost(const bool bToggle);

    //Called every frame by the locally controlled client.

    UFUNCTION(Server, Unreliable)

    void Server_Unreliable_SendCameraLocation(const FVector_NetQuantize10& CameraPosition);

    UFUNCTION(Server, Unreliable)

    void Server_Unreliable_SendPitchValue(uint16 NewPawnPitchValue);

    UFUNCTION(Server, Unreliable)

    void Server_Unreliable_SendYawValue(uint16 NewPawnPitchValue);

    //Called every frame by authority.

    UFUNCTION(NetMulticast, Unreliable)

    void Multicast_Unreliable_CameraPosition(const FVector_NetQuantize10& CameraPosition);

    UFUNCTION(NetMulticast, Unreliable)

    void Multicast_Unreliable_SendPitchValue(uint16 NewPawnYawValue);

    UFUNCTION(NetMulticast, Unreliable)

    void Multicast_Unreliable_SendYawValue(uint16 NewPawnYawValue);


    UFUNCTION()

    virtual void ExitPersonalVehicle();

    UFUNCTION()

    virtual void OnVehicleHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);

    UFUNCTION()

    virtual void OnVehicleBeginOverlap(AActor* OverlappedActor, AActor* OtherActor);

    UFUNCTION()

    virtual void OnVehicleEndOverlap(AActor* OverlappedActor, AActor* OtherActor);


    UFUNCTION()

    virtual void OnSelected(APlayerController* Sender, class UPrimitiveComponent* Component);

    UFUNCTION()

    virtual void OnHighlighted(APlayerController* Sender, class UPrimitiveComponent* Component);


    UFUNCTION()

    virtual void OnRep_WeaponComponent();

    UFUNCTION()

    virtual void OnRep_IsBoosting();

    UFUNCTION()

    virtual void OnRep_Driver();

    UFUNCTION()

    virtual void OnRep_Health(float PreviousHealth);


    UFUNCTION()

    virtual void OnRep_Boost();


    /* Name of this vehicle */

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Vehicle", meta = (AllowPrivateAccess = true))

    FText VehicleName;

    /* Sockets to fire vehicle projectiles from */

    UPROPERTY(Category = "Vehicle|Cosmetics", EditDefaultsOnly)

    TArray<FName> FiringSockets;

    /* Should we align the driver's view to the vehicle's forward vector when entering this vehicle? */

    UPROPERTY(Category = "Vehicle", EditDefaultsOnly)

    bool bAlignCameraOnVehicleEnter = false;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|KillCam")

    TSubclassOf<AKillCameraActor> KillCamActorClass = NULL;

    /*How far Away is the kill cam from the mesh*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|KillCam")

    float KillCameraDistance = 0.0f;

    /* The max angle we will try to align our vehicle to in slopes */

    UPROPERTY(Category = "Vehicle", EditDefaultsOnly)

    FVector2D MaxTerrainConformAngle = FVector2D(45.0f, 45.0f);

    /* Do collisions with things harm our vehicle? */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly)

    bool bCollisionDamagesVehicle = false;

    /* Damage type to be applied to this vehicle when colliding with things. Defaults to UDamageType_Physical*/

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionDamagesVehicle"))

    TSubclassOf<UDamageType> VehicleCollisionDamageTakenType;

    /* How much damage this vehicle should take per KM/H when colliding with things, calculation is based on how much speed this vehicle has above MinSpeedRequiredForTakingDamage*/

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionDamagesVehicle"))

    float VehicleDamageOnCollisionAmount = 100.f;

    /* This vehicle will only take damage if its speed is bigger than this value in KM/H */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionDamagesVehicle"))

    float MinSpeedRequiredForTakingDamage = 30.f;

    /* A multiplier that acts on the damage taken based on the angle between this vehicle's velocity and the collision's impact normal */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionDamagesVehicle"))

    float CollisionAngleDamageMultiplier = 1.f;

    /* Can this vehicle harm other things by colliding with them? */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly)

    bool bCollisionDamagesOthers = false;

    /* Damage type to be applied to things that this vehicle collides with. Defaults to UDamageType_Physical*/

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionDamagesOthers"))

    TSubclassOf<UDamageType> VehicleCollisionDamageInflictedType;

    /* How much damage this vehicle should inflict per KM/H when colliding with characters, calculation is based on how much speed this vehicle has above MinSpeedRequiredForApplyingDamage */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionDamagesOthers"))

    float CharactersDamageOnCollisionAmount = 100.f;

    /* This vehicle will only apply damage to characters if its speed is bigger than this value in KM/H */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionDamagesOthers"))

    float MinSpeedRequiredForApplyingDamage = 30.f;

    /* Should this vehicle push characters when colliding with them? */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly)

    bool bCollisionPushesCharacters = false;

    /* How much impulse should be applied per KM/H to other characters when this vehicle hit them */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionPushesCharacters"))

    float CharactersImpulseOnCollisionAmount = 5000.f;

    /* The maximum amount of force we can apply to characters hit (magnitude) */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionPushesCharacters"))

    float CharactersImpulseOnCollisionMaxAmount = 20000.f;

    /* How much upwards offset to the launch vector we should apply to other characters when we hit them. This helps to prevent us pushing characters towards the ground which can slow them drastically while being pushed */

    UPROPERTY(Category = "Vehicle|Collision", EditDefaultsOnly, meta = (EditCondition = "bCollisionPushesCharacters"))

    float CharactersImpulseOnCollisionVerticalOffset = 10.f;

    /* How much forward motion is applied to this pawn every tick. Useful for airships which would always have *some* degree of forward motion. */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (ClampMin = "0.0", ClampMax = "1.0"))

    float ConstantForwardAmount = 0.0f;

    /* Speed multiplier applied while boosting */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls")

    float BoostMultiplier = 5.0f;

    /* Sensitivity applied over the Input as a multiplier to the vertical axis*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls")

    float VerticalSensitivity = 35.f;

    /* Sensitivity applied over the Input as a multiplier to the horizontal axis*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls")

    float HorizontalSensitivity = 35.f;

    /* A multiplier that acts on the engine when moving Forward/Backwards */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls")

    float ForwardSpeedMultiplier = 1.f;

    /* A multiplier that acts on the engine when moving Left/Right */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls")

    float SidewaysSpeedMultiplier = .5f;

    /* A multiplier that acts on the Throttle when going Up */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "!bHasGravityInFlyingMode"))

    float ThrottleUpMultiplier = 1.f;

    /* A multiplier that acts on the Throttle when going Down */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "!bHasGravityInFlyingMode"))

    float ThrottleDownMultiplier = 1.f;

    /* Should the vehicle tilt based on velocity? */

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Vehicle|Controls")

    bool bAllowCosmeticTilts = true;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bAllowCosmeticTilts"))

    float MaxHoverTilt = 10.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bAllowCosmeticTilts"))

    float MaxHoverPitch = 10.0f;

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Vehicle|Controls")

    bool bHasGravityInFlyingMode = false;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bHasGravityInFlyingMode"))

    float TerrainConformSpeed = 4.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bHasGravityInFlyingMode"))

    float FallingForwardTilt = 0.25f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bHasGravityInFlyingMode"))

    bool IgnoreTerrainPitch = false;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bHasGravityInFlyingMode"))

    float VehicleMeshSmoothingSpeed = 5.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bHasGravityInFlyingMode"))

    float TerrainConformSpeedFalling = 1.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bIsHoverVehicle"))

    float HoverAdjustmentSpeed = 100.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bIsHoverVehicle"))

    float MaxFloorAngleToAlignInput = 30.0f;

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Vehicle|Controls")

    bool bMoveVehicleRelative = false;

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Vehicle|Controls")

    bool bRotateMeshToVelocityDirection = false;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Controls", meta = (EditCondition = "bRotateMeshToStrafeDirection"))

    float RotateMeshToStrafeDirectionSpeed = 10.0f;

    /* A curve that can be used to dynamically change the drain rate of this boost while not grounded */

    UPROPERTY(EditDefaultsOnly, Category = Jetpack, meta = (EditCondition = "bUseBoostInsteadOfJump"))

    class UCurveFloat* BoostDrainCurve = NULL;

    /* Whether this vehicle can respawn or not*/

    UPROPERTY(EditAnywhere, Category = "Vehicle|Spawn")

    bool bCanRespawn = true;

    /* Whether a player can spawn inside this vehicle or not */

    UPROPERTY(EditAnywhere, Category = "Vehicle|Spawn")

    bool bVehicleCanBeUsedForSpawn = true;

    /* Whether a player can spawn inside this vehicle if there are seats available*/

    UPROPERTY(EditAnywhere, Category = "Vehicle|Spawn", meta = (EditCondition = "bVehicleCanBeUsedForSpawn"))

    bool bPlayerCanSpawnInside = true;

    /* Whether a player can spawn near the vehicle (outside) if there are no seats available */

    UPROPERTY(EditAnywhere, Category = "Vehicle|Spawn", meta = (EditCondition = "bVehicleCanBeUsedForSpawn"))

    bool bPlayerCanSpawnNearby = false;

    /*Time it takes for the vehicle to respawn after being destroyed*/

    UPROPERTY(EditAnywhere, Category = "Vehicle|Respawn")

    float RespawnTime = 25.f;

    /*Time it takes for the vehicle to respawn after being destroyed*/

    UPROPERTY(EditAnywhere, Category = "Vehicle|Respawn")

    float PostLifeDuration = 5.0f;

    /*ForceApplied Vertically When destroyed*/

    UPROPERTY(EditAnywhere, Category = "Vehicle|Respawn")

    float DeathImpulseForce = 1000.0f;

    /* Should this vehicle keep its last aim hit location as the zeroing? This could be helpful when aiming towards the sky as the aim target can shift drastically between what's in front and what is the infinite range (Skybox) */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Aim")

    bool bRetainLastKnownZeroingWhenNoHit = true;

    /* The minimum amount of distance that we consider for setting the zeroing in centimeters. This means that if something is closer than AimMinZeroing, this vehicle won't adjust the angle of its guns to match that location, it will aim forward instead */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Aim")

    float AimMinDistanceForZeroing = 1000.f;

    /* The default zeroing set when  RetainLastKnownZeroingWhenNoHit is set to false and we can't identify what to set our Zeroing to*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Aim")

    float AimDefaultZeroing = 100000000.f;

    /* Maximum amount of degrees the gun can deviate from the vehicle's front*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Vehicle|Aim")

    float MaxAimAngleDeviation = 15.f;

    /* This icon will be used for the vehicle on the map */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|UI")

    TAssetPtr<UTexture2D> VehicleSeatsHUDIcon = NULL;

    /* This icon will be used for the vehicle on the map */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|UI")

    TAssetPtr<UTexture2D> VehicleMapIcon = NULL;

    /* This vehicle's icon that is to be displayed on HUDs*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|UI")

    TSoftObjectPtr<UTexture2D> VehicleHudIcon = NULL;

    /* This vehicle's icon that is to be displayed on radars*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|UI")

    TSoftObjectPtr<UTexture2D> VehicleRadarIcon = NULL;

    /* Amount of time to bob the vehicle down when it lands */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Cosmetics")

    float VehicleDownBobSpeed = 5.f;

    /* Amount of time to bob the vehicle up when it lands */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Cosmetics")

    float VehicleUpBobSpeed = 15.f;

    /* Distance to bob the vehicle when it lands */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle|Cosmetics")

    float VehicleBobDistance = 100.0f;

    /* Is this vehicle meant to be used only as a display? Such as in preview modes for a store or armory */

    UPROPERTY(EditAnywhere, BlueprintReadWrite , Category = "Vehicle|Cosmetics", Meta = (ExposeOnSpawn = true))

    bool bDisplayOnly = false;

    /* Latest team value before a new driver being replicated */

    UPROPERTY(BlueprintReadOnly, Category = "Vehicle|Stats")

    int32 CachedTeam = INDEX_NONE;

    /* Bool that allow vehicles to use boost */

    UPROPERTY(Category = "Vehicle|Controls", EditDefaultsOnly, BlueprintReadOnly)

    bool bVehicleCanBoost = true;

    /* Minimum Damage from vehicle explosion */

    UPROPERTY(Category = "Vehicle|Explosion", EditDefaultsOnly, BlueprintReadOnly)

    float MinimumVehicleExplosionDamage = 10.0f;

    /* Base vehicle explosion damage */

    UPROPERTY(Category = "Vehicle|Explosion", EditDefaultsOnly, BlueprintReadOnly)

    float BaseVehicleExplosionDamage = 50.0f;

    /* Vehicle explosion inner radius */

    UPROPERTY(Category = "Vehicle|Explosion", EditDefaultsOnly, BlueprintReadOnly)

    float ExplosionInnerRadius = 1000.0f;

    /* Vehicle explosion outer radius */

    UPROPERTY(Category = "Vehicle|Explosion", EditDefaultsOnly, BlueprintReadOnly)

    float ExplosionOuterRadius = 2000.0f;

    /* Vehicle explosion damage falloff */

    UPROPERTY(Category = "Vehicle|Explosion", EditDefaultsOnly, BlueprintReadOnly)

    float ExplosionDamageFallOff = 1.0f;

    /* Vehicle explosion damage falloff */

    UPROPERTY(Category = "Vehicle|Interaction", EditDefaultsOnly, BlueprintReadOnly)

    bool bCanBeInteractedWith = true;

    /* how much of the drivers velocity carries over to the vehicle */

    UPROPERTY(Category = "Vehicle|Controls", EditDefaultsOnly, BlueprintReadOnly)

    float DriverVelocityTransferRate = 0.0f;

    /* How Long does it take to exit the vehicle*/

    UPROPERTY(Category = "Vehicle|Controls", EditDefaultsOnly, BlueprintReadOnly)

    float ExitTime = 0.5f;

    /* How much damage that the vehicle takes is transffered to the occupants*/

    UPROPERTY(Category = "Vehicle|Damage", EditDefaultsOnly, BlueprintReadOnly)

    float DamageTransferMultiplier = 0.0f;

    virtual float GetTimeSinceLastDamage() const override;


    /*Returns the max distance this vehicle can be to be considered for locking-into. This means that if we scan for 20km targets but this vehicle has a MaxLockOnRange

    of 100m and this actor is further away than 100m it won't be considered as a candidate during the target-finding. A returned value of 0 is by default ignored by target-finding systems */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Vehicle|LockOn")

    float MaxLockOnRange = 0.f;

    /* Returns the Screen percentage that this vehicle is required to have to be considered for Locking-onto (In both vertical and horizontal axis of the viewport).

    A value of FVector2D(0,0) will by default be ignored by weapons when deciding locking-into candidates. For example, when scanning for a 20km range, if this vehicle

    has a screen percentage bigger than GetLockOnScreenPercentage() (in any axis) it is going to be considered as a candidate to be locked into. This is useful as

    actors that are really far away can still look big on the screen and feels like they should be locked into */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Vehicle|LockOn")

    FVector2D LockOnScreenPercentage = FVector2D::ZeroVector;


    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Vehicle)

    USceneComponent* MeshPivotPoint = NULL;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Vehicle)

    UCameraComponent* Camera = NULL;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Vehicle)

    USpringArmComponent* SpringArm = NULL;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Vehicle)

    UDamageHistoryComponent* DamageHistoryComponent = NULL;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Vehicle)

    UVehicleSeatComponent* DriverSeat = NULL;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Vehicle)

    UInteractableComponent* InteractableComponent = NULL;

    UPROPERTY(EditDefaultsOnly, Category = Afflictions)

    UAfflictionComponent* AfflictionComponent = NULL;


    UPROPERTY(ReplicatedUsing = OnRep_Health)

    float Health = 100.0f;

    UPROPERTY(Replicated, EditDefaultsOnly, Category = "Vehicle")

    float MaxHealth = 100.0f;

    /* Is this target armored? Affects HUD, hitping colour and sound etc */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    bool bArmored = true;

    UPROPERTY(Replicated)

    FVector CameraLocation;

    UPROPERTY(ReplicatedUsing = OnRep_Driver)

    TWeakObjectPtr<AProjectXCharacter> Driver = NULL;

    UPROPERTY(ReplicatedUsing = OnRep_WeaponComponent)

    UWeaponComponent* VehicleWeaponComponent;

    UPROPERTY()

    float LastDamageTime = -MAX_FLT;

    /*If the vehicle is Boosting*/

    UPROPERTY(ReplicatedUsing = OnRep_IsBoosting)

    bool bIsBoosting = false;

    /*Current Vehicle boost*/

    UPROPERTY(ReplicatedUsing = OnRep_Boost)

    float Boost = 100.0f;

    UPROPERTY(Replicated, Category = "Vehicle|Movement (Acceleration)", BlueprintReadOnly)

    uint8 PackedAcceleration = 0;

    /*Max Vehicle boost*/

    UPROPERTY()

    float MaxBoost = 100.0f;

    /*How fast boost regenerates for Vehicles*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float BoostRegenRate = 15.0f;

    /*How fast boost drains for Vehicles*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float BoostDrainRate = 15.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    FString VehicleID = "";

    UPROPERTY()

    bool bVisible = true;

    /* How long does a vehicle stays alive when unoccupied and not close to its spawn position? */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float UnoccupiedLifeDuration = 15.0f;

    /* How far the vehicle can be from its spawn position without triggering the self-destruction timer in cm */

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float SelfDestructionMinDistance = 500.0f;

    /* How long at minimum must you be in the vehicle*/

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float MinimumDriverDurationTime = 2.0f;


    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    TSubclassOf<UCameraModifier> BoostCameraModifierClass = nullptr;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float BoostFOVModifier = 10.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float BoostAlphaBlend = 1.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float BoostDepthOfFieldFStop = 20.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    float BoostDepthOfFieldFocalDistance = 36.0f;


    UPROPERTY(EditDefaultsOnly, Category = "Vehicle")

    bool bInitializeVehicleHealth = true;


    UPROPERTY(EditDefaultsOnly, Category = Explodable)

    TSubclassOf<class UWeaponInstance> VehicleExplosionWeaponInstanceClass = nullptr;

    UPROPERTY(EditDefaultsOnly, Category = Explodable)

    TSubclassOf<class UDamageType> VehicleExplosionDamageTypeClass;


    friend class UProjectXVehicleMovementComponent;


    TArray<TWeakObjectPtr<AProjectXCharacter>> IgnoredCharactersFromVehicleCollision;

    TArray<TWeakObjectPtr<UVehicleSeatComponent>> Seats;

    TWeakObjectPtr<AProjectXCharacter> LastDriver = NULL;

    TWeakObjectPtr<UCameraModifier> BoostCameraModifierInstance = NULL;


    FTransform SpawnTransform = FTransform::Identity;

    bool bDead = false;

    bool bDriving = false;

    float NextRotationSendTime = 0.0f;

    float AimTargetForwardOffset = 2000.f;

    float HealthRegenRate = 0.0f;

    mutable float LastKnownZeroing = -1.f;

    bool bRotationFlipFlop = false;

    FRotator CurrentLookRotation = FRotator::ZeroRotator;

    int32 FiringSocketCounter = 0;

    float LastOccupantLeftTime = 0.f;

    FTimerHandle SelfDestructionTimer;

    FTimerHandle MaxBoostTimer;

    FTimerHandle BoostCooldownTimer;

    float DriverEnterTime = 0.f;

    bool bIsInKillCam = false;

    float BoostUsageTime = 0.0f;

private:

    uint8 PreviousPackedAcceleration = 0;

};

EItemType::Weapon
@ Weapon

HealthInterface.h

EInputCategory::Movement
@ Movement

InteractableInterface.h

KillCamInterface.h

LockOnTargetInterface.h

EManagedActorState::On
@ On

ObjectInfoInterface.h

OwnedInterface.h

EStatClassifier::Vehicle
@ Vehicle

ProjectX.h

EStimulusType::Damage
@ Damage

ECharacterStat::Health
@ Health

EInputDirection::Forward
@ Forward

EInputDirection::Right
@ Right

EInputDirection::Left
@ Left

EDeathEffectBodyPartsType::Hit
@ Hit

EMessageType::Server
@ Server

DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FPassengerChangedSignature, class AProjectXVehicle *, Vehicle, class UVehicleSeatComponent *, Seat, class AProjectXCharacter *, PreviousPassenger)

EAccelerationDirection
EAccelerationDirection
Definition: ProjectXVehicle.h:45

EAccelerationDirection::Back
@ Back

EAccelerationDirection::Down
@ Down

EAccelerationDirection::Up
@ Up

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FDriverChangedSignature, class AProjectXVehicle *, Vehicle, class AProjectXCharacter *, OldDriver)

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FVehicleHierarchyUpdated, class AProjectXVehicle *, Vehicle)

DECLARE_DYNAMIC_MULTICAST_DELEGATE
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FVehicleDiedEvent)

SpawnTargetInterface.h

SpottableInterface.h

ESpotType
ESpotType
Definition: SpottableInterface.h:18

ESpotReply
ESpotReply
Definition: SpottableInterface.h:27

TeamInterface.h

TrackableInterface.h

ECompressedFlags::Jetpack
@ Jetpack

AKillCameraActor
Definition: KillCameraActor.h:19

AProjectXCharacter
Definition: ProjectXCharacter.h:128

AProjectXPlayerState
Definition: ProjectXPlayerState.h:238

AProjectXVehicle
Definition: ProjectXVehicle.h:56

AProjectXVehicle::GetObjectName
virtual const FText & GetObjectName() const
Definition: ProjectXVehicle.h:71

AProjectXVehicle::GetLockOnTentativeEndDelegate
virtual FPawnLockOnSignature & GetLockOnTentativeEndDelegate() override
Definition: ProjectXVehicle.h:103

AProjectXVehicle::GetSeats
FORCEINLINE const TArray< TWeakObjectPtr< UVehicleSeatComponent > > & GetSeats() const
Definition: ProjectXVehicle.h:61

AProjectXVehicle::GetLockOnEndDelegate
virtual FPawnLockOnSignature & GetLockOnEndDelegate() override
Definition: ProjectXVehicle.h:105

AProjectXVehicle::GetHudIcon
virtual TSoftObjectPtr< UTexture2D > GetHudIcon() const override
Definition: ProjectXVehicle.h:114

AProjectXVehicle::GetLockOnScreenPercentage
virtual FVector2D GetLockOnScreenPercentage() override
Definition: ProjectXVehicle.h:100

AProjectXVehicle::GetLockOnTentativeStartDelegate
virtual FPawnLockOnSignature & GetLockOnTentativeStartDelegate() override
Definition: ProjectXVehicle.h:102

AProjectXVehicle::GetIncomingProjectileStartDelegate
virtual FPawnIncomingProjectileSignature & GetIncomingProjectileStartDelegate() override
Definition: ProjectXVehicle.h:108

AProjectXVehicle::GetTrackableInterfaceActor
virtual AActor * GetTrackableInterfaceActor() override
Definition: ProjectXVehicle.h:115

AProjectXVehicle::GetRadarIcon
virtual TSoftObjectPtr< UTexture2D > GetRadarIcon() const override
Definition: ProjectXVehicle.h:113

AProjectXVehicle::GetLockOnMaxDistance
virtual float GetLockOnMaxDistance()
Definition: ProjectXVehicle.h:101

AProjectXVehicle::GetIncomingProjectileEndDelegate
virtual FPawnIncomingProjectileSignature & GetIncomingProjectileEndDelegate() override
Definition: ProjectXVehicle.h:109

AProjectXVehicle::SetHealthRegenRate
virtual void SetHealthRegenRate(float NewRate) override
Definition: ProjectXVehicle.h:83

AProjectXVehicle::IsArmored
virtual bool IsArmored() const override
Definition: ProjectXVehicle.h:70

AProjectXVehicle::UpdateVisibilityModifier
void UpdateVisibilityModifier(bool NewVisibility)
Definition: ProjectXVehicle.h:119

AProjectXVehicle::GetSpottingTraceOffset
virtual FVector GetSpottingTraceOffset() const override
Definition: ProjectXVehicle.h:111

AProjectXVehicle::GetImminentMissileWarningEndDelegate
virtual FPawnImminentMissileWarningSignature & GetImminentMissileWarningEndDelegate() override
Definition: ProjectXVehicle.h:107

AProjectXVehicle::GetImminentMissileWarningStartDelegate
virtual FPawnImminentMissileWarningSignature & GetImminentMissileWarningStartDelegate() override
Definition: ProjectXVehicle.h:106

AProjectXVehicle::GetMapIcon
virtual TSoftObjectPtr< UTexture2D > GetMapIcon() const override
Definition: ProjectXVehicle.h:112

AProjectXVehicle::GetLockOnStartDelegate
virtual FPawnLockOnSignature & GetLockOnStartDelegate() override
Definition: ProjectXVehicle.h:104

IHealthInterface
Definition: HealthInterface.h:28

IInteractableInterface
Definition: InteractableInterface.h:18

IKillCamInterface
Definition: KillCamInterface.h:21

ILockOnTargetInterface
Definition: LockOnTargetInterface.h:27

IObjectInfoInterface
Definition: ObjectInfoInterface.h:16

IOwnedInterface
Definition: OwnedInterface.h:20

ISpawnTargetInterface
Definition: SpawnTargetInterface.h:18

ISpottableInterface
Definition: SpottableInterface.h:40

ITeamInterface
Definition: TeamInterface.h:26

ITrackableInterface
Definition: TrackableInterface.h:22

UProjectXVehicleMovementComponent
Definition: VehicleMovementComponent.h:16

URadarIconWidget
Definition: RadarIconWidget.h:22

UWeaponInstance
Definition: WeaponInstance.h:220

UWeaponInstanceVehicle
Definition: WeaponInstanceVehicle.h:16

FRespawnInformation
Definition: VehicleRespawnManager.h:13