GASATHON/Project/Source/Gasa/Game/GasaGameMode.cpp

478 lines
14 KiB
C++

#include "GasaGameMode.h"
#include "Online/CoreOnline.h"
#include "GasaGameInstance.h"
#include "GasaGameState.h"
#include "GasaPlayerController.h"
#include "Engine/Player.h"
#include "GameFramework/GameSession.h"
#include "GameFramework/GameState.h"
#include "GameFramework/PlayerState.h"
#include "OnlineSubsystem.h"
using namespace Gasa;
#pragma region Game Framework
void AGasaGameMode::OnGameFrameworkInitialized()
{
NetLog("OnGameFrameworkInitialized");
BP_OnGameFrameworkInitialized();
if (MatchState == MatchState::WaitingToStart && ReadyToStartMatch())
StartMatch();
}
void AGasaGameMode::OwningClient_OnGameFrameworkInitialized(AGasaPlayerController* PC)
{
NetLog("OwningClient_OnGameFrameworkInitialized");
HandleStartingNewPlayer(PC);
}
#pragma endregion Game Framework
#pragma region GameMode
void AGasaGameMode::HandleStartingNewPlayer_Implementation(APlayerController* NewPlayer)
{
Super::HandleStartingNewPlayer_Implementation(NewPlayer);
if (NewPlayer)
NewPlayer->bBlockInput = false;
}
bool AGasaGameMode::ReadyToStartMatch_Implementation()
{
if ( ! GetGameInstance<UGasaGameInstance>()->IsGameFrameworkInitialized())
{
return false;
}
// Super::ReadyToStartMatch();
{
// If bDelayed Start is set, wait for a manual match start
if (bDelayedStart)
{
return false;
}
// By default start when we have > 0 players
if (GetMatchState() == MatchState::WaitingToStart)
{
if (NumPlayers + NumBots > 0)
{
return true;
}
}
return false;
}
}
#pragma endregion GameMode
#pragma region GameModeBase
void AGasaGameMode::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
Super::EndPlay(EndPlayReason);
NetLog("EndPlay");
}
void AGasaGameMode::FinishRestartPlayer(AController* NewPlayer, const FRotator& StartRotation)
{
// Super::FinishRestartPlayer(NewPlayer, StartRotation);
{
NewPlayer->Possess(NewPlayer->GetPawn());
// If the Pawn is destroyed as part of possession we have to abort
if (!IsValid(NewPlayer->GetPawn()))
{
FailedToRestartPlayer(NewPlayer);
}
else
{
// Set initial control rotation to starting rotation rotation
NewPlayer->ClientSetRotation(NewPlayer->GetPawn()->GetActorRotation(), true);
FRotator NewControllerRot = StartRotation;
NewControllerRot.Roll = 0.f;
NewPlayer->SetControlRotation(NewControllerRot);
SetPlayerDefaults(NewPlayer->GetPawn());
K2_OnRestartPlayer(NewPlayer);
}
}
}
void AGasaGameMode::GenericPlayerInitialization(AController* C)
{
NetLog("GenericPlayerInitialization: " + C->GetName());
// AGameMode::GenericPlayerInitialization(C);
{
APlayerController* PC = Cast<APlayerController>(C);
if (PC != nullptr)
{
// Moved to: void AGasaGameMode::SetPlayerDefaults(APawn* PlayerPawn)
// InitializeHUDForPlayer(Cast<APlayerController>(C));
// Notify the game that we can now be muted and mute others
UpdateGameplayMuteList(PC);
if (GameSession != nullptr)
{
// Tell the player to enable voice by default or use the push to talk method
PC->ClientEnableNetworkVoice(!GameSession->RequiresPushToTalk());
}
ReplicateStreamingStatus(PC);
bool HidePlayer = false, HideHUD = false, DisableMovement = false, DisableTurning = false;
// Check to see if we should start in cinematic mode (matinee movie capture)
if (ShouldStartInCinematicMode(PC, HidePlayer, HideHUD, DisableMovement, DisableTurning))
{
PC->SetCinematicMode(true, HidePlayer, HideHUD, DisableMovement, DisableTurning);
}
}
}
}
TSubclassOf<APlayerController> AGasaGameMode::GetPlayerControllerClassToSpawnForSeamlessTravel(APlayerController* PreviousPlayerController)
{
NetLog("GetPlayerControllerClassToSpawnForSeamlessTravel: " + PreviousPlayerController->GetName());
return Super::GetPlayerControllerClassToSpawnForSeamlessTravel(PreviousPlayerController);
}
void AGasaGameMode::HandleSeamlessTravelPlayer(AController*& Controller)
{
NetLog("HandleSeamlessTravelPlayer: " + Controller->GetName());
// Super::HandleSeamlessTravelPlayer( C );
UE_LOG(LogGameMode, Log, TEXT(">> GameMode::HandleSeamlessTravelPlayer: %s "), * Controller->GetName());
APlayerController* PC = Cast<APlayerController>(Controller);
UClass* PCClassToSpawn = GetPlayerControllerClassToSpawnForSeamlessTravel(PC);
// FUniqueNetIdRepl StoredNativePlatformUniqueNetId = C->GetPlayerState<AGasaPlayerState>()->NativePlatformUniqueNetId;
if (PC && PC->GetClass() != PCClassToSpawn)
{
if (PC->Player != nullptr)
{
// We need to spawn a new PlayerController to replace the old one
APlayerController* const NewPC = SpawnPlayerControllerCommon(PC->IsLocalPlayerController()
? ROLE_SimulatedProxy
: ROLE_AutonomousProxy, PC->GetFocalLocation(), PC->GetControlRotation(), PCClassToSpawn);
if (NewPC == nullptr)
{
NetLog(FString::Printf(
TEXT("Failed to spawn new PlayerController for %s (old class %s)"), *PC->GetHumanReadableName(), *PC->GetClass()->GetName())
, ELogV::Warning
);
PC->Destroy();
return;
}
else
{
PC->SeamlessTravelTo(NewPC);
NewPC->SeamlessTravelFrom(PC);
SwapPlayerControllers(PC, NewPC);
PC = NewPC;
Controller = NewPC;
}
}
else
{
PC->Destroy();
}
}
else
{
// clear out data that was only for the previous game
Controller->PlayerState->Reset();
// create a new PlayerState and copy over info; this is necessary because the old GameMode may have used a different PlayerState class
APlayerState* OldPlayerState = Controller->PlayerState;
Controller->InitPlayerState();
OldPlayerState->SeamlessTravelTo( Controller->PlayerState);
// we don"t need the old PlayerState anymore
//@fixme: need a way to replace PlayerStates that doesn't cause incorrect "player left the game"/"player entered the game" messages
OldPlayerState->Destroy();
}
InitSeamlessTravelPlayer(Controller);
// Initialize hud and other player details, shared with PostLogin
GenericPlayerInitialization(Controller);
if (AGasaGameState* GS = GetGameState<AGasaGameState>())
{
#if 0
UGasaGameInstance* GI = GetGameInstance<UGasaGameInstance>();
int32 NumConnections = GI->SessionSettings.bPublicGame
? GI->SessionSettings.PublicConnections
: GI->SessionSettings.PrivateConnections;
if (GS->OnlinePlayers.Num() < NumConnections)
GS->OnlinePlayers.Init( nullptr, NumConnections );
for (AGasaPlayerState* & PS : GS->OnlinePlayers)
{
if (PS == nullptr)
{
PS = C->GetPlayerState<ASlipgatePlayerState>();
PS->SgID = GS->OnlinePlayers.Find( PS );
break;
}
}
#endif
}
// Controller->GetPlayerState<AGasaPlayerState>()->NativePlatformUniqueNetId = StoredNativePlatformUniqueNetId;
NetLog(FString::Printf(TEXT("HandleSeamlessTravelPlayer: %s"), * Controller->GetName()) );
#if 0
if (PC)
PC->Event_NetOwner_OnGameplayFrameworkInitialized.AddDynamic(this, &ThisClass::OwningClient_OnGameFrameworkInitialized);
#endif
}
void AGasaGameMode::InitializeHUDForPlayer_Implementation(APlayerController* NewPlayer)
{
// Super::InitializeHUDForPlayer_Implementation(NewPlayer);
NewPlayer->ClientSetHUD(HUDClass);
}
void AGasaGameMode::InitSeamlessTravelPlayer(AController* NewController)
{
if (NewController)
NewController->bBlockInput = true;
// GameMode::InitSeamlessTravelPlayer(NewController);
{
// AGameModeBase::InitSeamlessTravelPlayer(NewController);
{
APlayerController* NewPC = Cast<APlayerController>(NewController);
FString ErrorMessage;
if (!UpdatePlayerStartSpot(NewController, TEXT(""), ErrorMessage))
NetLog(FString::Printf( TEXT("InitSeamlessTravelPlayer: %s"), *ErrorMessage), ELogV::Warning);
if (NewPC != nullptr)
{
NewPC->PostSeamlessTravel();
if (MustSpectate(NewPC))
{
NewPC->StartSpectatingOnly();
}
else
{
NewPC->bPlayerIsWaiting = true;
NewPC->ChangeState(NAME_Spectating);
NewPC->ClientGotoState(NAME_Spectating);
}
}
}
APlayerController* NewPC = Cast<APlayerController>(NewController);
if (NewPC != nullptr)
{
SetSeamlessTravelViewTarget(NewPC);
if (!MustSpectate(NewPC))
{
NumPlayers++;
NumTravellingPlayers--;
}
}
else
{
NumBots++;
}
}
NetLog("InitSeamlessTravelPlayer: " + NewController->GetName());
}
void AGasaGameMode::HandleMatchAborted()
{
Super::HandleMatchAborted();
NetLog("HandleMatchAborted");
}
void AGasaGameMode::Logout(AController* Exiting)
{
Super::Logout(Exiting);
Event_OnLogout.Broadcast(Cast<AGasaPlayerController>(Exiting));
NetLog("User Logged out: " + Exiting->GetName());
if (AGasaGameState* GS = Cast<AGasaGameState>(GetWorld()->GetGameState()))
{
#if 0
int32 Index = GS->OnlinePlayers.Find(Exiting->GetPlayerState<AGasaGameState>());
if (Index == INDEX_NONE)
{
NetLog("Could not find exiting player state in online players!", ELogV::Error);
return;
}
GS->OnlinePlayers[Index] = nullptr;
#endif
#if 0
IOnlineSessionPtr const SessionInterface = Online::GetSessionInterface(GetWorld());
if ( ! SessionInterface.IsValid())
{
NetLog("DestoryCurrentSession: Could not get the session interface.", ELogV::Warning);
return;
}
#endif
}
}
void AGasaGameMode::PreLogin(const FString& Options, const FString& Address, const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage)
{
Super::PreLogin(Options, Address, UniqueId, ErrorMessage);
// TODO(Ed): Refuse players if the server is full.
}
void AGasaGameMode::PostLogin(APlayerController* NewPlayer)
{
// AGameMode::PostLogin(NewPlayer);
{
UWorld* World = GetWorld();
// Update player count
if (MustSpectate(NewPlayer))
NumSpectators++;
else if (World->IsInSeamlessTravel() || NewPlayer->HasClientLoadedCurrentWorld())
NumPlayers++;
else
NumTravellingPlayers++;
// Save network address for re-associating with reconnecting player, after stripping out port number
FString Address = NewPlayer->GetPlayerNetworkAddress();
int32 Pos = Address.Find(TEXT(":"), ESearchCase::CaseSensitive);
NewPlayer->PlayerState->SavedNetworkAddress = (Pos > 0) ? Address.Left(Pos) : Address;
// Check if this player is reconnecting and already has PlayerState
FindInactivePlayer(NewPlayer);
}
// AGameModeBase::PostLogin(NewPlayer)
{
// Runs shared initialization that can happen during seamless travel as well
GenericPlayerInitialization(NewPlayer);
// Perform initialization that only happens on initially joining a server
NewPlayer->ClientCapBandwidth(NewPlayer->Player->CurrentNetSpeed);
if (MustSpectate(NewPlayer))
{
NewPlayer->ClientGotoState(NAME_Spectating);
}
else
{
// If NewPlayer is not only a spectator and has a valid ID, add him as a user to the replay.
FUniqueNetIdRepl const&
NewPlayerStateUniqueId = NewPlayer->PlayerState->GetUniqueId();
if (NewPlayerStateUniqueId.IsValid())
{
GetGameInstance()->AddUserToReplay(NewPlayerStateUniqueId.ToString());
}
}
if (GameSession)
{
GameSession->PostLogin(NewPlayer);
}
}
if (AGasaGameState* GS = GetGameState<AGasaGameState>())
{
UGasaGameInstance* GI = GetGameInstance<UGasaGameInstance>();
#if 0
int32 numconnections = GI->sessionsettings.bPublicGame
? GI->SessionSettings.PublicConnections : GI->SessionSettings.PrivateConnections;
if (GS->OnlinePlayers.Num() < NumConnections)
{
GS->OnlinePlayers.Init( nullptr, NumConnections );
}
for (AGasaPlayerState* & PS : GS->OnlinePlayers)
{
if (PS == nullptr)
{
PS = NewPlayer->GetPlayerState<AGasaPlayerState>();
PS->GasaID = GS->OnlinePlayers.Find( PS );
break;
}
}
#endif
}
// cont. AGameModeBase::PostLogin(NewPlayer)
{
// Notify Blueprints that a new player has logged in. Calling it here, because this is the first time that the PlayerController can take RPCs
DispatchPostLogin(NewPlayer);
}
AGasaPlayerController* PC = Cast<AGasaPlayerController>(NewPlayer);
if (PC)
PC->Event_NetOwner_OnGameFrameworkInitialized.AddDynamic(this, &ThisClass::OwningClient_OnGameFrameworkInitialized);
}
void AGasaGameMode::PostSeamlessTravel()
{
Super::PostSeamlessTravel();
NetLog("PostSeamlessTravel");
}
void AGasaGameMode::SetPlayerDefaults(APawn* PlayerPawn)
{
InitializeHUDForPlayer(Cast<APlayerController>(PlayerPawn->GetController()));
Super::SetPlayerDefaults(PlayerPawn);
}
void AGasaGameMode::SetSeamlessTravelViewTarget(APlayerController* PC)
{
Super::SetSeamlessTravelViewTarget(PC);
NetLog("SetSeamlessTravelViewTarget");
}
void AGasaGameMode::StartPlay()
{
if (MatchState == MatchState::EnteringMap)
SetMatchState(MatchState::WaitingToStart);
// Start match is deferred until the framework is considered initialized.
NetLog("StartPlay");
UGasaGameInstance* GI = GetGameInstance<UGasaGameInstance>();
GI->Event_OnGameFrameworkInitialized.AddDynamic(this, &ThisClass::OnGameFrameworkInitialized);
GI->NotifyGameFrameworkClassReady(EGameFrameworkClassFlag::GameMode);
// Not called yet, will wait for initialization of the framework.
//Super::StartPlay();
}
void AGasaGameMode::StartToLeaveMap()
{
NetLog("StartToLeaveMap");
Super::StartToLeaveMap();
}
void AGasaGameMode::SwapPlayerControllers(APlayerController* OldPC, APlayerController* NewPC)
{
NetLog("SwapPlayerControllers");
NetLog("Old: " + OldPC->GetName());
NetLog("New: " + NewPC->GetName());
Super::SwapPlayerControllers(OldPC, NewPC);
}
APlayerController* AGasaGameMode::SpawnPlayerControllerCommon(ENetRole InRemoteRole, FVector const& SpawnLocation, FRotator const& SpawnRotation,
TSubclassOf<APlayerController> InPlayerControllerClass)
{
NetLog("SpawnPlayerControllerCommon");
return Super::SpawnPlayerControllerCommon(InRemoteRole, SpawnLocation, SpawnRotation, InPlayerControllerClass);
}
#pragma endregion GameModeBase