FString AGameModeBase::InitNewPlayer(APlayerController* NewPlayerController, const FUniqueNetIdRepl& UniqueId, const FString& Options, const FString& Portal)
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
// Try calling deprecated version first
FString DeprecatedError = InitNewPlayer(NewPlayerController, UniqueId.GetUniqueNetId(), Options, Portal);
if (DeprecatedError != TEXT("DEPRECATED"))
{
// This means it was implemented in subclass
return DeprecatedError;
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
check(NewPlayerController);
FString ErrorMessage;
// Register the player with the session
GameSession->RegisterPlayer(NewPlayerController, UniqueId.GetUniqueNetId(), UGameplayStatics::HasOption(Options, TEXT("bIsFromInvite")));
// Find a starting spot
AActor* const StartSpot = FindPlayerStart(NewPlayerController, Portal);
if (StartSpot != nullptr)
{
// Set the player controller / camera in this new location
FRotator InitialControllerRot = StartSpot->GetActorRotation();
InitialControllerRot.Roll = 0.f;
NewPlayerController->SetInitialLocationAndRotation(StartSpot->GetActorLocation(), InitialControllerRot);
NewPlayerController->StartSpot = StartSpot;
}
else
{
ErrorMessage = FString::Printf(TEXT("Failed to find PlayerStart"));
}
// Set up spectating
bool bSpectator = FCString::Stricmp(*UGameplayStatics::ParseOption(Options, TEXT("SpectatorOnly")), TEXT("1")) == 0;
if (bSpectator || MustSpectate(NewPlayerController))
{
NewPlayerController->StartSpectatingOnly();
}
// Init player's name
FString InName = UGameplayStatics::ParseOption(Options, TEXT("Name")).Left(20);
if (InName.IsEmpty())
{
InName = FString::Printf(TEXT("%s%i"), *DefaultPlayerName.ToString(), NewPlayerController->PlayerState->PlayerId);
}
ChangeName(NewPlayerController, InName, false);
return ErrorMessage;
}
void APartyBeaconHost::HandlePlayerLogout(const FUniqueNetIdRepl& PlayerId)
{
if (PlayerId.IsValid())
{
UE_LOG(LogBeacon, Verbose, TEXT("HandlePlayerLogout %s"), *PlayerId->ToDebugString());
if (State)
{
if (State->RemovePlayer(PlayerId))
{
ReservationChanged.ExecuteIfBound();
}
}
}
}
void FPlayerMuteList::ServerMutePlayer(APlayerController* OwningPC, const FUniqueNetIdRepl& MuteId)
{
UWorld* World = OwningPC->GetWorld();
const TSharedPtr<const FUniqueNetId>& PlayerIdToMute = MuteId.GetUniqueNetId();
// Don't reprocess if they are already muted
AddIdToMuteList(VoiceMuteList, PlayerIdToMute);
// Add them to the packet filter list if not already on it
AddIdToMuteList(VoicePacketFilter, PlayerIdToMute);
// Replicate mute state to client
OwningPC->ClientMutePlayer(MuteId);
// Find the muted player's player controller so it can be notified
APlayerController* OtherPC = GetPlayerControllerFromNetId(World, *PlayerIdToMute);
if (OtherPC != NULL)
{
// Update their packet filter list too
OtherPC->MuteList.ClientMutePlayer(OtherPC, OwningPC->PlayerState->UniqueId);
// Tell the other PC to mute this one
OtherPC->ClientMutePlayer(OwningPC->PlayerState->UniqueId);
}
}
void FPlayerMuteList::GameplayUnmutePlayer(APlayerController* OwningPC, const FUniqueNetIdRepl& UnmuteId)
{
UWorld* World = OwningPC->GetWorld();
const TSharedPtr<const FUniqueNetId>& PlayerIdToUnmute = UnmuteId.GetUniqueNetId();
// Remove from the gameplay mute list
RemoveIdFromMuteList(GameplayVoiceMuteList, PlayerIdToUnmute);
// Find the muted player's player controller so it can be notified
APlayerController* OtherPC = GetPlayerControllerFromNetId(World, *PlayerIdToUnmute);
if (OtherPC != NULL)
{
FUniqueNetIdMatcher PlayerIdToUnmuteMatch(*PlayerIdToUnmute);
FUniqueNetIdMatcher OwningPlayerIdMatch(*OwningPC->PlayerState->UniqueId);
// Make sure this player isn't explicitly muted
if (VoiceMuteList.IndexOfByPredicate(PlayerIdToUnmuteMatch) == INDEX_NONE &&
// And make sure they didn't mute us
OtherPC->MuteList.VoiceMuteList.IndexOfByPredicate(OwningPlayerIdMatch) == INDEX_NONE)
{
RemoveIdFromMuteList(VoicePacketFilter, PlayerIdToUnmute);
// Now process on the client
OwningPC->ClientUnmutePlayer(UnmuteId);
}
}
}
void APartyBeaconHost::HandlePlayerLogout(const FUniqueNetIdRepl& PlayerId)
{
if (PlayerId.IsValid())
{
UE_LOG(LogBeacon, Verbose, TEXT("HandlePlayerLogout %s"), *PlayerId->ToDebugString());
if (State)
{
if (State->RemovePlayer(PlayerId))
{
SendReservationUpdates();
NotifyReservationEventNextFrame(ReservationChanged);
}
}
}
}
bool UPartyBeaconState::RemovePlayer(const FUniqueNetIdRepl& PlayerId)
{
bool bWasRemoved = false;
for (int32 ResIdx = 0; ResIdx < Reservations.Num() && !bWasRemoved; ResIdx++)
{
FPartyReservation& Reservation = Reservations[ResIdx];
if (Reservation.PartyLeader == PlayerId)
{
UE_LOG(LogBeacon, Display, TEXT("Party leader has left the party"), *PlayerId.ToString());
// Maintain existing members of party reservation that lost its leader
for (int32 PlayerIdx = 0; PlayerIdx < Reservation.PartyMembers.Num(); PlayerIdx++)
{
FPlayerReservation& PlayerEntry = Reservation.PartyMembers[PlayerIdx];
if (PlayerEntry.UniqueId != Reservation.PartyLeader && PlayerEntry.UniqueId.IsValid())
{
// Promote to party leader (for now)
Reservation.PartyLeader = PlayerEntry.UniqueId;
break;
}
}
}
// find the player in an existing reservation slot
for (int32 PlayerIdx = 0; PlayerIdx < Reservation.PartyMembers.Num(); PlayerIdx++)
{
FPlayerReservation& PlayerEntry = Reservation.PartyMembers[PlayerIdx];
if (PlayerEntry.UniqueId == PlayerId)
{
// player removed
Reservation.PartyMembers.RemoveAtSwap(PlayerIdx--);
bWasRemoved = true;
// free up a consumed entry
NumConsumedReservations--;
}
}
// remove the entire party reservation slot if no more party members
if (Reservation.PartyMembers.Num() == 0)
{
Reservations.RemoveAtSwap(ResIdx--);
}
}
if (bWasRemoved)
{
// Reshuffle existing teams so that beacon can accommodate biggest open slots
BestFitTeamAssignmentJiggle();
}
return bWasRemoved;
}
void APartyBeaconHost::HandlePlayerLogout(const FUniqueNetIdRepl& PlayerId)
{
if (PlayerId.IsValid())
{
bool bWasRemoved = false;
UE_LOG(LogBeacon, Verbose, TEXT("HandlePlayerLogout %s"), *PlayerId->ToDebugString());
for (int32 ResIdx=0; ResIdx < Reservations.Num(); ResIdx++)
{
FPartyReservation& Reservation = Reservations[ResIdx];
// find the player in an existing reservation slot
for (int32 PlayerIdx=0; PlayerIdx < Reservation.PartyMembers.Num(); PlayerIdx++)
{
FPlayerReservation& PlayerEntry = Reservation.PartyMembers[PlayerIdx];
if (PlayerEntry.UniqueId == PlayerId)
{
// player removed
Reservation.PartyMembers.RemoveAtSwap(PlayerIdx--);
bWasRemoved = true;
// free up a consumed entry
NumConsumedReservations--;
}
}
// remove the entire party reservation slot if no more party members
if (Reservation.PartyMembers.Num() == 0)
{
Reservations.RemoveAtSwap(ResIdx--);
}
if (bWasRemoved)
{
ReservationChanged.ExecuteIfBound();
break;
}
}
}
}
void FPlayerMuteList::GameplayMutePlayer(APlayerController* OwningPC, const FUniqueNetIdRepl& MuteId)
{
const TSharedPtr<const FUniqueNetId>& PlayerIdToMute = MuteId.GetUniqueNetId();
// Don't add if already muted
AddIdToMuteList(GameplayVoiceMuteList, PlayerIdToMute);
// Add to the filter list, if missing
AddIdToMuteList(VoicePacketFilter, PlayerIdToMute);
// Now process on the client
OwningPC->ClientMutePlayer(MuteId);
}
void AGameModeBase::PreLogin(const FString& Options, const FString& Address, const FUniqueNetIdRepl& UniqueId, FString& ErrorMessage)
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
// Try calling deprecated version first
PreLogin(Options, Address, UniqueId.GetUniqueNetId(), ErrorMessage);
if (!ErrorMessage.IsEmpty())
{
return;
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
ErrorMessage = GameSession->ApproveLogin(Options);
}
void UPartyBeaconState::RegisterAuthTicket(const FUniqueNetIdRepl& InPartyMemberId, const FString& InAuthTicket)
{
if (InPartyMemberId.IsValid() && !InAuthTicket.IsEmpty())
{
bool bFoundReservation = false;
for (int32 ResIdx = 0; ResIdx < Reservations.Num() && !bFoundReservation; ResIdx++)
{
FPartyReservation& ReservationEntry = Reservations[ResIdx];
FPlayerReservation* PlayerRes = ReservationEntry.PartyMembers.FindByPredicate(
[InPartyMemberId](const FPlayerReservation& ExistingPlayerRes)
{
return InPartyMemberId == ExistingPlayerRes.UniqueId;
});
if (PlayerRes)
{
UE_LOG(LogBeacon, Display, TEXT("Updating auth ticket for member %s."), *InPartyMemberId.ToString());
if (!PlayerRes->ValidationStr.IsEmpty() && PlayerRes->ValidationStr != InAuthTicket)
{
UE_LOG(LogBeacon, Display, TEXT("Auth ticket changing for member %s."), *InPartyMemberId.ToString());
}
PlayerRes->ValidationStr = InAuthTicket;
bFoundReservation = true;
break;
}
}
if (!bFoundReservation)
{
UE_LOG(LogBeacon, Warning, TEXT("Found no reservation for player %s, while registering auth ticket."), *InPartyMemberId.ToString());
}
}
}
void FPlayerMuteList::ClientMutePlayer(APlayerController* OwningPC, const FUniqueNetIdRepl& MuteId)
{
const TSharedPtr<const FUniqueNetId>& PlayerIdToMute = MuteId.GetUniqueNetId();
// Add to the filter list on clients (used for peer to peer voice)
AddIdToMuteList(VoicePacketFilter, PlayerIdToMute);
// Use the local player to determine the controller id
ULocalPlayer* LP = Cast<ULocalPlayer>(OwningPC->Player);
if (LP != NULL)
{
UWorld* World = OwningPC->GetWorld();
IOnlineVoicePtr VoiceInt = Online::GetVoiceInterface(World);
if (VoiceInt.IsValid())
{
// Have the voice subsystem mute this player
VoiceInt->MuteRemoteTalker(LP->GetControllerId(), *PlayerIdToMute, false);
}
}
}
void FPlayerMuteList::ServerUnmutePlayer(APlayerController* OwningPC, const FUniqueNetIdRepl& UnmuteId)
{
UWorld* World = OwningPC->GetWorld();
const TSharedPtr<const FUniqueNetId>& PlayerIdToUnmute = UnmuteId.GetUniqueNetId();
// If the player was found, remove them from our explicit list
RemoveIdFromMuteList(VoiceMuteList, PlayerIdToUnmute);
// Find the muted player's player controller so it can be notified
APlayerController* OtherPC = GetPlayerControllerFromNetId(World, *PlayerIdToUnmute);
if (OtherPC != NULL)
{
FUniqueNetIdMatcher PlayerIdToUnmuteMatch(*PlayerIdToUnmute);
FUniqueNetIdMatcher OwningPlayerIdMatch(*OwningPC->PlayerState->UniqueId);
// Make sure this player isn't muted for gameplay reasons
if (GameplayVoiceMuteList.IndexOfByPredicate(PlayerIdToUnmuteMatch) == INDEX_NONE &&
// And make sure they didn't mute us
OtherPC->MuteList.VoiceMuteList.IndexOfByPredicate(OwningPlayerIdMatch) == INDEX_NONE)
{
OwningPC->ClientUnmutePlayer(UnmuteId);
}
// If the other player doesn't have this player muted
if (OtherPC->MuteList.VoiceMuteList.IndexOfByPredicate(OwningPlayerIdMatch) == INDEX_NONE &&
OtherPC->MuteList.GameplayVoiceMuteList.IndexOfByPredicate(OwningPlayerIdMatch) == INDEX_NONE)
{
// Remove them from the packet filter list
RemoveIdFromMuteList(VoicePacketFilter, PlayerIdToUnmute);
// If found, remove so packets flow to that client too
RemoveIdFromMuteList(OtherPC->MuteList.VoicePacketFilter, OwningPC->PlayerState->UniqueId.GetUniqueNetId());
// Tell the other PC to unmute this one
OtherPC->ClientUnmutePlayer(OwningPC->PlayerState->UniqueId);
}
}
}
void TestUniqueIdRepl(UWorld* InWorld)
{
#if !UE_BUILD_SHIPPING
bool bSuccess = true;
TSharedPtr<const FUniqueNetId> UserId = UOnlineEngineInterface::Get()->GetUniquePlayerId(InWorld, 0);
FUniqueNetIdRepl EmptyIdIn;
if (EmptyIdIn.IsValid())
{
UE_LOG(LogNet, Warning, TEXT("EmptyId is valid."), *EmptyIdIn->ToString());
bSuccess = false;
}
FUniqueNetIdRepl ValidIdIn(UserId);
if (!ValidIdIn.IsValid() || UserId != ValidIdIn.GetUniqueNetId() || *UserId != *ValidIdIn)
{
UE_LOG(LogNet, Warning, TEXT("UserId input %s != UserId output %s"), *UserId->ToString(), *ValidIdIn->ToString());
bSuccess = false;
}
if (bSuccess)
{
TArray<uint8> Buffer;
for (int32 i = 0; i < 2; i++)
{
Buffer.Empty();
FMemoryWriter TestWriteUniqueId(Buffer);
if (i == 0)
{
// Normal serialize
TestWriteUniqueId << EmptyIdIn;
TestWriteUniqueId << ValidIdIn;
}
else
{
// Net serialize
bool bOutSuccess = false;
EmptyIdIn.NetSerialize(TestWriteUniqueId, NULL, bOutSuccess);
ValidIdIn.NetSerialize(TestWriteUniqueId, NULL, bOutSuccess);
}
FMemoryReader TestReadUniqueId(Buffer);
FUniqueNetIdRepl EmptyIdOut;
TestReadUniqueId << EmptyIdOut;
if (EmptyIdOut.GetUniqueNetId().IsValid())
{
UE_LOG(LogNet, Warning, TEXT("EmptyId %s should have been invalid"), *EmptyIdOut->ToString());
bSuccess = false;
}
FUniqueNetIdRepl ValidIdOut;
TestReadUniqueId << ValidIdOut;
if (*UserId != *ValidIdOut.GetUniqueNetId())
{
UE_LOG(LogNet, Warning, TEXT("UserId input %s != UserId output %s"), *ValidIdIn->ToString(), *ValidIdOut->ToString());
bSuccess = false;
}
}
}
if (bSuccess)
{
FString OutString;
TSharedRef<FJsonValue> JsonValue = ValidIdIn.ToJson();
bSuccess = JsonValue->TryGetString(OutString);
if (bSuccess)
{
FUniqueNetIdRepl NewIdOut;
NewIdOut.FromJson(OutString);
bSuccess = NewIdOut.IsValid();
}
}
if (!bSuccess)
{
UE_LOG(LogNet, Warning, TEXT("TestUniqueIdRepl test failure!"));
}
#endif
}
void APartyBeaconHost::RemovePartyReservation(const FUniqueNetIdRepl& PartyLeader)
{
const int32 ExistingReservationIdx = GetExistingReservation(PartyLeader);
if (ExistingReservationIdx != INDEX_NONE)
{
NumConsumedReservations -= Reservations[ExistingReservationIdx].PartyMembers.Num();
Reservations.RemoveAtSwap(ExistingReservationIdx);
CancelationReceived.ExecuteIfBound(*PartyLeader);
ReservationChanged.ExecuteIfBound();
}
else
{
UE_LOG(LogBeacon, Warning, TEXT("Failed to find reservation to cancel for leader %s:"), *PartyLeader->ToString());
}
}
void AOnlineBeaconHost::NotifyControlMessage(UNetConnection* Connection, uint8 MessageType, class FInBunch& Bunch)
{
if(NetDriver->ServerConnection == nullptr)
{
bool bCloseConnection = false;
// We are the server.
#if !(UE_BUILD_SHIPPING && WITH_EDITOR)
UE_LOG(LogBeacon, Verbose, TEXT("%s[%s] Host received: %s"), *GetName(), Connection ? *Connection->GetName() : TEXT("Invalid"), FNetControlMessageInfo::GetName(MessageType));
#endif
switch (MessageType)
{
case NMT_Hello:
{
UE_LOG(LogBeacon, Log, TEXT("Beacon Hello"));
uint8 IsLittleEndian;
uint32 RemoteNetworkVersion = 0;
uint32 LocalNetworkVersion = FNetworkVersion::GetLocalNetworkVersion();
FNetControlMessage<NMT_Hello>::Receive(Bunch, IsLittleEndian, RemoteNetworkVersion);
if (!FNetworkVersion::IsNetworkCompatible(LocalNetworkVersion, RemoteNetworkVersion))
{
UE_LOG(LogBeacon, Log, TEXT("Client not network compatible %s"), *Connection->GetName());
FNetControlMessage<NMT_Upgrade>::Send(Connection, LocalNetworkVersion);
bCloseConnection = true;
}
else
{
Connection->Challenge = FString::Printf(TEXT("%08X"), FPlatformTime::Cycles());
FNetControlMessage<NMT_BeaconWelcome>::Send(Connection);
Connection->FlushNet();
}
break;
}
case NMT_Netspeed:
{
int32 Rate;
FNetControlMessage<NMT_Netspeed>::Receive(Bunch, Rate);
Connection->CurrentNetSpeed = FMath::Clamp(Rate, 1800, NetDriver->MaxClientRate);
UE_LOG(LogBeacon, Log, TEXT("Client netspeed is %i"), Connection->CurrentNetSpeed);
break;
}
case NMT_BeaconJoin:
{
FString ErrorMsg;
FString BeaconType;
FUniqueNetIdRepl UniqueId;
FNetControlMessage<NMT_BeaconJoin>::Receive(Bunch, BeaconType, UniqueId);
UE_LOG(LogBeacon, Log, TEXT("Beacon Join %s %s"), *BeaconType, *UniqueId.ToDebugString());
if (Connection->ClientWorldPackageName == NAME_None)
{
AOnlineBeaconClient* ClientActor = GetClientActor(Connection);
if (ClientActor == nullptr)
{
UWorld* World = GetWorld();
Connection->ClientWorldPackageName = World->GetOutermost()->GetFName();
AOnlineBeaconClient* NewClientActor = nullptr;
FOnBeaconSpawned* OnBeaconSpawnedDelegate = OnBeaconSpawnedMapping.Find(BeaconType);
if (OnBeaconSpawnedDelegate && OnBeaconSpawnedDelegate->IsBound())
{
NewClientActor = OnBeaconSpawnedDelegate->Execute(Connection);
}
if (NewClientActor && BeaconType == NewClientActor->GetBeaconType())
{
NewClientActor->SetConnectionState(EBeaconConnectionState::Pending);
FNetworkGUID NetGUID = Connection->Driver->GuidCache->AssignNewNetGUID_Server(NewClientActor);
NewClientActor->SetNetConnection(Connection);
Connection->PlayerId = UniqueId;
Connection->OwningActor = NewClientActor;
NewClientActor->Role = ROLE_Authority;
NewClientActor->SetReplicates(false);
check(NetDriverName == NetDriver->NetDriverName);
NewClientActor->SetNetDriverName(NetDriverName);
ClientActors.Add(NewClientActor);
FNetControlMessage<NMT_BeaconAssignGUID>::Send(Connection, NetGUID);
}
else
{
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnFailureError", "Join failure, Couldn't spawn beacon.").ToString();
}
}
else
{
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnExistingActorError", "Join failure, existing beacon actor.").ToString();
}
}
else
{
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnClientWorldPackageNameError", "Join failure, existing ClientWorldPackageName.").ToString();
}
if (!ErrorMsg.IsEmpty())
{
UE_LOG(LogBeacon, Log, TEXT("%s: %s"), *Connection->GetName(), *ErrorMsg);
FNetControlMessage<NMT_Failure>::Send(Connection, ErrorMsg);
bCloseConnection = true;
}
break;
}
case NMT_BeaconNetGUIDAck:
{
FString ErrorMsg;
FString BeaconType;
FNetControlMessage<NMT_BeaconNetGUIDAck>::Receive(Bunch, BeaconType);
AOnlineBeaconClient* ClientActor = GetClientActor(Connection);
if (ClientActor && BeaconType == ClientActor->GetBeaconType())
{
FOnBeaconConnected* OnBeaconConnectedDelegate = OnBeaconConnectedMapping.Find(BeaconType);
if (OnBeaconConnectedDelegate)
{
ClientActor->SetReplicates(true);
ClientActor->SetAutonomousProxy(true);
ClientActor->SetConnectionState(EBeaconConnectionState::Open);
// Send an RPC to the client to open the actor channel and guarantee RPCs will work
ClientActor->ClientOnConnected();
UE_LOG(LogBeacon, Log, TEXT("Handshake complete for %s!"), *ClientActor->GetName());
OnBeaconConnectedDelegate->ExecuteIfBound(ClientActor, Connection);
}
else
{
// Failed to connect.
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnNetGUIDAckError1", "Join failure, no host object at NetGUIDAck.").ToString();
}
}
else
{
// Failed to connect.
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnNetGUIDAckError2", "Join failure, no actor at NetGUIDAck.").ToString();
}
if (!ErrorMsg.IsEmpty())
{
UE_LOG(LogBeacon, Log, TEXT("%s: %s"), *Connection->GetName(), *ErrorMsg);
FNetControlMessage<NMT_Failure>::Send(Connection, ErrorMsg);
bCloseConnection = true;
}
break;
}
case NMT_BeaconWelcome:
case NMT_BeaconAssignGUID:
default:
{
FString ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnUnexpectedError", "Join failure, unexpected control message.").ToString();
UE_LOG(LogBeacon, Log, TEXT("%s: %s"), *Connection->GetName(), *ErrorMsg);
FNetControlMessage<NMT_Failure>::Send(Connection, ErrorMsg);
bCloseConnection = true;
}
break;
}
if (bCloseConnection)
{
UE_LOG(LogBeacon, Verbose, TEXT("Closing connection %s: %s"), *Connection->GetName(), *Connection->PlayerId.ToDebugString());
AOnlineBeaconClient* ClientActor = GetClientActor(Connection);
if (ClientActor)
{
UE_LOG(LogBeacon, Verbose, TEXT("- BeaconActor: %s %s"), *ClientActor->GetName(), *ClientActor->GetBeaconType());
AOnlineBeaconHostObject* BeaconHostObject = GetHost(ClientActor->GetBeaconType());
if (BeaconHostObject)
{
UE_LOG(LogBeacon, Verbose, TEXT("- HostObject: %s"), *BeaconHostObject->GetName());
BeaconHostObject->NotifyClientDisconnected(ClientActor);
}
RemoveClientActor(ClientActor);
}
Connection->FlushNet(true);
Connection->Close();
UE_LOG(LogBeacon, Verbose, TEXT("--------------------------------"));
}
}
}
void APartyBeaconHost::RemovePartyReservation(const FUniqueNetIdRepl& PartyLeader)
{
if (State && State->RemoveReservation(PartyLeader))
{
CancelationReceived.ExecuteIfBound(*PartyLeader);
SendReservationUpdates();
NotifyReservationEventNextFrame(ReservationChanged);
}
else
{
UE_LOG(LogBeacon, Warning, TEXT("Failed to find reservation to cancel for leader %s:"), PartyLeader.IsValid() ? *PartyLeader->ToString() : TEXT("INVALID") );
}
}
void TestUniqueIdRepl(UWorld* InWorld)
{
bool bSuccess = true;
IOnlineIdentityPtr IdentityPtr = Online::GetIdentityInterface(InWorld);
if (IdentityPtr.IsValid())
{
TSharedPtr<FUniqueNetId> UserId = IdentityPtr->GetUniquePlayerId(0);
FUniqueNetIdRepl EmptyIdIn;
if (EmptyIdIn.IsValid())
{
UE_LOG(LogNet, Warning, TEXT("EmptyId is valid."), *EmptyIdIn->ToString());
bSuccess = false;
}
FUniqueNetIdRepl ValidIdIn(UserId);
if (!ValidIdIn.IsValid() || UserId != ValidIdIn.GetUniqueNetId())
{
UE_LOG(LogNet, Warning, TEXT("UserId input %s != UserId output %s"), *UserId->ToString(), *ValidIdIn->ToString());
bSuccess = false;
}
if (bSuccess)
{
TArray<uint8> Buffer;
for (int32 i=0; i<2; i++)
{
Buffer.Empty();
FMemoryWriter TestWriteUniqueId(Buffer);
if (i == 0)
{
// Normal serialize
TestWriteUniqueId << EmptyIdIn;
TestWriteUniqueId << ValidIdIn;
}
else
{
// Net serialize
bool bSuccess = false;
EmptyIdIn.NetSerialize(TestWriteUniqueId, NULL, bSuccess);
ValidIdIn.NetSerialize(TestWriteUniqueId, NULL, bSuccess);
}
FMemoryReader TestReadUniqueId(Buffer);
FUniqueNetIdRepl EmptyIdOut;
TestReadUniqueId << EmptyIdOut;
if (EmptyIdOut.GetUniqueNetId().IsValid())
{
UE_LOG(LogNet, Warning, TEXT("EmptyId %s should have been invalid"), *EmptyIdOut->ToString());
bSuccess = false;
}
FUniqueNetIdRepl ValidIdOut;
TestReadUniqueId << ValidIdOut;
if (*UserId != *ValidIdOut.GetUniqueNetId())
{
UE_LOG(LogNet, Warning, TEXT("UserId input %s != UserId output %s"), *ValidIdIn->ToString(), *ValidIdOut->ToString());
bSuccess = false;
}
}
}
}
if (!bSuccess)
{
UE_LOG(LogNet, Warning, TEXT("TestUniqueIdRepl test failure!"));
}
}
void APartyBeaconHost::RemovePartyReservation(const FUniqueNetIdRepl& PartyLeader)
{
if (State && State->RemoveReservation(PartyLeader))
{
CancelationReceived.ExecuteIfBound(*PartyLeader);
ReservationChanged.ExecuteIfBound();
}
else
{
UE_LOG(LogBeacon, Warning, TEXT("Failed to find reservation to cancel for leader %s:"), *PartyLeader->ToString());
}
}
void APartyBeaconHost::DumpReservations() const
{
FUniqueNetIdRepl NetId;
FPlayerReservation PlayerRes;
UE_LOG(LogBeacon, Display, TEXT("Debug info for Beacon: %s"), *BeaconName);
UE_LOG(LogBeacon, Display, TEXT("Session that reservations are for: %s"), *SessionName.ToString());
UE_LOG(LogBeacon, Display, TEXT("Number of teams: %d"), NumTeams);
UE_LOG(LogBeacon, Display, TEXT("Number players per team: %d"), NumPlayersPerTeam);
UE_LOG(LogBeacon, Display, TEXT("Number total reservations: %d"), MaxReservations);
UE_LOG(LogBeacon, Display, TEXT("Number consumed reservations: %d"), NumConsumedReservations);
UE_LOG(LogBeacon, Display, TEXT("Number of party reservations: %d"), Reservations.Num());
// Log each party that has a reservation
for (int32 PartyIndex = 0; PartyIndex < Reservations.Num(); PartyIndex++)
{
NetId = Reservations[PartyIndex].PartyLeader;
UE_LOG(LogBeacon, Display, TEXT(" Party leader: %s"), *NetId->ToString());
UE_LOG(LogBeacon, Display, TEXT(" Party team: %d"), Reservations[PartyIndex].TeamNum);
UE_LOG(LogBeacon, Display, TEXT(" Party size: %d"), Reservations[PartyIndex].PartyMembers.Num());
// Log each member of the party
for (int32 MemberIndex = 0; MemberIndex < Reservations[PartyIndex].PartyMembers.Num(); MemberIndex++)
{
PlayerRes = Reservations[PartyIndex].PartyMembers[MemberIndex];
UE_LOG(LogBeacon, Display, TEXT(" Party member: %s"), *PlayerRes.UniqueId->ToString());
}
}
UE_LOG(LogBeacon, Display, TEXT(""));
}
void UPartyBeaconState::UpdatePartyLeader(const FUniqueNetIdRepl& InPartyMemberId, const FUniqueNetIdRepl& NewPartyLeaderId)
{
if (InPartyMemberId.IsValid() && NewPartyLeaderId.IsValid())
{
bool bFoundReservation = false;
for (int32 ResIdx = 0; ResIdx < Reservations.Num() && !bFoundReservation; ResIdx++)
{
FPartyReservation& ReservationEntry = Reservations[ResIdx];
FPlayerReservation* PlayerRes = ReservationEntry.PartyMembers.FindByPredicate(
[InPartyMemberId](const FPlayerReservation& ExistingPlayerRes)
{
return InPartyMemberId == ExistingPlayerRes.UniqueId;
});
if (PlayerRes)
{
UE_LOG(LogBeacon, Display, TEXT("Updating party leader to %s from member %s."), *NewPartyLeaderId.ToString(), *InPartyMemberId.ToString());
ReservationEntry.PartyLeader = NewPartyLeaderId;
bFoundReservation = true;
break;
}
}
if (!bFoundReservation)
{
UE_LOG(LogBeacon, Warning, TEXT("Found no reservation for player %s, while updating party leader."), *InPartyMemberId.ToString());
}
}
}
bool UPartyBeaconState::GetPartyLeader(const FUniqueNetIdRepl& InPartyMemberId, FUniqueNetIdRepl& OutPartyLeaderId) const
{
bool bFoundReservation = false;
if (InPartyMemberId.IsValid())
{
for (int32 ResIdx = 0; ResIdx < Reservations.Num() && !bFoundReservation; ResIdx++)
{
const FPartyReservation& ReservationEntry = Reservations[ResIdx];
const FPlayerReservation* PlayerRes = ReservationEntry.PartyMembers.FindByPredicate(
[InPartyMemberId](const FPlayerReservation& ExistingPlayerRes)
{
return InPartyMemberId == ExistingPlayerRes.UniqueId;
});
if (PlayerRes)
{
UE_LOG(LogBeacon, Display, TEXT("Found party leader for member %s."), *InPartyMemberId.ToString());
OutPartyLeaderId = ReservationEntry.PartyLeader;
bFoundReservation = true;
break;
}
}
if (!bFoundReservation)
{
UE_LOG(LogBeacon, Warning, TEXT("Found no reservation for player %s, while looking for party leader."), *InPartyMemberId.ToString());
}
}
return bFoundReservation;
}
void AGameSession::UnregisterPlayer(FName InSessionName, const FUniqueNetIdRepl& UniqueId)
{
UWorld* World = GetWorld();
if (GetNetMode() != NM_Standalone &&
UniqueId.IsValid() &&
UniqueId->IsValid())
{
// Remove the player from the session
UOnlineEngineInterface::Get()->UnregisterPlayer(World, InSessionName, *UniqueId);
}
}
void APartyBeaconHost::ProcessCancelReservationRequest(APartyBeaconClient* Client, const FUniqueNetIdRepl& PartyLeader)
{
UE_LOG(LogBeacon, Verbose, TEXT("ProcessCancelReservationRequest %s PartyLeader: %s from (%s)"),
Client ? *Client->GetName() : TEXT("NULL"),
PartyLeader.IsValid() ? *PartyLeader->ToString() : TEXT("INVALID"),
Client ? *Client->GetNetConnection()->LowLevelDescribe() : TEXT("NULL"));
if (Client)
{
RemovePartyReservation(PartyLeader);
}
}
