SquadComponent.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 "SquadComponent.generated.h"
 
class APlayerController;
class AProjectXPlayerController;
class AProjectXPlayerStateTeam;
 
USTRUCT(BlueprintType)
struct FSquadInstance
{
    GENERATED_BODY()
 
    FSquadInstance()
    {
        SquadID = INDEX_NONE;
    }
 
    FSquadInstance(uint8 InTeam)
    {
        Team = InTeam;
        SquadID = SquadIDCounter;
        SquadIDCounter++;
    }
 
    bool operator==(const FSquadInstance& Other) const
    {
        return SquadID != INDEX_NONE && SquadID == Other.SquadID;
    }
 
    bool operator!() const
    {
        return SquadID == INDEX_NONE;
    }
 
    operator bool()
    {
        return SquadID != INDEX_NONE;
    }
 
    //Returns true if this squad is now empty.
    bool Cleanup();
    bool HasAlivePlayers();
    bool IsInvalid();
    bool CanJoin(AProjectXPlayerState* Player);
    void ForceOnRepUpdate();
    void AddPlayer(AProjectXPlayerState* NewPlayer);
    void RemovePlayer(AProjectXPlayerState* Player);
    bool IsEmpty();
 
public:
    UPROPERTY()
    int32 SquadID = INDEX_NONE;
 
    UPROPERTY()
    uint8 Team = MAX_uint8;
 
    UPROPERTY()
    TArray<TWeakObjectPtr<AProjectXPlayerState>> PlayerList = TArray<TWeakObjectPtr<AProjectXPlayerState>>();
 
    static int32 SquadIDCounter;
 
    UPROPERTY()
    uint8 UpdateCounter = 0;
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FSquadListUpdateSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FSquadUpdateSignature, int32, SquadID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FSquadMemberUpdateSignature, int32, SquadID, AProjectXPlayerState*, PlayerState);
 
UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class PROJECTX_API USquadComponent : public UActorComponent
{
    GENERATED_UCLASS_BODY()
 
//~ Begin UActorComponent Interface
protected:
    virtual void BeginPlay() override;
//~ End UActorComponent Interface
    
public:
    UFUNCTION(BlueprintCallable, Category = SquadComponent)
    FORCEINLINE int32 GetSquadCount() const { return SquadCount; }
    UFUNCTION(BlueprintCallable, Category = SquadComponent)
    FORCEINLINE int32 GetMaxSquadSize() const { return MaxSquadSize; }
    UFUNCTION(BlueprintCallable, Category = SquadComponent)
    void GetSquadList(TArray<FSquadInstance>& OutSquadList) const;
    UFUNCTION(BlueprintCallable, Category = SquadComponent)
    void GetSquadListForTeam(TArray<FSquadInstance>& OutSquadList, uint8 Team) const;
    UFUNCTION(BlueprintPure, Category = SquadComponent, meta = (DisplayName = "Get Squad By ID", ScriptName = "GetSquadByID"))
    void K2_GetSquadByID(int32 SquadID, FSquadInstance& Squad);
    UFUNCTION(BlueprintPure, Category = SquadComponent, meta = (DisplayName = "Get Squad By Player", ScriptName = "GetSquadByPlayer"))
    bool K2_GetSquadByPlayer(AProjectXPlayerState* Player, FSquadInstance& Squad);
    UFUNCTION(BlueprintPure, Category = SquadComponent)
    virtual bool IsInSameSquad(const AProjectXPlayerState* PlayerStateA, const AProjectXPlayerState* PlayerStateB);
 
    virtual void AutoAssignSquad(AProjectXPlayerState* Player);
 
    UFUNCTION(BlueprintCallable, Category = SquadComponent)
    virtual bool JoinSquad(AProjectXPlayerState* Player, int32 SquadID);
    UFUNCTION(BlueprintCallable, Category = SquadComponent, meta = (DisplayName = "Can Join Squad", ScriptName = "CanJoinSquad"))
    bool K2_CanJoinSquad(AProjectXPlayerState* Player, int32 SquadID);
 
    virtual bool CanJoinSquad(AProjectXPlayerState* Player, FSquadInstance* Squad) const;
 
    virtual void LeaveSquad(AProjectXPlayerState* Player);
 
    virtual FSquadInstance* GetSquadByID(int32 SquadID);
    virtual FSquadInstance* GetSquadByPlayer(const AProjectXPlayerState* Player);
    
    UFUNCTION(BlueprintCallable, Category = SquadComponent)
    virtual AProjectXPlayerState* GetSquadLeaderByID(int32 SquadID);
 
    virtual void CleanupSquads();
 
    virtual void TryJoinSquadVoiceChannel(TWeakObjectPtr<AProjectXPlayerState> NewSquadMember, int32 TeamID, int32 SquadID);
 
public:
    //Called when the size of the squad list changes.
    UPROPERTY(BlueprintAssignable)
    FSquadListUpdateSignature OnSquadListChanged;
    //Called each time a squad's member list changes.
    UPROPERTY(BlueprintAssignable)
    FSquadUpdateSignature OnSquadChanged;
    //Called each time a user joins or leaves a squad.
    UPROPERTY(BlueprintAssignable)
    FSquadMemberUpdateSignature OnSquadMemberAdded;
    UPROPERTY(BlueprintAssignable)
    FSquadMemberUpdateSignature OnSquadMemberRemoved;
 
protected:
    UFUNCTION()
    virtual void OnRep_SquadList();
    UFUNCTION()
    virtual void PlayerJoinGame(AProjectXPlayerState* Player, const FString& JoinTarget);
    UFUNCTION()
    virtual void OnPlayerStateRemoved(APlayerState* PlayerState);
 
protected:
    UPROPERTY(ReplicatedUsing = OnRep_SquadList)
    TArray<FSquadInstance> SquadList;
 
    TArray<FSquadInstance> CachedSquadList;
    int32 VoiceChatSalt = 0;
    FString NetAddress = "";
 
    TMap<int32, int32> CachedSquadIDMap;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
    uint8 MaxSquadSize = 5;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Replicated)
    uint8 SquadCount = 6;
 
public:
    UFUNCTION(BlueprintPure, Category = SquadComponent, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static USquadComponent* GetSquadComponent(const UObject* WorldContextObject);
    UFUNCTION(BlueprintPure, Category = SquadComponent)
    static bool GetSquadInfo(const FSquadInstance& Squad, uint8& Team, int32& ID, TArray<AProjectXPlayerState*>& PlayerList);
    UFUNCTION(BlueprintPure, Category = SquadComponent)
    static bool AreSquadsEqual(const FSquadInstance& OldSquad, const FSquadInstance& NewSquad);
};