AMultiplayerGameMode Class Reference

#include <MultiplayerGameMode.h>

Inheritance diagram for AMultiplayerGameMode:

Public Member Functions
	AMultiplayerGameMode ()
virtual void	BeginPlay () override
virtual int32	GetCurrentRound () const
	In Parent
virtual void	SpawnedPlayerDeath (FPlayerDeath &PlayerDeath, APawn *PawnThatDied) override
	In Parent
virtual void	SpawnedAIDeath (FPlayerDeath &PlayerDeath, APawn *PawnThatDied) override
void	AddDeathToKillFeed (const FPlayerDeath &PlayerDeath, const bool bPlayerDeath=true)
Public Member Functions inherited from AOnlineGameMode
	AOnlineGameMode ()
void	UpdateScore ()
virtual void	UpdatePlayerList ()
virtual void	SpawnPlayer (APlayerController *PlayerController)

Public Attributes
TMap< int32, TArray< APlayerStart * > >	TeamStarts
Public Attributes inherited from AOnlineGameMode
float	UpdatePlayerListDelay = 0.3f

Protected Member Functions
virtual void	PreMatch () override
virtual void	ReadyMatch () override
virtual void	StartMatch () override
virtual void	EndMatch () override
virtual void	MatchCountdown () override
virtual void	StartRound ()
virtual void	RoundCountdown ()
virtual void	EndRound ()
virtual void	UpdateGameState () override
void	OnStartRound ()
void	OnRoundCountdown ()
void	OnEndRound ()
virtual void	SetEndRoundCondition ()
virtual void	ResetEndRoundCondition ()
virtual void	AddScoreToTeam (const int32 TeamID, const int32 ScoreToAdd)
virtual void	AddScoreToPlayer (APlayerState *Player, const bool bTeamKill=false, const bool bSelfKill=false)
virtual void	AddDeathToPlayer (APlayerState *Player, const bool bSelfKill=false)
Protected Member Functions inherited from AOnlineGameMode
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
void	OnPlayerDeath (const FPlayerDeath &PlayerDeath)
void	OnAIDeath (const FPlayerDeath &PlayerDeath)
TArray< FPlayerDeath > &	GetAllPlayerDeaths ()
TArray< FPlayerDeath > &	GetAllAIDeaths ()
virtual bool	ReadyToStartMatch_Implementation () override
void	OnPreMatch ()
void	OnReadyMatch ()
void	OnStartMatch ()
void	OnEndMatch ()
void	OnMatchCountdown ()
virtual void	SetEndMatchCondition ()
virtual bool	GetIsMatchOver ()
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
class AMultiplayerGameState *	MultiplayerGameState = nullptr
	Replaced with Parent = UpdateGameState();.
int32	GoalScore = 1
int32	PlayerKilledScore = 2
int32	TeamKillScore =-1
int32	AIKilledScore = 1
int32	ObjectiveScore = 5
float	PlayerKilledXP = 100.0f
float	TeamKilledXP = -100.0f
float	SelfKilledXP = -25.0f
float	AIKilledXP = 25.0f
bool	bEndOnTeamReachingGoal = true
bool	bPlayerLifeLimit = false
int32	PlayerLifePool = 10
bool	bRoundBased = false
bool	bRoundsTimed = false
bool	bRoundLimit = false
int32	Round = 0
int32	RoundTime = 20
int32	RoundTimeMax = 10
int32	RoundGoalScore = 1
int32	MaxRounds = 10
float	TimeTillNextRound = 4.0f
bool	bEndRoundOnTeamReachingGoal = false
bool	bTeamKillPenalty = true
int32	TeamKillPenaltyTime = 3
bool	bSelfKillPenalty = true
int32	SelfKillPenaltyTime = 3
bool	bShowDeathsInFeed = true
bool	bShowPlayerDeathsInFeed = true
bool	bShowAIDeathInFeed = true
Protected Attributes inherited from AOnlineGameMode
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 Attributes
FMatchState	RoundMatchState
FTimerHandle	RoundTimerHandle
FTimerHandle	NextRoundTimerHandle
bool	bEndRoundCondition = false

Constructor & Destructor Documentation

AMultiplayerGameMode()

AMultiplayerGameMode::AMultiplayerGameMode

(

)

{
    
}

Member Function Documentation

AddDeathToKillFeed()

void AMultiplayerGameMode::AddDeathToKillFeed	(	const FPlayerDeath &	PlayerDeath,
		const bool	bPlayerDeath = true )

{
    if(!bShowDeathsInFeed){return;}
    if(MultiplayerGameState == nullptr){UE_LOG(LogCustomALSGameMode,Warning,TEXT("MultiplayerGameState in Multiplayer GM"));return;}
    MultiplayerGameState->ClientAddDeathToKillFeed(PlayerDeath, bPlayerDeath);
    return;
    for(APlayerController* PlayerController: AllPlayerControllers)
    {
        ACustomPlayerController* CustomPlayerController = Cast<ACustomPlayerController>(PlayerController);
        if(CustomPlayerController != nullptr)
        {
            CustomPlayerController->ClientAddDeathToKillFeed(PlayerDeath, bPlayerDeath);
        }
    }
}

AddDeathToPlayer()

void AMultiplayerGameMode::AddDeathToPlayer ( APlayerState * Player, const bool bSelfKill = false )

protectedvirtual

{
    AMenuSystemPlayerState* CustomVictimPlayerState = Cast<AMenuSystemPlayerState>(Player);
    if(CustomVictimPlayerState != nullptr)
    {
        CustomVictimPlayerState->SetMultiplayerStats(CustomVictimPlayerState->GetMultiplayerStats().AddDeath());
        int32 RespawnTimeFull = RespawnTime;
        if(bSelfKill)
        {
            RespawnTimeFull *= SelfDeathRespawnTimeMultiplier;
        }
        if(PlayerLifePool >= 0)
        {
            CustomVictimPlayerState->StartRespawnTimer(RespawnTimeFull);
            CustomVictimPlayerState->OnReadyToRespawn.AddUniqueDynamic(this, &AOnlineGameMode::SpawnPlayer);
        }
    }
}

AddScoreToPlayer()

void AMultiplayerGameMode::AddScoreToPlayer ( APlayerState * Player, const bool bTeamKill = false, const bool bSelfKill = false )

protectedvirtual

{
    if(Player == nullptr){return;}
    AMenuSystemPlayerState* CustomPlayerState = Cast<AMenuSystemPlayerState>(Player);
    if(CustomPlayerState != nullptr)
    {
        if(!bSelfKill && !bTeamKill)
        {
            CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddKill());
            CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddXP(PlayerKilledXP));
        }
        if(bTeamKill && bTeamKillPenalty)
        {
            CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddTeamKill());
            CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddXP(TeamKilledXP));
            CustomPlayerState->AddRespawnPenalty(TeamKillPenaltyTime);
        }
        if(bSelfKill && bSelfKillPenalty)
        {
            CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddSelfKill());
            CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddXP(SelfKilledXP));
            CustomPlayerState->AddRespawnPenalty(SelfKillPenaltyTime);
        }
    }
}

AddScoreToTeam()

void AMultiplayerGameMode::AddScoreToTeam ( const int32 TeamID, const int32 ScoreToAdd )

protectedvirtual

{
    const int32* PreviousAttackerScorePtr = TeamScores.Find(TeamID);
    int32 PreviousAttackerScore = 0;
    if(PreviousAttackerScorePtr != nullptr)
    {
        PreviousAttackerScore = *PreviousAttackerScorePtr;
    }
    TeamScores.Add(TeamID, (PreviousAttackerScore + ScoreToAdd));
}

BeginPlay()

void AMultiplayerGameMode::BeginPlay ( )

overridevirtual

In Parent

Reimplemented from AOnlineGameMode.

Reimplemented in AMultiplayerHordeGameMode.

{
    Super::BeginPlay();
    RoundTimeMax = RoundTime;
    if(bDisableStartTimers)
    {
        PreMatchWaitTime = 0;   
        ReadyMatchWaitTime = 0;
    }
    // GetAllPlayerStarts();
    MultiplayerGameState = GetGameState<AMultiplayerGameState>();
    if(MultiplayerGameState == nullptr){UE_LOG(LogCustomALSGameMode,Error,TEXT("Game State Missing in Multiplayer Game Mode"));}
 
    // MultiplayerMatchState.MatchState = EMatchState::PreMatch;
    // if(MultiplayerGameState != nullptr)
    // {
    //  MultiplayerGameState->SetMultiplayerMatchState(MultiplayerMatchState);
    // }
    // GetWorld()->GetTimerManager().SetTimer(PreMatchTimerHandle, this, &AMultiplayerGameMode::PreMatch, 1.0f, true);
    // SetupScore();
}

EndMatch()

void AMultiplayerGameMode::EndMatch ( )

overrideprotectedvirtual

Condition Met to finish match

In Parent

Reimplemented from AOnlineGameMode.

{
    // bMatchOver = true;
    // GetWorld()->GetTimerManager().ClearTimer(MatchTimerHandle);
    // MultiplayerMatchState.MatchState = EMatchState::PostMatch;
    // MultiplayerMatchState.TimeRemaining = 0;//@TODO Add in Lobby up part
    GetWorld()->GetTimerManager().ClearTimer(RoundTimerHandle);
    GetWorld()->GetTimerManager().ClearTimer(NextRoundTimerHandle);
 
    Super::EndMatch();
    UpdateGameState();
    //@ TODO Add Client Match Over
    // MultiplayerGameState->ClientMatchOver();
 
    // if(MultiplayerGameState != nullptr)
    // {
    //  MultiplayerGameState->SetMultiplayerMatchState(MultiplayerMatchState);
    //  MultiplayerGameState->ClientMatchOver();
    // }
    return;
 
    for(APlayerState* PlayerState : MultiplayerGameState->PlayerArray)
    {
        if(PlayerState->GetPawn() != nullptr)
        {
            PlayerState->GetPawn()->GetMovementComponent()->StopMovementImmediately();
        }
        // if(PlayerState->GetPlayerController() != nullptr)
        // {
        //  FInputModeUIOnly InputUIOnly;
        //  PlayerState->GetPlayerController()->SetInputMode(InputUIOnly);
        // }
    }
}

EndRound()

void AMultiplayerGameMode::EndRound ( )

protectedvirtual

Reimplemented in AMultiplayerHordeGameMode.

{
    UpdateGameState();
    OnEndRound();
    GetWorld()->GetTimerManager().ClearTimer(RoundTimerHandle);
    ResetEndRoundCondition();
    RoundMatchState.RoundState = EMatchState::PostMatch;
    RoundMatchState.RoundTimeRemaining = 0;
    RoundTime = 0;
    UpdateGameState();
    // if(MultiplayerGameState != nullptr)
    // {
    //  MultiplayerGameState->SetMultiplayerMatchState(MultiplayerMatchState);
    // }
    if(bDebuggingMode && bLogMatchState){UE_LOG(LogCustomALSGameMode,Warning,TEXT("Round OVER"));}
    if(bRoundLimit && Round >= MaxRounds)
    {
        EndMatch();
    }
    UpdateGameState();
    //@ TODO Add in this
    // MultiplayerGameState->ClientRoundOver();
 
    
    // if(MultiplayerGameState != nullptr)
    // {
    //  MultiplayerGameState->SetMultiplayerMatchState(MultiplayerMatchState);
    //  MultiplayerGameState->ClientRoundOver();
    // }
    if(GetIsMatchOver())
    {
        
    }
    else
    {
        GetWorld()->GetTimerManager().SetTimer(NextRoundTimerHandle, this, &AMultiplayerGameMode::StartRound,TimeTillNextRound);
    }
}

GetCurrentRound()

virtual int32 AMultiplayerGameMode::GetCurrentRound ( ) const

inlinevirtual

In Parent

{return Round;};

MatchCountdown()

void AMultiplayerGameMode::MatchCountdown ( )

overrideprotectedvirtual

Loop while in Match

Reimplemented from AOnlineGameMode.

Reimplemented in AMultiplayerHordeGameMode.

{
    Super::MatchCountdown();
 
    //@ TODO Keep going with OnlineGameMode Moving  ///
    //- Multiplayer 
    if(bEndOnTeamReachingGoal)
    {
        for(const auto& Team : TeamScores)
        {
            if(Team.Value >= GoalScore)
            {
                if(bDebuggingMode){UE_LOG(LogCustomALSGameMode,Warning,TEXT("AMultiplayerGameMode::MatchCountdown Team: %i WON,  %i Points"), Team.Key, Team.Value);}
                SetEndMatchCondition();
            }
        }
    }
    //- Multiplayer 
    
    // if(bMatchTimed && MatchTime <= 0)
    // {
    //  GetWorld()->GetTimerManager().ClearTimer(MatchTimerHandle);
    //  EndMatch();
    // }
    // if(GetIsMatchOver())
    // {
    //  GetWorld()->GetTimerManager().ClearTimer(MatchTimerHandle);
    //  EndMatch();
    // }
}

OnEndRound()

void AMultiplayerGameMode::OnEndRound ( )

protected

OnRoundCountdown()

void AMultiplayerGameMode::OnRoundCountdown ( )

protected

OnStartRound()

void AMultiplayerGameMode::OnStartRound ( )

protected

PreMatch()

void AMultiplayerGameMode::PreMatch ( )

overrideprotectedvirtual

Waiting for everyone to load in

Reimplemented from AOnlineGameMode.

{
    Super::PreMatch();
    // if(MultiplayerGameState != nullptr)
    // {
    //  MultiplayerGameState->SetMultiplayerMatchState(MultiplayerMatchState);
    // }
    // if(bDebuggingMode && bLogMatchTime){UE_LOG(LogCustomALSGameMode,Warning,TEXT("Pre Match Wait: %i "), PreMatchWaitTime);}
    // if(PreMatchWaitTime <= 0 || GetTotalNumberOfControllers() >= NumberOfPlayersToStart)
    // {
    //  GetWorld()->GetTimerManager().ClearTimer(PreMatchTimerHandle);
    //  GetWorld()->GetTimerManager().SetTimer(ReadyMatchTimerHandle, this, &AMultiplayerGameMode::ReadyMatch, 1.0f, true);
    // }
}

ReadyMatch()

void AMultiplayerGameMode::ReadyMatch ( )

overrideprotectedvirtual

Everyone Ready to Start

Reimplemented from AOnlineGameMode.

{
    Super::ReadyMatch();
}

ResetEndRoundCondition()

virtual void AMultiplayerGameMode::ResetEndRoundCondition ( )

inlineprotectedvirtual

{bEndRoundCondition = false;};

RoundCountdown()

void AMultiplayerGameMode::RoundCountdown ( )

protectedvirtual

Use Update GameState?

{
    OnRoundCountdown();
    UpdateGameState();
    if(bRoundsTimed)
    {
        RoundTime--;
        // UpdateMatchState();
        if(bDebuggingMode && bLogMatchTime){UE_LOG(LogCustomALSGameMode,Warning,TEXT("Rounnd Time: %i "), RoundTime);}
    }
    RoundMatchState.RoundState = EMatchState::InProgress;
    RoundMatchState.RoundTimeRemaining = RoundTime;
    if(bEndRoundOnTeamReachingGoal)
    {
        for(const auto& Team : TeamScores)
        {
            //@TODO Temp, change to function that can be overridden
            if(Team.Value >= RoundGoalScore * Round)
            {
                if(bDebuggingMode){UE_LOG(LogCustomALSGameMode,Warning,TEXT("Team: %i WON,  %i Points"), Team.Key, Team.Value);}
                SetEndRoundCondition();
            }
        }
    }
    if(bRoundsTimed && RoundTime <= 0)
    {
        SetEndRoundCondition();
    }
    if(bRoundLimit && Round >= MaxRounds)
    {
        SetEndRoundCondition();
    }
    if(bEndRoundCondition)
    {
        EndRound();
    }
}

SetEndRoundCondition()

virtual void AMultiplayerGameMode::SetEndRoundCondition ( )

inlineprotectedvirtual

{bEndRoundCondition = true;};

SpawnedAIDeath()

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

overridevirtual

In Parent

Reimplemented from AOnlineGameMode.

Reimplemented in AMultiplayerHordeGameMode.

{
    Super::SpawnedAIDeath(PlayerDeath, PawnThatDied);
    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);
    
    // AMenuSystemPlayerState* CustomPlayerState = Cast<AMenuSystemPlayerState>(PlayerDeath.AttackerPlayerState);
    // if(CustomPlayerState != nullptr)
    // {
    //  CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddKill());
    //  CustomPlayerState->SetMultiplayerStats(CustomPlayerState->GetMultiplayerStats().AddXP(AIKilledXP));
    // }
}

SpawnedPlayerDeath()

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

overridevirtual

In Parent

Reimplemented from AOnlineGameMode.

Reimplemented in AMultiplayerHordeGameMode.

{
    Super::SpawnedPlayerDeath(PlayerDeath, PawnThatDied);
    int32 PointsToAdd = PlayerKilledScore;
    if(PlayerDeath.bTeamKill)
    {
        if(bTeamKillPenalty)
        {
            PointsToAdd = TeamKillScore;
        }
        else
        {
            PointsToAdd = 0;
        }
    }
    AddScoreToTeam(PlayerDeath.AttackerTeamID, PointsToAdd);
    if(bShowPlayerDeathsInFeed){AddDeathToKillFeed(PlayerDeath);}
    
    AddScoreToPlayer(PlayerDeath.AttackerPlayerState, PlayerDeath.bTeamKill, PlayerDeath.bSelfDeath);
    AddDeathToPlayer(PlayerDeath.VictimPlayerState, PlayerDeath.bSelfDeath);
}

StartMatch()

void AMultiplayerGameMode::StartMatch ( )

overrideprotectedvirtual

Start logic, Spawn in Players

Reimplemented from AOnlineGameMode.

Reimplemented in AMultiplayerHordeGameMode.

{
    Super::StartMatch();
 
    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);
    }
    // for(APlayerController* PlayerController : AllPlayerControllers)
    // {
    //  SpawnPlayer(PlayerController);
    // }
    if(bRoundBased)
    {
        GetWorld()->GetTimerManager().SetTimer(NextRoundTimerHandle, this, &AMultiplayerGameMode::StartRound,TimeTillNextRound);
    }
    //@TODO
    // GetWorld()->GetTimerManager().SetTimer(SetupScoreTimerHandle, this, &AMultiplayerGameMode::SetupScore,TimeTillNextRound);
}

StartRound()

void AMultiplayerGameMode::StartRound ( )

protectedvirtual

Reimplemented in AMultiplayerHordeGameMode.

{
    OnStartRound();
    UpdateGameState();
    if(bMatchOver){return;}
    if(bDebuggingMode && bLogMatchState){UE_LOG(LogCustomALSGameMode,Warning,TEXT("Round Start"));}
    ++Round;
    RoundTime = RoundTimeMax;
    GetWorld()->GetTimerManager().ClearTimer(NextRoundTimerHandle);
    
    GetWorld()->GetTimerManager().SetTimer(RoundTimerHandle, this, &AMultiplayerGameMode::RoundCountdown, 1.0f, true);
    RoundMatchState.RoundState = EMatchState::PreMatch;
    if(MultiplayerGameState == nullptr){UE_LOG(LogCustomALSGameMode,Warning,TEXT("MultiplayerGameState in Multiplayer GM"));return;}
    MultiplayerGameState->SetRound(Round);
    UpdateScore();
}

UpdateGameState()

void AMultiplayerGameMode::UpdateGameState ( )

overrideprotectedvirtual

Reimplemented from AOnlineGameMode.

{
    Super::UpdateGameState();
    //-
    //@ TODO
    // Cast to IMultiplayerGS
    //  if(OnlineGameState == nullptr)
    // {
    //  OnlineGameState = Cast<IOnlineGS>(GameState);
    // }
    // if(OnlineGameState == nullptr){UE_LOG(LogCustomALSGameMode,Error,TEXT("Game State Missing in AOnlineGameMode"));}
    // if(OnlineGameState != nullptr)
    // {
 
 
    // if(MultiplayerGameState == nullptr){UE_LOG(LogCustomALSGameMode,Warning,TEXT("MultiplayerGameState in Multiplayer GM"));return;}
    //- Functions to Add to IMultiplayerGS  //
    // MultiplayerGameState->SetScore(ScoresArray);
    // MultiplayerGameState->SetScoreGoal(GoalScore);
    // MultiplayerGameState->SetRound(Round);
 
}

Member Data Documentation

AIKilledScore

int32 AMultiplayerGameMode::AIKilledScore = 1

protected

AIKilledXP

float AMultiplayerGameMode::AIKilledXP = 25.0f

protected

bEndOnTeamReachingGoal

bool AMultiplayerGameMode::bEndOnTeamReachingGoal = true

protected

bEndRoundCondition

bool AMultiplayerGameMode::bEndRoundCondition = false

private

bEndRoundOnTeamReachingGoal

bool AMultiplayerGameMode::bEndRoundOnTeamReachingGoal = false

protected

bPlayerLifeLimit

bool AMultiplayerGameMode::bPlayerLifeLimit = false

protected

bRoundBased

bool AMultiplayerGameMode::bRoundBased = false

protected

bRoundLimit

bool AMultiplayerGameMode::bRoundLimit = false

protected

bRoundsTimed

bool AMultiplayerGameMode::bRoundsTimed = false

protected

bSelfKillPenalty

bool AMultiplayerGameMode::bSelfKillPenalty = true

protected

bShowAIDeathInFeed

bool AMultiplayerGameMode::bShowAIDeathInFeed = true

protected

bShowDeathsInFeed

bool AMultiplayerGameMode::bShowDeathsInFeed = true

protected

bShowPlayerDeathsInFeed

bool AMultiplayerGameMode::bShowPlayerDeathsInFeed = true

protected

bTeamKillPenalty

bool AMultiplayerGameMode::bTeamKillPenalty = true

protected

GoalScore

int32 AMultiplayerGameMode::GoalScore = 1

protected

MaxRounds

int32 AMultiplayerGameMode::MaxRounds = 10

protected

MultiplayerGameState

class AMultiplayerGameState* AMultiplayerGameMode::MultiplayerGameState = nullptr

protected

Replaced with Parent = UpdateGameState();.

Remove Game State, use Interface //

NextRoundTimerHandle

FTimerHandle AMultiplayerGameMode::NextRoundTimerHandle

private

ObjectiveScore

int32 AMultiplayerGameMode::ObjectiveScore = 5

protected

PlayerKilledScore

int32 AMultiplayerGameMode::PlayerKilledScore = 2

protected

PlayerKilledXP

float AMultiplayerGameMode::PlayerKilledXP = 100.0f

protected

PlayerLifePool

int32 AMultiplayerGameMode::PlayerLifePool = 10

protected

Round

int32 AMultiplayerGameMode::Round = 0

protected

RoundGoalScore

int32 AMultiplayerGameMode::RoundGoalScore = 1

protected

RoundMatchState

FMatchState AMultiplayerGameMode::RoundMatchState

private

RoundTime

int32 AMultiplayerGameMode::RoundTime = 20

protected

RoundTimeMax

int32 AMultiplayerGameMode::RoundTimeMax = 10

protected

RoundTimerHandle

FTimerHandle AMultiplayerGameMode::RoundTimerHandle

private

SelfKilledXP

float AMultiplayerGameMode::SelfKilledXP = -25.0f

protected

SelfKillPenaltyTime

int32 AMultiplayerGameMode::SelfKillPenaltyTime = 3

protected

TeamKilledXP

float AMultiplayerGameMode::TeamKilledXP = -100.0f

protected

TeamKillPenaltyTime

int32 AMultiplayerGameMode::TeamKillPenaltyTime = 3

protected

TeamKillScore

int32 AMultiplayerGameMode::TeamKillScore =-1

protected

TeamStarts

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

TimeTillNextRound

float AMultiplayerGameMode::TimeTillNextRound = 4.0f

protected

---

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

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