WaveSpawner.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2022. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "ReactsToMatchEvents.h"
#include "SpawnInterface.h"
#include "Engine/DataTable.h"
#include "Engine/DataAsset.h"
#include "WeakInterfacePtr.h"
#include "WaveSpawner.generated.h"
 
class ULocalMessage;
class USoundCue;
class UAfflictionInstance;
class AProjectXSpawnerObjective;
 
USTRUCT(Blueprintable)
struct FWaveSpawnInfo
{
    GENERATED_USTRUCT_BODY()
 
    /* Drag as many spwners as you'd like to be activated for this wave. Only actors implementing ISpawnInterface can be used */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (MustImplement = "ISpawnInterface"))
    TArray<AActor*> SpawnersToActivate;
    /* If true, the system will track all enemies spawned and end the wave if all spawned ai have been killed. This feature will not work if any of your spawners are set to spawn indefinitely. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    bool bEndWaveIfAllEnemiesKilled = false;
    /* Should we respawn fallen AI? This will determine the group size to respawn them in. Example: If 4, the player would have to kill 4 enemies before they all respawn in one batch. 1 would spawn them 1 by 1. -1 will ignore this feature.*/
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    float RespawnGroupSize = INDEX_NONE;
    /* An optional delay which will occur the moment the player has killed "RespawnGroupSize" enemies in order to fill a shuttle. This wait time will be queued prior to respawning the AI. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    float RespawnDelay = 10.0f;
    /* Spaces out respawns by 'RespawnDelay' so that if 'RespawnDelay' were 10s, 3 respawns would take 10s, 20s and 30s rather than all spawning at once 10s later. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    bool bStaggeredRespawns = true;
    /* Should we end the wave if a certain number of enemies are killed? -1 will ignore this feature. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (EditCondition = "!bEndWaveIfAllEnemiesKilled"))
    float NumEnemiesKilledToEndWave = INDEX_NONE;
    /* Should we end the wave if a certain amount of time has expired? -1 will ignore this feature. Not compatible with "WaveFailureTime". This will take precedence if both are set. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    float TimeToEndWave = INDEX_NONE;
    /* Does this wave need a cooldown different than the standard one? Override here. -1 will ignore this feature */
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    float WaveCooldownOverride = INDEX_NONE;
    /* Should the game end in failure if the wave was not completed before this time ends? -1 will ignore this feature. Not compatible with "TimeToEndWave". "TimeToEndWave" will take precedence if both are set */
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    float WaveFailureTime = INDEX_NONE;
 
    // Spawners can destroy themselves, so we can't consider configuration data to be reliable data
    TArray<TWeakObjectPtr<AActor>> CachedSpawnerWeakPtrs;
    int32 CompletedSpawns = 0;
 
    bool IsWaveSpawningComplete() const { return CompletedSpawns >= SpawnersToActivate.Num(); }
};
 
UENUM(BlueprintType)
enum class EWaveSpawnerState : uint8
{
    Idle = 0,
    Spawning = 1,
    InProgress = 2,
    CoolingDown = 3,
    Completed = 4,
    Invalid = 255
};
 
UENUM(BlueprintType)
enum class EWaveTimerType : uint8
{
    NONE = 0,
    Survive = 1,
    Cooldown = 2,
    ObjectiveTime = 3
};
 
USTRUCT(BlueprintType)
struct FWaveStateInfo
{
    GENERATED_USTRUCT_BODY()
    FWaveStateInfo(){}
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Customization)
    USoundCue* WaveCue = NULL;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Customization)
    FString AnnouncerVoiceToPlay = "";
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Customization)
    FText WaveNarrativeMessage;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Customization)
    FText WaveMessage;
};
 
USTRUCT(BlueprintType)
struct PROJECTX_API FWaveData : public FTableRowBase
{
    GENERATED_BODY()
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Customization)
    TMap<EWaveSpawnerState, FWaveStateInfo> WaveDisplayInfo;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Customization)
    bool bDisplayKillProgress = false;
    UPROPERTY(EditAnywhere,BlueprintReadWrite, Category = Cusomtization)
    FText KillDescriptionText;
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWaveSpawnerWaveStartedSignature, AWaveSpawner* const, WaveSpawner);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FWaveSpawnerCompletedSignature, AWaveSpawner* const, WaveSpawner, bool, bSuccess);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FWaveSpawnerMobDefeatedSignature, AWaveSpawner* const, WaveSpawner, int32, DefeatedMobCount);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FWaveSpawnerMobCountUpdatedSignature, AWaveSpawner* const, WaveSpawner, int32, TotalMobCount, int32, DefeatedMobCount);
 
UCLASS()
class PROJECTX_API AWaveSpawner : public AActor, public IReactsToMatchEvents, public ISpawnInterface
{
    GENERATED_BODY()
    
public: 
    /* Run when the match starts, if false, the spawner will begin spawning actors immediately. */
    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta = (EditCondition = "!bExecutesOnBeginPlay"))
    bool bExecuteOnMatchStart = true;
    /* Run when the map loads, if false, the spawner will begin spawning actors immediately. */
    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta = (EditCondition = "!bExecuteOnMatchStart"))
    bool bExecutesOnBeginPlay = false;
    /* Time to wait before beginning the wave */
    UPROPERTY(BlueprintReadWrite, EditAnywhere)
    float StartTimeDelay = 0.0f;
    /* Amount of time for a wave to cooldown after completion before begining the next wave */
    UPROPERTY(BlueprintReadWrite, EditAnywhere)
    float WaveCooldownTime = 15.0f;
    /* Should the match end in victory if all waves have been completed? */
    UPROPERTY(BlueprintReadWrite, EditAnywhere)
    bool bEndGameWithVictoryIfAllWavesCompleted = false;
    /* What vehicle should be used to deliver respawned actors? */
    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta = (MustImplement = "ISpawnInterface"))
    TSubclassOf<AActor> RespawnActor = nullptr;
    /* What team is the enemy ai on? This is used for victory/fail conditions. You will still want to set teams on your ai spawners. */
    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta = (EditCondition = "bDebug"))
    int32 EnemyTeam = 99;
    /* Should we print information about what the spawnwer is doing for debug purposes? */
    UPROPERTY(BlueprintReadWrite, EditAnywhere)
    bool bDebug = false;
    /* This can get spammy, but is useful for tracking more details about the spawner */
    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta = (EditCondition = "bDebug"))
    bool bVerboseDebug = false;
    /* Wave definitions containing information on how each wave should execute */
    UPROPERTY(BlueprintReadWrite, EditAnywhere)
    TArray<FWaveSpawnInfo> Waves;
    /* is this the game modes primary wave spawner, one of them in the level needs to be*/
    UPROPERTY(BlueprintReadWrite, EditAnywhere)
    bool bPrimarySpawner = false;
    UPROPERTY(BlueprintReadOnly)
    float SurviveTimeMultiplier = 1.0f;
    UPROPERTY(BlueprintReadOnly)
    float WaveFailureTimeMultiplier = 1.0f;
 
    AWaveSpawner();
 
    UFUNCTION(BlueprintPure)
    FORCEINLINE int32 GetCurrentWave() const { return CurrentWave; }
    UFUNCTION(BlueprintPure)
    FORCEINLINE int32 GetTotalWaves() const { return Waves.Num(); }
    UFUNCTION(BlueprintPure)
    FORCEINLINE int32 GetTotalKills() const { return TotalMobsKilled; }
    UFUNCTION(BlueprintPure)
    FORCEINLINE float GetWaveProgress() const { return (float)GetCurrentWave() / (float)GetTotalWaves(); }
    UFUNCTION(BlueprintPure)
    FORCEINLINE EWaveSpawnerState GetWaveSpawnerState() const { return SpawningState; };
    UFUNCTION(BlueprintPure)
    FORCEINLINE bool IsADefeatEnemyWave(int32 Wave) const {return Waves.IsValidIndex(Wave) ? Waves[Wave].bEndWaveIfAllEnemiesKilled : false;}
    UFUNCTION(BlueprintPure)
    int32 GetNumberOfEnemiesNeededToProgress(int32 Wave) const;
    UFUNCTION(BlueprintCallable)
    virtual void SpawnWave();
    UFUNCTION(BlueprintCallable)
    virtual void EndWave();
    
    UFUNCTION(BlueprintPure)
    static void GetWaveSpawnerStateFromPackedInt(const int32 Data, int32& Wave, EWaveSpawnerState& State);
 
    void RegisterActiveObjective(AProjectXSpawnerObjective* const Objective);
    virtual int32 GetPackedWaveState();
    virtual void SetWaveSpawnerState(const EWaveSpawnerState NewState);
    virtual void BroadcastWaveStateToPlayer(APlayerController* const SpecificPlayer);
    virtual void NextWave();
    virtual void BeginSpawning_Implementation() override;
    virtual void MatchStarted() override;
    virtual void BeginPlay() override;
    virtual bool ImplementsSpawnCompleteCallback() const override { return true; }
    virtual void RespawnMobs(const FVector Location, TArray<TSubclassOf<AActor>> MobList);
    virtual void CancelRespawns();
    virtual void GameOver(const bool bVictory);
    virtual int32 GetPlayerTeam() const;
    virtual void WipeMobs();
    bool HasWaveBeenDefeated() const;
    bool EnemiesRemainingToEndWave() const;
 
    UFUNCTION()
    void RespawnerFinsished(AActor* Actor, EEndPlayReason::Type EndPlayReason);
    UFUNCTION()
    void EventComplete(bool bSuccess);
    UFUNCTION()
    void OnMobSpawned(AProjectXCharacter* SpawnedPlayerState);
    UFUNCTION()
    void OnMobDestroyed(AProjectXCharacter* SpawnedPlayerState, FVector SpawnLocation);
    UFUNCTION()
    void OnSpawnerCompleted(UObject* Spawner);
    void ApplyWaveAffliction();
    UPROPERTY(BlueprintAssignable)
    FWaveSpawnerCompletedSignature OnWaveSpawnerEventsCompletedEvent;
    UPROPERTY(BlueprintAssignable)
    FWaveSpawnerCompletedSignature OnWaveCompletedEvent;
    UPROPERTY(BlueprintAssignable)
    FWaveSpawnerWaveStartedSignature OnWaveStartedEvent;
    UPROPERTY(BlueprintAssignable)
    FWaveSpawnerMobDefeatedSignature OnMobsDefeatedEvent;
    UPROPERTY(BlueprintAssignable)
    FWaveSpawnerCompletedSignature OnTimedWaveCompletedEvent;
    UPROPERTY(BlueprintAssignable)
    FWaveSpawnerMobCountUpdatedSignature OnMobCountUpdatedSignature;
    UPROPERTY(BlueprintAssignable)
    FWaveSpawnerWaveStartedSignature OnWaveProgress;
 
protected:
    /* Affliction to be applied to enemies that are spawned*/
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TSubclassOf<UAfflictionInstance> SpawnedCharacterAffliction = NULL;
    /* at what percentage of the wave being killed will it trigger this affliction*/
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    float CharacterAfflictionTriggerPercentage = 0.5f;
 
private:
    EWaveSpawnerState SpawningState = EWaveSpawnerState::Idle;
    int32 CurrentWave = 0;
    int32 TotalMobsKilled = 0;
    int32 TotalMobsSpawned = 0;
    bool bAppliedWaveAffliction = false;
    TArray<TWeakObjectPtr<AActor>> ActiveRespawners;
    TArray<TSubclassOf<AActor>> MobRespawnList;
    TWeakObjectPtr< AProjectXSpawnerObjective> ActiveObjective = NULL;
    TArray<TWeakObjectPtr<AProjectXCharacter>> SpawnedCharacters = TArray<TWeakObjectPtr<AProjectXCharacter>>();
    uint32 QueuedRespawns = 0;
};