AOnlineGameMode Class Reference

#include <OnlineGameMode.h>

Inheritance diagram for AOnlineGameMode:

Public Member Functions
	AOnlineGameMode ()
void	UpdateScore ()
virtual void	UpdatePlayerList ()
virtual void	SpawnPlayer (APlayerController *PlayerController)

Public Attributes
float	UpdatePlayerListDelay = 0.3f

Protected Member Functions
virtual void	BeginPlay () override
virtual void	GenericPlayerInitialization (AController *Controller) override
virtual void	PostLogin (APlayerController *NewPlayer) override
virtual void	Logout (AController *Exiting) override
virtual void	SwapPlayerControllers (APlayerController *OldPC, APlayerController *NewPC) override
virtual void	RegisterPlayer (APlayerController *NewPlayer)
int32	GetTotalNumberOfControllers () const
virtual void	AddPlayerToTeam (APlayerController *PlayerController)
virtual FMatchState	GetMultiplayerMatchState () const override
void	DestroyPawn (APawn *Pawn) const
virtual void	SpawnedPlayerDeath (FPlayerDeath &PlayerDeath, APawn *PawnThatDied)
virtual void	SpawnedAIDeath (FPlayerDeath &PlayerDeath, APawn *PawnThatDied)
void	OnPlayerDeath (const FPlayerDeath &PlayerDeath)
void	OnAIDeath (const FPlayerDeath &PlayerDeath)
TArray< FPlayerDeath > &	GetAllPlayerDeaths ()
TArray< FPlayerDeath > &	GetAllAIDeaths ()
virtual void	PreMatch ()
virtual void	ReadyMatch ()
virtual void	StartMatch () override
virtual void	EndMatch () override
virtual void	MatchCountdown ()
virtual bool	ReadyToStartMatch_Implementation () override
void	OnPreMatch ()
void	OnReadyMatch ()
void	OnStartMatch ()
void	OnEndMatch ()
void	OnMatchCountdown ()
virtual void	SetEndMatchCondition ()
virtual bool	GetIsMatchOver ()
virtual void	UpdateGameState ()
FTransform	FindRandomPlayerStart () const
FTransform	FindRandomAIPlayerStart () const
FTransform	FindTeamPlayerStart (const int32 TeamID)
void	LogMissingPointer (const FString &PointerName) const
void	LogDebugError (const FString &Message) const
void	LogDebugWarning (const FString &Message) const
void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const

Protected Attributes
TArray< APlayerController * >	AllPlayerControllers
TMap< int32, TArray< APlayerController * > >	TeamPlayerControllers
TArray< FPlayerDeath >	AllPlayerDeaths
TArray< FPlayerDeath >	AllAIDeaths
TArray< FPlayerDeath >	AllDeaths
int32	NumberOfTeams = 2
TMap< int32, int32 >	TeamScores
TArray< int32 >	TeamIDs
bool	bFriendlyFireOn = true
FString	AISpawnTag = "AI"
int32	RespawnTime = 3
int32	SelfDeathRespawnTimeMultiplier = 2
int32	TeamKillDeathRespawnTimeMultiplier = 3
bool	bMatchTimed = false
bool	bMatchCountUp = false
bool	bMatchTimeLimit = false
int32	MatchTime = 20
int32	MatchTimeLimit = 120
bool	bTeamSpawns = true
bool	bMatchOver = false
EMultiplayerMode	MultiplayerMode = EMultiplayerMode::Default
bool	bDisableStartTimers = false
int32	PreMatchWaitTime = 5
float	MatchUpdateFrequency = 1.0f
int32	ReadyMatchWaitTime = 10
TArray< AActor * >	PlayerStarts
TArray< AActor * >	AIPlayerStarts
TMap< int32, int32 >	LastUsedPlayerStart
int32	NumberOfPlayersToStart = 4
TMap< int32, TArray< APlayerStart * > >	TeamStarts
bool	bDebuggingMode = false
bool	bLogPlayerStarts = false
bool	bLogMatchTime = false
bool	bLogMatchState = false
class IOnlineGS *	OnlineGameState = nullptr

Private Member Functions
AActor *	FindBestPlayerStart (TArray< AActor * > Starts) const
void	GetAllPlayerStarts ()
void	ResetTeamScores ()

Private Attributes
FMatchState	MultiplayerMatchState
FTimerHandle	PreMatchTimerHandle
FTimerHandle	ReadyMatchTimerHandle
FTimerHandle	MatchTimerHandle
FTimerHandle	UpdatePlayerListTimerHandle
bool	bEndMatchCondition = false

Constructor & Destructor Documentation

AOnlineGameMode()

AOnlineGameMode::AOnlineGameMode

(

)

{
    
}

Member Function Documentation

AddPlayerToTeam()

void AOnlineGameMode::AddPlayerToTeam ( APlayerController * PlayerController )

protectedvirtual

Old Way used for only 2 Teams

{
    if(PlayerController == nullptr){return;}
    for (int32 TeamID = 1; TeamID <= NumberOfTeams; ++TeamID)
    {
        TeamPlayerControllers.FindOrAdd(TeamID);
    }
    // Find the team with the least number of players
    int32 TeamWithLeastPlayers = 1;
    int32 LeastNumberOfPlayers = MAX_int32;
    for (const auto& Team : TeamPlayerControllers)
    {
        if (Team.Value.Num() < LeastNumberOfPlayers)
        {
            LeastNumberOfPlayers = Team.Value.Num();
            TeamWithLeastPlayers = Team.Key;
        }
    }
    // Add the player to the team with the least number of players
    TeamPlayerControllers[TeamWithLeastPlayers].Add(PlayerController);
    // Set the team ID in the generic team agent interface
    IGenericTeamAgentInterface* TeamAgentInterface = Cast<IGenericTeamAgentInterface>(PlayerController->PlayerState);
    if (TeamAgentInterface != nullptr)
    {
        TeamAgentInterface->SetGenericTeamId(FGenericTeamId(TeamWithLeastPlayers));
    }
    // Add the team ID to the list of team IDs (if not already present)
    TeamIDs.AddUnique(TeamWithLeastPlayers);
    
    // if(TeamAPlayerController.Num() == 0 || TeamAPlayerController.Num() < TeamBPlayerController.Num())
    // {
    //  TeamAPlayerController.Add(PlayerController);
    //  IGenericTeamAgentInterface* TeamAgentInterface = Cast<IGenericTeamAgentInterface>(PlayerController->PlayerState);
    //  if(TeamAgentInterface != nullptr)
    //  {
    //      TeamAgentInterface->SetGenericTeamId(10);
    //  }
    //  TeamIDs.AddUnique(10);
    // }
    // else
    // {
    //  TeamBPlayerController.Add(PlayerController);
    //  IGenericTeamAgentInterface* TeamAgentInterface = Cast<IGenericTeamAgentInterface>(PlayerController->PlayerState);
    //  if(TeamAgentInterface != nullptr)
    //  {
    //      TeamAgentInterface->SetGenericTeamId(20);
    //  }
    //  TeamIDs.AddUnique(20);
    // }
}

BeginPlay()

void AOnlineGameMode::BeginPlay ( )

overrideprotectedvirtual

Reimplemented in ACampaignGameMode, AMultiplayerGameMode, AMultiplayerHordeGameMode, and AQuestExampleGameMode.

{
    Super::BeginPlay();
    GetAllPlayerStarts();
    if(bDisableStartTimers)
    {
        PreMatchWaitTime = 0;   
        ReadyMatchWaitTime = 0;
    }
    MultiplayerMatchState.MatchState = EMatchState::PreMatch;
    UpdateGameState();
    GetWorld()->GetTimerManager().SetTimer(PreMatchTimerHandle, this, &AOnlineGameMode::PreMatch, MatchUpdateFrequency, true, 0.0f);
}

DestroyPawn()

void AOnlineGameMode::DestroyPawn ( APawn * Pawn ) const

protected

{
    TArray<AActor*> PawnAttachedActors;
    Pawn->GetAttachedActors(PawnAttachedActors, true);
    for(AActor* AttachedActor : PawnAttachedActors)
    {
        AttachedActor->Destroy(true);
    }
    Pawn->Destroy(true);
}

EndMatch()

void AOnlineGameMode::EndMatch ( )

overrideprotectedvirtual

Condition Met to finish match

Reimplemented in AMultiplayerGameMode.

{
    bMatchOver = true;
    GetWorld()->GetTimerManager().ClearTimer(MatchTimerHandle);
    MultiplayerMatchState.MatchState = EMatchState::PostMatch;
    MultiplayerMatchState.TimeRemaining = 0;
    if(bDebuggingMode && bLogMatchState){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::EndMatch Match OVER"));}
    UpdateGameState();
    if(OnlineGameState != nullptr)
    {
        OnlineGameState->MatchOver();
    }
    OnEndMatch();
    Super::EndMatch();
}

FindBestPlayerStart()

AActor * AOnlineGameMode::FindBestPlayerStart ( TArray< AActor * > Starts ) const

private

{
    if(Starts.IsEmpty()){return nullptr;}
    const APawn* PawnToFit = DefaultPawnClass ? DefaultPawnClass->GetDefaultObject<APawn>() : nullptr;
    TArray<AActor*> UnOccupiedStartPoints;
    TArray<AActor*> OccupiedStartPoints;
 
    if(bDebuggingMode && bLogPlayerStarts){UE_LOG(LogOnlineGameMode, Warning, TEXT("Random Player Start"));}
    //- Go through all player starts, and try see if Pawn will fit  //
    for(const auto& PlayerStart : Starts)
    {
        FVector ActorLocation = PlayerStart->GetActorLocation();
        const FRotator ActorRotation = PlayerStart->GetActorRotation();
        if(!GetWorld()->EncroachingBlockingGeometry(PawnToFit, ActorLocation, ActorRotation))
        {
            UnOccupiedStartPoints.Add(PlayerStart);
        }
        else if (GetWorld()->FindTeleportSpot(PawnToFit, ActorLocation, ActorRotation))
        {
            OccupiedStartPoints.Add(PlayerStart);
        }
    }
    if(UnOccupiedStartPoints.Num() > 0)
    {
        return UnOccupiedStartPoints[FMath::RandRange(0, UnOccupiedStartPoints.Num() - 1)];
    }
    if(OccupiedStartPoints.Num() > 0)
    {
        return OccupiedStartPoints[FMath::RandRange(0, OccupiedStartPoints.Num() - 1)];
    }
    return Starts[FMath::RandRange(0, Starts.Num() - 1)];
}

FindRandomAIPlayerStart()

FTransform AOnlineGameMode::FindRandomAIPlayerStart ( ) const

protected

{
    if(PlayerStarts.Num() == 0 || AIPlayerStarts.Num() == 0)
    {
        if(bDebuggingMode && bLogPlayerStarts){UE_LOG(LogOnlineGameMode, Error, TEXT("No Player Starts & No AI Player Starts in AI Player Starts"));}
        return FindRandomPlayerStart();
    }
    const AActor* BestStart = FindBestPlayerStart(AIPlayerStarts);
    if(BestStart == nullptr)
    {
        if(bDebuggingMode && bLogPlayerStarts){UE_LOG(LogOnlineGameMode, Error, TEXT("No AIPlayerStarts Player Starts Found"));}
        return FTransform(FQuat(FRotator::ZeroRotator), FVector::ZeroVector, FVector(1,1,1));
    }
    return BestStart->GetActorTransform();
}

FindRandomPlayerStart()

FTransform AOnlineGameMode::FindRandomPlayerStart ( ) const

protected

{
    if(PlayerStarts.Num() == 0)
    {
        if(bDebuggingMode && bLogPlayerStarts){UE_LOG(LogOnlineGameMode, Error, TEXT("No Player Starts Found"));}
        return FTransform(FQuat(FRotator::ZeroRotator), FVector::ZeroVector, FVector(1,1,1));
    }
    const AActor* BestStart = FindBestPlayerStart(PlayerStarts);
    if(BestStart == nullptr)
    {
        if(bDebuggingMode && bLogPlayerStarts){UE_LOG(LogOnlineGameMode, Error, TEXT("No Player Starts Found"));}
        return FTransform(FQuat(FRotator::ZeroRotator), FVector::ZeroVector, FVector(1,1,1));
    }
    return BestStart->GetActorTransform();
}

FindTeamPlayerStart()

FTransform AOnlineGameMode::FindTeamPlayerStart ( const int32 TeamID )

protected

{
    if(!TeamStarts.Contains(TeamID) || TeamStarts[TeamID].Num() == 0)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Warning, TEXT("No player starts for this team"));}
        //- Handle error - no player start for this team.
        return FindRandomPlayerStart();
    }
    //- If the team hasn't spawned anyone yet, initialize the last used index
    if(!LastUsedPlayerStart.Contains(TeamID))
    {
        LastUsedPlayerStart.Add(TeamID, -1);
    }
 
    //- Get the last used index for this team
    int32& LastUsedIndex = LastUsedPlayerStart[TeamID];
 
    //- Cycle to the next player start
    LastUsedIndex = (LastUsedIndex + 1) % TeamStarts[TeamID].Num();
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Warning, TEXT("TEAM PLAYER START"));}
    return TeamStarts[TeamID][LastUsedIndex]->GetTransform();
}

GenericPlayerInitialization()

void AOnlineGameMode::GenericPlayerInitialization ( AController * Controller )

overrideprotectedvirtual

{
    Super::GenericPlayerInitialization(Controller);
    APlayerController* NewPlayer = Cast<APlayerController>(Controller);
    if(NewPlayer == nullptr){return;}
    AllPlayerControllers.AddUnique(NewPlayer);
    AddPlayerToTeam(NewPlayer);
    RegisterPlayer(NewPlayer);
    GetWorld()->GetTimerManager().SetTimer(UpdatePlayerListTimerHandle, this, &AOnlineGameMode::UpdatePlayerList, UpdatePlayerListDelay);
}

GetAllAIDeaths()

TArray< FPlayerDeath > & AOnlineGameMode::GetAllAIDeaths ( )

inlineprotected

{return AllAIDeaths;};

GetAllPlayerDeaths()

TArray< FPlayerDeath > & AOnlineGameMode::GetAllPlayerDeaths ( )

inlineprotected

{return AllPlayerDeaths;};

GetAllPlayerStarts()

void AOnlineGameMode::GetAllPlayerStarts ( )

private

{
    UGameplayStatics::GetAllActorsOfClass(GetWorld(), APlayerStart::StaticClass(), PlayerStarts);
    for(AActor* PlayerStartActor: PlayerStarts)
    {
        APlayerStart* PlayerStart = Cast<APlayerStart>(PlayerStartActor);
        if(PlayerStart != nullptr)
        {
            if (PlayerStart->PlayerStartTag.ToString().Equals(AISpawnTag))
            {
                AIPlayerStarts.Add(PlayerStart);
                continue;
            }
            int32 ExtractedTeamID = FCString::Atoi(*PlayerStart->PlayerStartTag.ToString());
            if(!TeamStarts.Contains(ExtractedTeamID))
            {
                TeamStarts.Add(ExtractedTeamID, TArray<APlayerStart*>());
                if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::GetAllPlayerStarts TeamStarts Doesn't contain TEAM ID"));}
            }
            TeamStarts[ExtractedTeamID].Add(PlayerStart);
            if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::GetAllPlayerStarts Team: %i has: %i Starts"), ExtractedTeamID, TeamStarts[ExtractedTeamID].Num());}
        }
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::GetAllPlayerStarts AI Player Starts: %i"), AIPlayerStarts.Num());}
}

GetIsMatchOver()

virtual bool AOnlineGameMode::GetIsMatchOver ( )

inlineprotectedvirtual

{return bEndMatchCondition;};

GetMultiplayerMatchState()

FMatchState AOnlineGameMode::GetMultiplayerMatchState ( ) const

overrideprotectedvirtual

Implements IOnlineGM.

{
    return MultiplayerMatchState;
}

GetTotalNumberOfControllers()

int32 AOnlineGameMode::GetTotalNumberOfControllers ( ) const

protected

{
    int32 NumberOfPCInTeams = 0;
    for(auto& Element : TeamPlayerControllers)
    {
        Element.Key;
        NumberOfPCInTeams++;
    }
    if(AllPlayerControllers.Num() == NumberOfPCInTeams)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Error,TEXT("Total Players doesn't add up: %i, Teams: %i"), AllPlayerControllers.Num(), NumberOfPCInTeams);}
    }
    // if(AllPlayerControllers.Num() == TeamAPlayerController.Num() + TeamBPlayerController.Num())
    // {
    //  UE_LOG(LogOnlineGameMode,Error,TEXT("Total Players doesn't add up: %i, TeamA: %i TeamB %i"), AllPlayerControllers.Num(), TeamAPlayerController.Num(), TeamBPlayerController.Num());
    // }
    return AllPlayerControllers.Num();
}

LogDebugError()

void AOnlineGameMode::LogDebugError ( const FString & Message ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AOnlineGameMode::LogDebugError);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_GameMode);
    LogDebugMessage(Message, true, true);
}

LogDebugMessage()

void AOnlineGameMode::LogDebugMessage ( const FString & Message, const bool bWarning = false, const bool bError = false ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(UPlayerControllerComponent::LogDebugMessage);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_GameMode);
    if(bDebuggingMode == false && bError == false){return;}
    FOutputDevice* OutputDevice = GWarn;
    if(OutputDevice == nullptr){return;}
    FString NetModeString;
    switch(GetWorld()->GetNetMode())
    {
    case NM_Standalone:
        NetModeString = FString("SDL");
        break;
    case NM_DedicatedServer:
        NetModeString = FString("DServer");
        break;
    case NM_ListenServer:
        NetModeString = FString("LServer");
        break;
    case NM_Client:
        NetModeString = FString("Client");
        break;
    default:
        NetModeString = FString("Unknown");
        break;
    }
    const FString FullMessage = FString::Printf(TEXT("%s: %s::%s"), *NetModeString, *GetName(), *Message);
    if(bError)
    {
        OutputDevice->Log(LogOnlineGameMode.GetCategoryName(), ELogVerbosity::Error, FullMessage);
    }
    else if(bWarning)
    {
        OutputDevice->Log(LogOnlineGameMode.GetCategoryName(), ELogVerbosity::Warning, FullMessage);
    }
    else
    {
        OutputDevice->Log(LogOnlineGameMode.GetCategoryName(), ELogVerbosity::Log, FullMessage);
    }
}

LogDebugWarning()

void AOnlineGameMode::LogDebugWarning ( const FString & Message ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AOnlineGameMode::LogDebugWarning);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_GameMode);
    LogDebugMessage(Message, true);
}

LogMissingPointer()

void AOnlineGameMode::LogMissingPointer ( const FString & PointerName ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AOnlineGameMode::LogMissingPointer);
    SCOPE_CYCLE_COUNTER(STATGROUP_BaseHelpers_GameMode);
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Error, TEXT(" %s not set in %s of %s"), ToCStr(PointerName), ToCStr(GetName()), ToCStr(GetOwner()->GetName()));}
}

Logout()

void AOnlineGameMode::Logout ( AController * Exiting )

overrideprotectedvirtual

{
    Super::Logout(Exiting);
    if(Exiting == nullptr){return;}
    APlayerController* PlayerController = Cast<APlayerController>(Exiting);
    if(PlayerController != nullptr && AllPlayerControllers.Contains(Exiting))
    {
        AllPlayerControllers.Remove(PlayerController);
    }
    //@TODO Remove Player Controller from TeamPlayerControllers.
    //@TODO Add function that can get the TeamID from PlayerController? 
    // if(PlayerController != nullptr && TeamPlayerControllers.Contains(Exiting))
    // {
    //  
    // }
    
    //@TODO- Send Message, x player left match
    GetWorld()->GetTimerManager().SetTimer(UpdatePlayerListTimerHandle, this, &AOnlineGameMode::UpdatePlayerList, UpdatePlayerListDelay);
}

MatchCountdown()

void AOnlineGameMode::MatchCountdown ( )

protectedvirtual

Loop while in Match

Reimplemented in AMultiplayerGameMode, and AMultiplayerHordeGameMode.

{
    if(bMatchTimed)
    {
        if(bMatchCountUp)
        {
            MatchTime++;
        }
        else
        {
            MatchTime--;
        }
        if(bDebuggingMode && bLogMatchTime){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::MatchCountdown Match Time: %i "), MatchTime);}
    }
    MultiplayerMatchState.MatchState = EMatchState::InProgress;
    MultiplayerMatchState.TimeRemaining = MatchTime;
    UpdateGameState();
    OnMatchCountdown();
    if(bEndMatchCondition || (bMatchTimed && MatchTime <= 0) || (bMatchTimeLimit && MatchTime >= MatchTimeLimit))
    {
        GetWorld()->GetTimerManager().ClearTimer(MatchTimerHandle);
        EndMatch();
    }
}

OnAIDeath()

void AOnlineGameMode::OnAIDeath ( const FPlayerDeath & PlayerDeath )

protected

OnEndMatch()

void AOnlineGameMode::OnEndMatch ( )

protected

OnMatchCountdown()

void AOnlineGameMode::OnMatchCountdown ( )

protected

OnPlayerDeath()

void AOnlineGameMode::OnPlayerDeath ( const FPlayerDeath & PlayerDeath )

protected

OnPreMatch()

void AOnlineGameMode::OnPreMatch ( )

protected

OnReadyMatch()

void AOnlineGameMode::OnReadyMatch ( )

protected

OnStartMatch()

void AOnlineGameMode::OnStartMatch ( )

protected

PostLogin()

void AOnlineGameMode::PostLogin ( APlayerController * NewPlayer )

overrideprotectedvirtual

{
    Super::PostLogin(NewPlayer);
}

PreMatch()

void AOnlineGameMode::PreMatch ( )

protectedvirtual

Waiting for everyone to load in

Reimplemented in AMultiplayerGameMode.

{
    PreMatchWaitTime--;
    MultiplayerMatchState.TimeRemaining = PreMatchWaitTime;
    UpdateGameState();
    if(bDebuggingMode && bLogMatchTime){LogDebugError(FString::Printf(TEXT("AOnlineGameMode::PreMatch Pre Match Wait: %i "), PreMatchWaitTime));}
    OnPreMatch();
    if(PreMatchWaitTime <= 0 || GetTotalNumberOfControllers() >= NumberOfPlayersToStart)
    {
        GetWorld()->GetTimerManager().ClearTimer(PreMatchTimerHandle);
        GetWorld()->GetTimerManager().SetTimer(ReadyMatchTimerHandle, this, &AOnlineGameMode::ReadyMatch, MatchUpdateFrequency, true, 0.0f);
    }
}

ReadyMatch()

void AOnlineGameMode::ReadyMatch ( )

protectedvirtual

Everyone Ready to Start

Reimplemented in AMultiplayerGameMode.

{
    ReadyMatchWaitTime--;
    MultiplayerMatchState.MatchState = EMatchState::WaitingToStart;
    MultiplayerMatchState.TimeRemaining = ReadyMatchWaitTime;
    UpdateGameState();
    if(bDebuggingMode && bLogMatchTime){UE_LOG(LogOnlineGameMode,Warning,TEXT("Ready Match Wait: %i "), ReadyMatchWaitTime);}
    ResetTeamScores();
    UpdateScore();
    UpdateGameState();
    //@ TODO Move spawning Players into Ready Match? then Perform all Component Setups
    // for(APlayerController* PlayerController : AllPlayerControllers)
    // {
    //  SpawnPlayer(PlayerController);
    // }
    OnReadyMatch();
    if(ReadyMatchWaitTime <= 0)
    {
        GetWorld()->GetTimerManager().ClearTimer(ReadyMatchTimerHandle);
        StartMatch();
    }
}

ReadyToStartMatch_Implementation()

bool AOnlineGameMode::ReadyToStartMatch_Implementation ( )

overrideprotectedvirtual

{
    return false;
}

RegisterPlayer()

void AOnlineGameMode::RegisterPlayer ( APlayerController * NewPlayer )

protectedvirtual

{
    if(NewPlayer == nullptr){return;}
    FUniqueNetIdRepl UniqueNetIdRepl;
    if(NewPlayer->IsLocalController())
    {
        const ULocalPlayer* LocalPlayer = NewPlayer->GetLocalPlayer();
        if(LocalPlayer != nullptr)
        {
            UniqueNetIdRepl = LocalPlayer->GetPreferredUniqueNetId();
        }
        else
        {
            const UNetConnection* RemoteNetConnection = Cast<UNetConnection>(NewPlayer->Player);
            check(IsValid(RemoteNetConnection));
            UniqueNetIdRepl = RemoteNetConnection->PlayerId;
        }
    }
    else
    {
        const UNetConnection* RemoteNetConnection = Cast<UNetConnection>(NewPlayer->Player);
        check(IsValid(RemoteNetConnection));
        UniqueNetIdRepl = RemoteNetConnection->PlayerId;
    }
 
    const TSharedPtr<const FUniqueNetId> UniqueNetId = UniqueNetIdRepl.GetUniqueNetId();
    //- extra added error check from pre login // 
    if(UniqueNetId == nullptr){Logout(NewPlayer);return;}
    check(UniqueNetId != nullptr)
    const IOnlineSubsystem* OnlineSubsystem = Online::GetSubsystem(NewPlayer->GetWorld());
    if(OnlineSubsystem == nullptr){if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Error, TEXT("AOnlineGameMode::RegisterPlayer Online Subsystem failed in Register Player"));}return;}
    const IOnlineSessionPtr Session = OnlineSubsystem->GetSessionInterface();
    if(Session == nullptr){if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Error, TEXT("AOnlineGameMode::RegisterPlayer IOnlineSessionPtr failed in Register Player"));}return;}
    const IOnlineGI* GameInstance = Cast<IOnlineGI>(GetGameInstance());
    if(GameInstance == nullptr){if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Error, TEXT("AOnlineGameMode::RegisterPlayer failed in Register Player"));}return;}
    const bool bRegistrationSuccess = Session->RegisterPlayer(FName(GameInstance->GetCurrentSessionName()),*UniqueNetId, false);
    if(bRegistrationSuccess)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::RegisterPlayer Player Registered!"));}
        return;
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Error,TEXT("AOnlineGameMode::RegisterPlayer Registeration Failed!"));}
}

ResetTeamScores()

void AOnlineGameMode::ResetTeamScores ( )

private

{
    for(int32 TeamID : TeamIDs)
    {
        //- Set the team score to 0 //
        const int32* PreviousScorePtr = TeamScores.Find(TeamID);
        int32 PreviousScore = 0;
        if(PreviousScorePtr != nullptr)
        {
            PreviousScore = *PreviousScorePtr;
        }
        TeamScores.Add(TeamID, PreviousScore);
    }
}

SetEndMatchCondition()

virtual void AOnlineGameMode::SetEndMatchCondition ( )

inlineprotectedvirtual

Set the game to end

{bEndMatchCondition = true;};

SpawnedAIDeath()

void AOnlineGameMode::SpawnedAIDeath ( FPlayerDeath & PlayerDeath, APawn * PawnThatDied )

protectedvirtual

Reimplemented in ACampaignGameMode, AMultiplayerGameMode, and AMultiplayerHordeGameMode.

{
    const IOnlinePlayerState* AttackerPlayerState = Cast<IOnlinePlayerState>(PlayerDeath.AttackerPlayerState);
    if(AttackerPlayerState != nullptr)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("Attacker Name: %s"), *AttackerPlayerState->GetPlayerName());}
        PlayerDeath.Attacker = AttackerPlayerState->GetPlayerName();
    }   
    if(PlayerDeath.bSelfDeath)
    {
        //-     Self Death      //
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("Self Death AI"));}
    }
    AllAIDeaths.Add(PlayerDeath);
    AllDeaths.Add(PlayerDeath);
    
    TeamIDs.AddUnique(PlayerDeath.AttackerTeamID);
    TeamIDs.AddUnique(PlayerDeath.VictimTeamID);
    const int32* PreviousAttackerScorePtr = TeamScores.Find(PlayerDeath.AttackerTeamID);
    // int32 PointsToAdd = PlayerKilledScore;
    // if(!PlayerDeath.bTeamKill)
    // {
    //  AddScoreToTeam(PlayerDeath.AttackerTeamID, AIKilledScore);
    // }
    // if(bShowAIDeathInFeed)
    // {
    //  AddDeathToKillFeed(PlayerDeath);
    // }
    UpdateScore();
    // OnAIDeath(PlayerDeath);
    // AddScoreToPlayer(PlayerDeath.AttackerPlayerState, PlayerDeath.bTeamKill, PlayerDeath.bSelfDeath);
    OnAIDeath(PlayerDeath);
}

SpawnedPlayerDeath()

void AOnlineGameMode::SpawnedPlayerDeath ( FPlayerDeath & PlayerDeath, APawn * PawnThatDied )

protectedvirtual

Reimplemented in ACampaignGameMode, AMultiplayerGameMode, and AMultiplayerHordeGameMode.

{
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::PlayerDeath Victim: %s Attacker: %s"), *PlayerDeath.Victim, *PlayerDeath.Attacker);}
    const IOnlinePlayerState* VictimPlayerState = Cast<IOnlinePlayerState>(PlayerDeath.VictimPlayerState);
    if(VictimPlayerState != nullptr)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::PlayerDeath Victim Name: %s"), *VictimPlayerState->GetPlayerName());}
        PlayerDeath.Victim = VictimPlayerState->GetPlayerName();
    }
    const IOnlinePlayerState* AttackerPlayerState = Cast<IOnlinePlayerState>(PlayerDeath.AttackerPlayerState);
    if(AttackerPlayerState != nullptr)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::PlayerDeath Attacker Name: %s"), *AttackerPlayerState->GetPlayerName());}
        PlayerDeath.Attacker = AttackerPlayerState->GetPlayerName();
    }
    if(PlayerDeath.bSelfDeath)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::PlayerDeath Self Death"));}
    }
    if(PlayerDeath.bTeamKill)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::PlayerDeath Team Kill"));}
    }
    AllPlayerDeaths.Add(PlayerDeath);
    AllDeaths.Add(PlayerDeath);
    //- Make sure both teams are in the array of teamIDs
    TeamIDs.AddUnique(PlayerDeath.AttackerTeamID);
    TeamIDs.AddUnique(PlayerDeath.VictimTeamID);
    // int32 PointsToAdd = PlayerKilledScore;
    // if(PlayerDeath.bTeamKill)
    // {
    //  if(bTeamKillPenalty)
    //  {
    //      PointsToAdd = TeamKillScore;
    //  }
    //  else
    //  {
    //      PointsToAdd = 0;
    //  }
    // }
    // AddScoreToTeam(PlayerDeath.AttackerTeamID, PointsToAdd);
    // AddScoreToPlayer(PlayerDeath.AttackerPlayerState, PlayerDeath.bTeamKill, PlayerDeath.bSelfDeath);
    // AddDeathToPlayer(PlayerDeath.VictimPlayerState, PlayerDeath.bSelfDeath);
    OnPlayerDeath(PlayerDeath);
    UpdateScore();
}

SpawnPlayer()

void AOnlineGameMode::SpawnPlayer ( APlayerController * PlayerController )

virtual

{
    if(PlayerController == nullptr){UE_LOG(LogOnlineGameMode, Error, TEXT("AOnlineGameMode::SpawnPlayer Player Controller Null"));return;}
    APawn* ControlledPawn = PlayerController->GetPawn();
    if(ControlledPawn == nullptr){UE_LOG(LogOnlineGameMode, Error, TEXT("AOnlineGameMode::SpawnPlayer Pawn Null"));return;}
    //@TODO Add to BPlib, GetPlayerTeamID()
    int32 TeamID = 0;
    TeamID = UBaseHelpersBPLib::GetPlayerTeamID(PlayerController);
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Warning, TEXT("AOnlineGameMode::SpawnPlayer Spawn Player: %s Team ID: %i"), *PlayerController->PlayerState->GetPlayerName(),  TeamID);}
    DestroyPawn(ControlledPawn);
    
    const FActorSpawnParameters SpawnParameters;
    FTransform SpawnLocation = FindRandomPlayerStart();
    if(bTeamSpawns){SpawnLocation = FindTeamPlayerStart(TeamID);}
    APawn* NewPawn = GetWorld()->SpawnActor<APawn>(DefaultPawnClass, SpawnLocation, SpawnParameters);
    if(NewPawn != nullptr)
    {
        ACharacterBase* SpawnedPlayer = Cast<ACharacterBase>(NewPawn);
        if(SpawnedPlayer != nullptr)
        {
            SpawnedPlayer->OnCharacterDeath.AddUniqueDynamic(this, &AOnlineGameMode::SpawnedPlayerDeath);
            // SpawnedPlayer->OnSetupComplete.AddUniqueDynamic(this, &AOnlineGameMode::PlayerCharacterSetup);
        }
        PlayerController->Possess(NewPawn);
        return;
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Error, TEXT("AOnlineGameMode::SpawnPlayer Pawn Failed To Spawn"));}
}

StartMatch()

void AOnlineGameMode::StartMatch ( )

overrideprotectedvirtual

Start logic, Spawn in Players

Reimplemented in AMultiplayerGameMode, and AMultiplayerHordeGameMode.

{
    Super::StartMatch();
    if(bDebuggingMode && bLogMatchState){UE_LOG(LogOnlineGameMode,Warning,TEXT("AOnlineGameMode::StartMatch Match Start"));}
    // ResetTeamScores();
    // UpdateScore();
    UpdateGameState();
    for(APlayerController* PlayerController : AllPlayerControllers)
    {
        SpawnPlayer(PlayerController);
    }
    UpdateGameState();
    // //@ TODO Move spawning Players into Ready Match? then Perform all Component Setups
    // for(APlayerController* PlayerController : AllPlayerControllers)
    // {
    //  SpawnPlayer(PlayerController);
    // }
    if(bMatchCountUp)
    {
        MatchTime = 0;
    }
    GetWorld()->GetTimerManager().SetTimer(MatchTimerHandle, this, &AOnlineGameMode::MatchCountdown, MatchUpdateFrequency, true, 0.0f);
    OnStartMatch();
}

SwapPlayerControllers()

void AOnlineGameMode::SwapPlayerControllers ( APlayerController * OldPC, APlayerController * NewPC )

overrideprotectedvirtual

{
    Super::SwapPlayerControllers(OldPC, NewPC);
    if(NewPC == nullptr){return;}
    //@ TODO Get Team from OldPC - Transfer it to NewPC
    //@ otherwise it will be putting players on new teams when they go in vehicles etc. 
    AllPlayerControllers.AddUnique(NewPC);
    AddPlayerToTeam(NewPC);
    RegisterPlayer(NewPC);
    
    GetWorld()->GetTimerManager().SetTimer(UpdatePlayerListTimerHandle, this, &AOnlineGameMode::UpdatePlayerList, UpdatePlayerListDelay);
    if(bDebuggingMode){UE_LOG(LogOnlineGameMode, Warning, TEXT("AOnlineGameMode::SwapPlayerControllers Swap Player Controllers,Total PCs: %i"), AllPlayerControllers.Num());}
}

UpdateGameState()

void AOnlineGameMode::UpdateGameState ( )

protectedvirtual

Reimplemented in AMultiplayerGameMode.

{
    if(OnlineGameState == nullptr)
    {
        OnlineGameState = Cast<IOnlineGS>(GameState);
    }
    if(OnlineGameState == nullptr){UE_LOG(LogOnlineGameMode,Error,TEXT("Game State Missing in AOnlineGameMode"));}
    if(OnlineGameState != nullptr)
    {
        UpdateScore();
        OnlineGameState->SetOnlineMatchState(MultiplayerMatchState);
        OnlineGameState->SetMultiplayerMode(MultiplayerMode);
        // OnlineGameState->SetScore(MultiplayerMode);
 
        // OnlineGameState->SetScoreGoal(GoalScore);
        //- In Multiplayer only 
        // OnlineGameState->SetRound(Round);
    }
}

UpdatePlayerList()

void AOnlineGameMode::UpdatePlayerList ( )

virtual

{
    GetWorld()->GetTimerManager().ClearTimer(UpdatePlayerListTimerHandle);
    if(OnlineGameState == nullptr){UE_LOG(LogOnlineGameMode, Error, TEXT("AOnlineGameMode::UpdatePlayerList Game State Cast Failed"));return;}
    OnlineGameState->UpdatePlayerList();
}

UpdateScore()

void AOnlineGameMode::UpdateScore

(

)

{
    TArray<FTeamScoreData> ScoresArray;
    for(const TPair<int32, int32>& Pair : TeamScores)
    {
        FTeamScoreData Data;
        Data.TeamID = Pair.Key;
        Data.TeamScore = Pair.Value;
        ScoresArray.Add(Data);
    }
}

Member Data Documentation

AIPlayerStarts

TArray<AActor*> AOnlineGameMode::AIPlayerStarts

protected

All AI Player Starts (Player Starts with a Tag "@TODO ")

AISpawnTag

FString AOnlineGameMode::AISpawnTag = "AI"

protected

AllAIDeaths

TArray<FPlayerDeath> AOnlineGameMode::AllAIDeaths

protected

AllDeaths

TArray<FPlayerDeath> AOnlineGameMode::AllDeaths

protected

AllPlayerControllers

TArray<APlayerController*> AOnlineGameMode::AllPlayerControllers

protected

All Player Controllers

AllPlayerDeaths

TArray<FPlayerDeath> AOnlineGameMode::AllPlayerDeaths

protected

bDebuggingMode

bool AOnlineGameMode::bDebuggingMode = false

protected

bDisableStartTimers

bool AOnlineGameMode::bDisableStartTimers = false

protected

bEndMatchCondition

bool AOnlineGameMode::bEndMatchCondition = false

private

bFriendlyFireOn

bool AOnlineGameMode::bFriendlyFireOn = true

protected

bLogMatchState

bool AOnlineGameMode::bLogMatchState = false

protected

bLogMatchTime

bool AOnlineGameMode::bLogMatchTime = false

protected

bLogPlayerStarts

bool AOnlineGameMode::bLogPlayerStarts = false

protected

bMatchCountUp

bool AOnlineGameMode::bMatchCountUp = false

protected

bMatchOver

bool AOnlineGameMode::bMatchOver = false

protected

bMatchTimed

bool AOnlineGameMode::bMatchTimed = false

protected

bMatchTimeLimit

bool AOnlineGameMode::bMatchTimeLimit = false

protected

bTeamSpawns

bool AOnlineGameMode::bTeamSpawns = true

protected

LastUsedPlayerStart

TMap<int32, int32> AOnlineGameMode::LastUsedPlayerStart

protected

Player Start that was last used to spawn player

MatchTime

int32 AOnlineGameMode::MatchTime = 20

protected

MatchTimeLimit

int32 AOnlineGameMode::MatchTimeLimit = 120

protected

MatchTimerHandle

FTimerHandle AOnlineGameMode::MatchTimerHandle

private

MatchUpdateFrequency

float AOnlineGameMode::MatchUpdateFrequency = 1.0f

protected

MultiplayerMatchState

FMatchState AOnlineGameMode::MultiplayerMatchState

private

MultiplayerMode

EMultiplayerMode AOnlineGameMode::MultiplayerMode = EMultiplayerMode::Default

protected

NumberOfPlayersToStart

int32 AOnlineGameMode::NumberOfPlayersToStart = 4

protected

Number of Players Required to start

NumberOfTeams

int32 AOnlineGameMode::NumberOfTeams = 2

protected

OnlineGameState

class IOnlineGS* AOnlineGameMode::OnlineGameState = nullptr

protected

PlayerStarts

TArray<AActor*> AOnlineGameMode::PlayerStarts

protected

Player Starts All Player Starts

PreMatchTimerHandle

FTimerHandle AOnlineGameMode::PreMatchTimerHandle

private

PreMatchWaitTime

int32 AOnlineGameMode::PreMatchWaitTime = 5

protected

ReadyMatchTimerHandle

FTimerHandle AOnlineGameMode::ReadyMatchTimerHandle

private

ReadyMatchWaitTime

int32 AOnlineGameMode::ReadyMatchWaitTime = 10

protected

RespawnTime

int32 AOnlineGameMode::RespawnTime = 3

protected

SelfDeathRespawnTimeMultiplier

int32 AOnlineGameMode::SelfDeathRespawnTimeMultiplier = 2

protected

TeamIDs

TArray<int32> AOnlineGameMode::TeamIDs

protected

TeamKillDeathRespawnTimeMultiplier

int32 AOnlineGameMode::TeamKillDeathRespawnTimeMultiplier = 3

protected

TeamPlayerControllers

TMap<int32, TArray<APlayerController*> > AOnlineGameMode::TeamPlayerControllers

protected

TeamScores

TMap<int32, int32> AOnlineGameMode::TeamScores

protected

TeamStarts

TMap<int32, TArray<APlayerStart*> > AOnlineGameMode::TeamStarts

protected

UpdatePlayerListDelay

float AOnlineGameMode::UpdatePlayerListDelay = 0.3f

UpdatePlayerListTimerHandle

FTimerHandle AOnlineGameMode::UpdatePlayerListTimerHandle

private

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Public/GameMode/OnlineGameMode.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Private/GameMode/OnlineGameMode.cpp