WeaponComponent.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2017. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "PlayerStructs.h"
#include "GameFramework/GameStateBase.h"
#include "WeaponComponent.generated.h"
 
class USkeletalMeshComponent;
class UWeaponInstance;
 
UENUM(BlueprintType)
enum class EWeaponError : uint8
{
    NoWeaponExists = 0,
    OutOfAmmo = 1,
    OnCoolDown = 2,
    NoFlashlight = 3,
    AlreadyReloading = 4,
    FullyLoaded = 5,
    CantFireWhileSwitchingWeapons = 6,
    NotReady = 7, //used by weapon instances, generically signifies the weapon is busy doing something that doesn't let it perform the requested action.
    AlreadyEquipped = 8,
    OutOfRange = 9,
    Overheated = 10,
    AltitudeTooLow = 11,
    OutOfEnergy = 12
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponRemovedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponAnimationSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponReloadSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponErrorSignature, EWeaponError, Error);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponAmmoChangeSignature, int32, Amount);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FReloadEventSignature, UWeaponComponent*, WeaponComponent);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDeployableSpawnedSignature, class ADeployable*, Deployable);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDeployableDestroyedSignature, class ADeployable*, Deployable);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FReticleVisibilityChangedSignature, bool, bVisible);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponAddedSignature, UWeaponInstance*, Weapon);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponEquippedSignature, UWeaponInstance*, Weapon);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponSkinsChangedSignature, UWeaponInstance*, Weapon);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLockOnSignature, class UWeaponInstanceProjectile*, Weapon);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponFireSignature, uint8, Mode);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FPersonalVehicleEventSignature, bool, bHold, float, HoldDuration);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FLockedOnSignature, class UWeaponInstanceProjectile*, Weapon, AActor*, Target);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FLockOnStrengthChangedSignature, class UWeaponInstanceProjectile*, Weapon, float, DeltaStrength);
 
UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class PROJECTX_API UWeaponComponent : public UActorComponent
{
    GENERATED_UCLASS_BODY()
 
public:
    UFUNCTION(BlueprintPure, Category = WeaponComponent)
    FORCEINLINE bool IsLocallyControlled() const { return GetController() && GetController()->IsLocalController(); }
 
    UFUNCTION(BlueprintPure, Category = WeaponComponent)
    FORCEINLINE bool IsHoldingAltFire() const { return bHoldingAltFire;}
 
    UFUNCTION(BlueprintPure, Category = WeaponComponent)
    FORCEINLINE bool IsHoldingFire() const { return bHoldingFire; }
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual bool UsesAmmo() const;
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual float GetMagAmmo() const;
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual float GetReserveAmmo() const;
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual bool IsSwitchingWeapons() const;
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    TArray<UWeaponInstance*> GetWeaponInventory() const;
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE UWeaponInstance* GetWeaponFromIndex(int32 Index) const { return WeaponInventory.IsValidIndex(Index) ? WeaponInventory[Index].Get() : NULL; }
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    UWeaponInstance* GetWeaponFromClass(TSubclassOf<UWeaponInstance> WeaponClass) const;
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE UWeaponInstance* GetWeaponFromSlot(EEquipSlot Slot) const { return WeaponInventory.IsValidIndex((uint8)Slot) ? WeaponInventory[(uint8)Slot].Get() : NULL; }
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    EEquipSlot GetSlotFromWeapon(const UWeaponInstance* const Weapon) const;
 
    UFUNCTION(BlueprintPure, Category = WeaponComponent)
    UCameraComponent* GetFirstPersonCamera() const { return FPCamera; }
    void UpdateFirstPersonCamera(UCameraComponent* CameraComponent);
 
    template <class T>
    T* GetWeaponFromClass() const { return Cast<T>(GetWeaponFromClass(T::StaticClass())); }
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    int32 GetWeaponIndex(UWeaponInstance* Weapon) const;
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE UWeaponInstance* GetCurrentWeapon() const { return EquippedWeapon.IsValid() ? EquippedWeapon.Get() : NULL; }
 
    UFUNCTION(BlueprintPure, Category = WeaponComponent)
    virtual float GetWeaponSpread() const;
    UFUNCTION(BlueprintPure, Category = WeaponComponent)
    virtual float GetReticleSpreadMultiplier() const;
 
    virtual bool CanPlayAnimations1P() const;
    virtual bool CanPlayAnimations3P() const;
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE USkeletalMeshComponent* GetMesh1P() const { return Mesh1P; }
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE USkeletalMeshComponent* GetMesh3P() const { return Mesh3P; }
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE USkeletalMeshComponent* GetWeaponMesh1P() const { return WeaponMesh1P; }
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE USkeletalMeshComponent* GetWeaponMesh3P() const { return WeaponMesh3P; }
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    FORCEINLINE bool IsCurrentWeapon(UWeaponInstance* Weapon) const { return GetCurrentWeapon() == Weapon; }
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual bool IsCurrentWeaponByClass(TSubclassOf<UWeaponInstance> Weapon) const;
    FORCEINLINE bool GetCanFire() { return bCanFire; }
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual float GetAmmoPickupMultiplier() const { return AmmoPickupMultiplier;}
    virtual void UpdateAmmoPickUpMultiplier(float NewPickupMultiplier) { AmmoPickupMultiplier = NewPickupMultiplier; }
 
    //This allows weapons to call the OnWeaponStartFire event locally to drive cosmetic changes on the weapon ABP
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual void CosmeticPrimaryFire() const { OnWeaponStartFire.Broadcast(0); }
 
    class AController* GetController() const;
    class ACharacter* GetPlayerCharacter() const;
 
    virtual void ChargedFire(uint8 Index);
    /* Run a check for fire buttons being held and if applicable, ask for a fire */
    virtual void FireIfAvailable();
 
    void UpdateCanFire(bool bNewCanFire);
 
public:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent);
 
    virtual void BeginPlay() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    UFUNCTION(BlueprintCallable)
    virtual UWeaponInstance* AddWeapon(TSubclassOf<UWeaponInstance> WeaponClass,EEquipSlot Slot, bool bIsPartOfBatch = false);
    virtual void RemoveWeapon(TSubclassOf<UWeaponInstance> WeaponClass);
    virtual void RemoveWeapon(UWeaponInstance* Weapon);
    virtual void ForceWeaponInventoryCheck();
    virtual void IncrementBlockSemaphore();
    virtual void DecrementBlockSemaphore();
 
    template<uint8 Index>
    void EquipWeapon();
 
    void EquipMelee();
    void EquipVehicle();
 
    virtual void RemoveAllWeapons();
    UFUNCTION()
    void WeaponAutoFire();
    UFUNCTION()
    virtual void StartVehicleAbility();
    UFUNCTION()
    virtual void StopVehicleAbility();
    UFUNCTION()
    virtual void UseVehicleAbility();
 
    //do not abuse this function. this should only be called by weapon instances attempted to manually perform weapon switching (eg attempting perform a queued weapon switch on their own).
    void SetPendingWeapon(UWeaponInstance* Weapon);
    UFUNCTION(Server, Reliable, WithValidation)
    virtual void Server_Reliable_SetPendingWeapon(UWeaponInstance* Weapon);
    UFUNCTION(BlueprintCallable)
    virtual void EquipWeapon(UWeaponInstance* Weapon, bool bCanUnequipExclusive = false, bool bForce = false);
 
    UFUNCTION()
    virtual void EquipPreviousWeapon(bool bCanUnequipExclusive = false);
    UFUNCTION()
    virtual void UnEquipComplete();
    UFUNCTION()
    virtual void OwnerDied();
    UFUNCTION()
    virtual void OnRep_WeaponInventory();
    UFUNCTION()
    virtual void OnFOVSettingChanged(const float Delta);
    virtual void ToggleWeaponActive(bool bNewActiveState, UWeaponInstance* WeaponClass);
 
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual void CancelWeaponActions();
    UFUNCTION(BlueprintCallable, Category = WeaponComponent)
    virtual void CancelInputConstrainedWeaponActions();
 
    UFUNCTION(BlueprintCallable, Category = "Damage")
    FORCEINLINE float GetDamageModifier() const { return DamageModifier; }
 
    void UpdateDamageModifier(float NewModifier); 
    void UpdateWeaponSpreadMultiplier(float NewMultiplier);
 
public:
    //We will keep these bindable events here so that listeners do not need to bind to every weapon.
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponAddedSignature OnWeaponAdded;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponRemovedSignature OnWeaponRemoved;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponEquippedSignature OnWeaponEquipped;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponSkinsChangedSignature OnWeaponSkinsChanged;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponErrorSignature OnWeaponError;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponAnimationSignature OnTightAimStart;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponAnimationSignature OnTightAimStop;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponAmmoChangeSignature OnAmmoChanged;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponAmmoChangeSignature OnAmmoReserveChanged;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FReloadEventSignature OnReloadStart;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FReloadEventSignature OnReloadStop;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponAnimationSignature OnFiringStart;
    UPROPERTY(BlueprintAssignable, Category = "Weapon Events")
    FWeaponAnimationSignature OnFiringStop;
 
    UPROPERTY(BlueprintAssignable)
    FDeployableSpawnedSignature OnDeployableSpawned;
    UPROPERTY(BlueprintAssignable)
    FDeployableDestroyedSignature OnDeployableDestroyed;
    
    UPROPERTY(BlueprintAssignable)
    FLockedOnSignature OnLockOnStart; 
    UPROPERTY(BlueprintAssignable)
    FLockedOnSignature OnLockedOn;
    UPROPERTY(BlueprintAssignable)
    FLockOnSignature OnLockOnLost;
    UPROPERTY(BlueprintAssignable)
    FLockOnSignature OnLockOnStopped;
    UPROPERTY(BlueprintAssignable)
    FLockOnStrengthChangedSignature OnLockOnStrengthChanged;
 
    UPROPERTY(BlueprintAssignable)
    FWeaponFireSignature OnWeaponStartFire;
    UPROPERTY(BlueprintAssignable)
    FWeaponFireSignature OnWeaponAutoFire;
    UPROPERTY(BlueprintAssignable)
    FWeaponFireSignature OnWeaponStopFire;
    UPROPERTY(BlueprintAssignable)
    FWeaponFireSignature OnWeaponChargedFire;
    UPROPERTY(BlueprintAssignable)
    FWeaponFireSignature OnWeaponShotFired;
    UPROPERTY(BlueprintAssignable)
    FWeaponReloadSignature OnWeaponReload;
    UPROPERTY(BlueprintAssignable)
    FPersonalVehicleEventSignature OnPersonalVehicleInputEvent;
 
    /* How long you would have to hold to trigger the vehicle*/
    UPROPERTY(EditDefaultsOnly,Category = Vehicle, Config)
    float PersonalVehicleHoldTriggerTimeDefault = 0.2;
    /* A curve that can be used to dynamically evaluate a forward offset for our arms mesh based on the current FOV */
    UPROPERTY(EditDefaultsOnly, Category = Jetpack = "Character|Camera")
    class UCurveFloat* FOVOffsetControlCurve = NULL;
    float FoundWeaponAmmoBonus = 0.0f;
 
    UFUNCTION(Server, Reliable, WithValidation)
    virtual void Server_Reliable_EquipWeapon(UWeaponInstance* Weapon, bool bCanUnequipExclusive = false);
 
    UFUNCTION()
    virtual void QuickWeaponSwitch();
    UFUNCTION()
    virtual void QuickWeaponSwitchPrevious();
    UFUNCTION()
    virtual void CycleWeapon(bool bReverse = false);
    UFUNCTION()
    virtual void OnRep_EquippedWeapon();
 
    template<int32 Index>
    void Fire() { Fire(Index); }
    void Fire(int32 Index);
 
    template<int32 Index>
    void FireReleased() { FireReleased(Index); }
    void FireReleased(int32 Index);
 
    void Reload();
 
    UPROPERTY(ReplicatedUsing = OnRep_EquippedWeapon)
    TWeakObjectPtr<UWeaponInstance> EquippedWeapon = NULL;
    UPROPERTY()
    TWeakObjectPtr<UWeaponInstance> PendingWeapon = NULL;
    UPROPERTY()
    TWeakObjectPtr<UWeaponInstance> PreviousWeapon = NULL;
    
    UPROPERTY(ReplicatedUsing = OnRep_WeaponInventory)
    TArray<TWeakObjectPtr<UWeaponInstance>> WeaponInventory;
 
    TArray<TWeakObjectPtr<UWeaponInstance>> PreviousInventory;
 
    UPROPERTY()
    USkeletalMeshComponent* Mesh1P;
    UPROPERTY()
    USkeletalMeshComponent* Mesh3P;
    UPROPERTY()
    USkeletalMeshComponent* WeaponMesh1P;
    UPROPERTY()
    USkeletalMeshComponent* WeaponMesh3P;
 
 
    UPROPERTY()
    class UCameraComponent* FPCamera;
 
    UPROPERTY()
    float DamageModifier = 1.0f;
    UPROPERTY()
    float AmmoPickupMultiplier = 1.0f;
    UPROPERTY()
    float WeaponSpreadMultiplier = 1.0f;
 
private:
    mutable AController* Controller;
    mutable ACharacter* PlayerCharacter;
 
    FTimerHandle PVHoldTimer;
 
    UPROPERTY(Replicated)
    bool bCanFire = true;
 
    bool bHoldingAltFire = false;
 
    bool bHoldingFire = false;
    /* In the case that we mis predict this value, the client might get locked out of doing input-based actions. Replicating it makes this safer to have as we don't have a lot of supporting systems when we mis predict some stuff to modify this locally.
       This value is currently only being manipulated on Equips/Unequips, and getting this out of sync won't probably happen, but it's 1 byte to be on the safe side and future-proof it */
    UPROPERTY(Replicated)
    uint8 InputBlockSemaphore = 0;
};