GlobalAmmoComponent.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "GameFramework/Actor.h"
#include "GlobalAmmoComponent.generated.h"
 
class APlayerState;
class UWeaponInstance;
 
//Globally held ammo for a weapon for persistance across pawns.
USTRUCT()
struct FGlobalWeaponAmmo
{
    GENERATED_USTRUCT_BODY()
 
    FGlobalWeaponAmmo(TSubclassOf<UWeaponInstance> InWeapon, float InAmmo, float Modifier = 1.0f)
    {
        Weapon = InWeapon;
        Ammo = InAmmo;
        RestockModifier = Modifier;
    }
 
    FGlobalWeaponAmmo()
    {
        Weapon = NULL;
        Ammo = 0.f;
    }
 
public:
    UPROPERTY()
    TSubclassOf<UWeaponInstance> Weapon = NULL;
 
    UPROPERTY()
    float Ammo = 0.f;
    UPROPERTY()
    float RestockTimerStart = -1.f;
    UPROPERTY()
    float RestockModifier = 0.0f;
 
public:
    bool IsEqualTo(const FGlobalWeaponAmmo& Other) const;
    bool HasEnoughAmmo(float Amount) const;
    bool ConsumeAmmo(float Amount, class UGlobalAmmoComponent* OwningComponent);
 
    void UpdateProgressAmmoRestock(class UGlobalAmmoComponent* OwningComponent);
 
    //Used by clients for when the server updates the onreps and the client thinks it's still restocking.
    void ClientCheckRestockTimer(class UGlobalAmmoComponent* OwningComponent);
 
    void StartRestockTimer(class UGlobalAmmoComponent* OwningComponent);
 
    bool operator==(const FGlobalWeaponAmmo& Other) const
    {
        return this->IsEqualTo(Other);
    }
 
    bool operator!=(const FGlobalWeaponAmmo& Other) const
    {
        return !(*this == Other);
    }
 
public:
    static FGlobalWeaponAmmo InvalidEntry;
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FGlobalAmmoChangedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FGlobalAmmoRestockTimerChangedSignature, TSubclassOf<UWeaponInstance>, Weapon, FTimerHandle, Timer);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FGlobalAmmoRestockCompleteSignature, TSubclassOf<UWeaponInstance>, Weapon, bool, bLastRestock);
 
UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class PROJECTX_API UGlobalAmmoComponent : public UActorComponent
{
    GENERATED_BODY()
 
    UGlobalAmmoComponent();
 
//~ Begin UActorComponent Interface
public:
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
//~ End UActorComponent Interface
 
public:
    UFUNCTION()
    virtual FGlobalWeaponAmmo& GetGlobalAmmoEntry(const UWeaponInstance* const Weapon);
 
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    virtual float GetGlobalWeaponAmmo(TSubclassOf<UWeaponInstance> Weapon) const;
 
    UFUNCTION(BlueprintCallable, Category = PlayerState)
    virtual float GetTimeUntilNextRestock(TSubclassOf<UWeaponInstance> Weapon) const;
 
    UFUNCTION()
    virtual void GlobalWeaponAmmoRestock(TSubclassOf<UWeaponInstance> Weapon);
    UFUNCTION()
    virtual void GlobalWeaponAmmoReset(TSubclassOf<UWeaponInstance> Weapon);
 
    TMap<TSubclassOf<UWeaponInstance>, FTimerHandle>& GetRestockTimerMap() { return GlobalAmmoTimerMap; }
    TMap<TSubclassOf<UWeaponInstance>, int32>& GetRestockInterpolatorMap() { return GlobalAmmoInterpolatorMap; }
 
    UFUNCTION()
    void ForceNetUpdate() { if (GetOwner()) { GetOwner()->ForceNetUpdate(); } }
 
    //Meant to run through APlayerState::OverrideWith and APlayerState::CopyProperties.
    virtual void OverrideWith(UGlobalAmmoComponent* GlobalAmmoComponent);
    virtual void CopyProperties(UGlobalAmmoComponent* GlobalAmmoComponent);
 
public:
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FGlobalAmmoChangedSignature OnGlobalAmmoChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FGlobalAmmoRestockTimerChangedSignature OnGlobalAmmoRestockTimerChanged;
    UPROPERTY(BlueprintAssignable, Category = PlayerState)
    FGlobalAmmoRestockCompleteSignature OnGlobalAmmoRestockComplete;
 
    void MarkGlobalAmmoDirty();
 
protected:
    friend struct FGlobalWeaponAmmo;
 
    /* List of weapons that have globally synchronized ammo */
    UPROPERTY(Replicated)
    TArray<FGlobalWeaponAmmo> GlobalAmmoList;
    UPROPERTY(ReplicatedUsing = OnRep_GlobalAmmoList)
    uint8 Counter = 0; // For some reason the array is not triggering the onreps, so we're using this instead
    TArray<FGlobalWeaponAmmo> PreviousGlobalAmmoList;
 
    TMap<TSubclassOf<UWeaponInstance>, FTimerHandle> GlobalAmmoTimerMap; //Global ammo timer handles kept separate to make it easier to manage prediction.
    TMap<TSubclassOf<UWeaponInstance>, int32> GlobalAmmoInterpolatorMap; //Global ammo timer handles kept separate to make it easier to manage prediction.
 
    UFUNCTION()
    virtual void OnRep_GlobalAmmoList();
};