WeaponInstanceProjectile.h

Go to the documentation of this file.

 
// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Weapons/WeaponInstanceRanged.h"
#include "WeaponInstanceProjectile.generated.h"
 
class UDamageType;
class AProjectile;
class UAdvancedWidgetComponent;
class UCurveFloat;
 
UENUM(Blueprintable)
enum class ELockOnType : uint8
{
    TightAimOnly = 0,
    Always = 1,
    NONE = MAX_uint8,
};
 
UENUM(Blueprintable)
enum class EProjectileMagnetismType : uint8
{
    Always = 0,
    GamepadOnly = 1,
    Disabled = MAX_uint8,
};
 
UCLASS()
class PROJECTX_API UWeaponInstanceProjectile : public UWeaponInstanceRanged
{
    GENERATED_BODY()
 
public:
    void BeginPlay();
    virtual TSubclassOf<class UDamageType> GetDamageType() const override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    float GetProjectileSpeed() const;
    UFUNCTION(BlueprintPure, Category = "Projectile Weapon")
    FORCEINLINE AActor* GetHomingTarget() const { return CanLockOn() ? LockOnTarget.Get() : NULL; }
    FORCEINLINE bool GetShouldProjectilesNotifyTarget() const { return bShouldProjectilesNotifyTarget; }
    FORCEINLINE float GetTimeBeforeNotifyingHomingTargetLost() const { return TimeBeforeNotifyingHomingTargetLost; }
    FORCEINLINE AActor* GetAimTarget() const { return AimTarget.Get(); }
    FORCEINLINE float GetProjectileMagnetismFalloff() const { return MagnetismFalloff; }
    UFUNCTION(BlueprintPure, Category = "Projectile Weapon")
    FORCEINLINE float GetLockOnStrength() const { return LockOnStrength; }
    UFUNCTION(BlueprintPure, Category = "Projectile Weapon")
    bool CanLockOn() const;
    UFUNCTION(BlueprintPure, Category = "Projectile Weapon")
    float CalculateMagnetismFalloff();
    UFUNCTION(BlueprintPure, Category = "Projectile Weapon")
    float GetWeaponMagnetismConeSize() const;
    UFUNCTION(BlueprintPure, Category = "Projectile Weapon")
    bool IsWeaponMagnetismEnabled();
    UFUNCTION(BlueprintPure, Category = "Projectile Weapon")
    TSubclassOf<AActor> GetProjectileClass() const { return ProjectileClass; }
    virtual void InitializeWeapon(bool bFromBatchInitialization = false) override;
    virtual float GetDisplayDamage() const override;
    virtual void PrimaryFire(uint8 RemainingBurstCount) override;
 
    virtual bool Equip() override;
    virtual bool UnEquip(bool bForce = false) override;
    virtual float GetProjectileDamageModifier();
 
    virtual void StopAllActions() override;
 
    UFUNCTION(BlueprintNativeEvent)
    bool GetProjectileTransform(FTransform& Transform, FTransform& CosmeticTransform);
 
protected:
    virtual TArray<AActor*> GetIgnoredActors() { return TArray<AActor*>(); }
    virtual void FireProjectiles();
    //deferredly spawns a punch of projectiles at the given transform.
    TArray<TWeakObjectPtr<AProjectile>> SpawnProjectiles(UClass* Class, const FTransform& Transform, const FTransform& CosmeticTransform);
 
    virtual void PreSpawnClientProjectile(const uint8 ShotID,AProjectile* Projectile);
 
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_AuthenticateTicket(const TArray<int32>& ProjectileIDs, TSubclassOf<AProjectile> UsedProjectileClass, const FVector_NetQuantize& Origin, AActor* PlayerAimTarget = nullptr, const float PlayerMagnetismFalloff = 1.0f);
    
    UFUNCTION()
    int32 GetProjectileID() { return ProjectileIDCounter++; }
 
    virtual void ToggleTightAim(bool bEnable) override;
    virtual void ToggleLockOn(bool bEnable);
 
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_LockOn(AActor* Target);
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_SetTentativeLockOn(AActor* Target);
 
    virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    virtual void TickTargetFinder(float DeltaTime);
    virtual void TickTargetLockOn(float DeltaTime);
    virtual void TickTargetMaintain(float DeltaTime);
 
    virtual void UpdateLockOn(float DeltaStrength);
    virtual void SetLockOn(AActor* Target);
    virtual void SetTentativeLockOn(AActor* Target);
 
    virtual bool IsValidLockOnTarget(AActor* Target) const;
 
    UFUNCTION()
    virtual void OnRep_LockOnTarget();
    UFUNCTION()
    virtual void OnRep_TentativeLockOnTarget();
 
    UFUNCTION()
    virtual void UpdateLockOnWidget(AActor* Target, TSubclassOf<UAdvancedWidgetComponent> WidgetComponentClass);
 
public:
    /* Type of projectile to shoot */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon")
    TSubclassOf<AActor> ProjectileClass = NULL;
    /* How fast should the projectile move? */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon")
    float ProjectileSpeed = 10000.f;
    /* How many projectiles the weapon shoots. The number of projectiles will divide the total damage dealt. Every projectiles will have to hit to deal full damage. */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon")
    int32 ProjectileCount = 1;
    /* Socket on the mesh used as a spawn point for client projectiles. */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon")
    FName ClientProjectileTransformSocket = FName("Muzzle");
    /* If this weapon is not managed by the Weapon Component, should we query the ClientProjectileTransformSocket from the equipped weapon anyways? If false, we'll fallback to the 1P or 3P skeletal mesh we're using */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon", meta = (EditCondition = "bIsManagedByWeaponComponent"))
    bool bUnmanagedSearchProjectileSocketOnWeapon = false;
 
    TArray<TWeakObjectPtr<AProjectile>> ProjectileList;
protected:
 
    /*Should the characters speed be added to the projectile speed */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon")
    bool bUseCharacterSpeed = false;
    /* Should projectile magnetism run gamepad only or with mouse? It can be disabled here as well. */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    EProjectileMagnetismType ProjectileMagnetismType = EProjectileMagnetismType::Always;
    /* Anything below the first value will be 100% bullet magnetism, the amount of magnetism will drop off until the player's angle reaches the second value. */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    FVector2D ProjectileMagnetismFalloffAngle = FVector2D(6.0f, 10.0f);
    /* Gamepad Only! Anything below the first value will be 100% bullet magnetism, the amount of magnetism will drop off until the player's angle reaches the second value. */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    FVector2D ProjectileMagnetismFalloffAngleGamepad = FVector2D(6.0f, 10.0f);
    /* Same as above but for tight aming. if you have the player on 2x zoom you will want to make the cone 2x tighter */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    FVector2D TightAimedProjectileMagnetismFalloffAngle = FVector2D(3.0f, 5.0f);
    /* Gamepad Only! Same as above but for tight aming. if you have the player on 2x zoom you will want to make the cone 2x tighter */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    FVector2D TightAimedProjectileMagnetismFalloffAngleGamepad = FVector2D(3.0f, 5.0f);
    /* At what distance does magnetism start to fall off? Distance is X and falloff value is Y. If you want a gun that has 100% magnetism up to 1500cm, define a key at (0, 1) and a key at (1500, 1) then taper off the curve over time as X gets > 1500 */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    UCurveFloat* ProjectileMagnetismDistanceFalloffCurve = nullptr;
    /* Gamepad Only! At what distance does magnetism start to fall off? Distance is X and falloff value is Y. If you want a gun that has 100% magnetism up to 1500cm, define a key at (0, 1) and a key at (1500, 1) then taper off the curve over time as X gets > 1500 */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    UCurveFloat* ProjectileMagnetismDistanceFalloffCurveGamepad = nullptr;
    /* Same as above but for tight aiming. If using 2x zoom you'll want to double the distance of the falloff curve */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    UCurveFloat* TightAimedProjectileMagnetismDistanceFalloffCurve = nullptr;
    /* Gamepad Only! Same as above but for tight aiming. If using 2x zoom you'll want to double the distance of the falloff curve */
    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")
    UCurveFloat* TightAimedProjectileMagnetismDistanceFalloffCurveGamepad = nullptr;
    /* Should this weapon have the ability to lock on targets? */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On")
    ELockOnType LockOn = ELockOnType::NONE;
    /* Should this weapon notify the target it has incoming projectiles when firing homing projectiles towards it? */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On")
    bool bShouldProjectilesNotifyTarget = false;
    /* How long, in seconds, should we wait before notifying the target that our projectiles have lost the target.
     Projectiles can lose/regain acceleration towards the homing target based on an angle between the projectiles velocity and the direction towards the target
     Having some time in here allows the projectile to not fire a lot of notifications of gained/lost the target when the changes occur too often, which might happen frequently in some cases */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On")
    float TimeBeforeNotifyingHomingTargetLost = .3f;
    /* What is the lock-on range? */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On", meta = (EditCondition = "bCanLockOn"))
    float LockOnRange = 10000.f;
    /* What is the radius of the target finder from within the center of the camera? */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On", meta = (EditCondition = "bCanLockOn"))
    float LockOnRadius = 300.f;
    /* How long does the player need to hold the button for the lock on to be full initialized and ready */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On", meta = (EditCondition = "bCanLockOn"))
    float LockOnTime = 1.f;
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On", meta = (EditCondition = "bCanLockOn"))
    float MinLockOnPercent = 0.75f;
    /* Max angle the player can be looking (relative to the target) for lock on to work */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On", meta = (EditCondition = "bCanLockOn"))
    float MaxLockOnAngle = 30.f;
    /* Check this if you want the lock-on to only work if the player manages to keep its cursor inside the Lock-Square */
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On", meta = (EditCondition = "bCanLockOn"))
    bool bUsePlaneIntersectionForLock = false;
 
    UPROPERTY()
    float MinDotProduct; //Cached version of MaxLockOnAngle
    UPROPERTY(EditDefaultsOnly, Category = "Projectile Weapon|Lock On", meta = (EditCondition = "bCanLockOn"))
    TSubclassOf<UAdvancedWidgetComponent> LockOnWidgetComponentClass = NULL;
    UPROPERTY()
    TWeakObjectPtr<UAdvancedWidgetComponent> LockOnWidgetComponent = NULL;
    UPROPERTY(ReplicatedUsing = OnRep_TentativeLockOnTarget)
    TWeakObjectPtr<AActor> TentativeLockOnTarget = NULL;
    UPROPERTY(ReplicatedUsing = OnRep_LockOnTarget)
    TWeakObjectPtr<AActor> LockOnTarget = NULL;
    UPROPERTY(Replicated)
    TWeakObjectPtr<AActor> AimTarget = NULL;
    UPROPERTY(Replicated)
    float MagnetismFalloff = 0.0f;
 
    TWeakObjectPtr<AActor> PreviousTarget = NULL;
    TWeakObjectPtr<AActor> PreviousTentativeTarget = NULL;
    float LockOnStrength = 0.f;
    FVector2D TightAimedProjectileMagnetismFalloffInRadians = FVector2D::ZeroVector;
    FVector2D ProjectileMagnetismFalloffInRadians = FVector2D::ZeroVector;
    FVector2D TightAimedProjectileMagnetismFalloffInRadiansGamepad = FVector2D::ZeroVector;
    FVector2D ProjectileMagnetismFalloffInRadiansGamepad = FVector2D::ZeroVector;
    float ProjectileAuthenticationMaxDistanceFromActorSquared = 500.0f * 500.0f;
private:
    /* Internal projectile ID counter for this weapon component. Should never be directly interacted with, use GetProjectileID() instead. */
    static int32 ProjectileIDCounter;
 
    friend class UTurretComponent;
    bool bWantsTick = false;
    uint16 ProjectileCounter = 0;
 
};