اتصال اللاعبين

#include "FlockSubsystem.h"
#include "Multiplayer/FlockMultiplayerSession.h"

// Every player's game, the host's included, once it holds the session.
TravelOptions.HostLevel = TEXT("/Game/Maps/Arena");   // the level the host opens; players travel to whatever the host has open
const TWeakObjectPtr<UMyGameInstance> Game = this;
Session->TravelToSession(this, TravelOptions, [Game](TFlockResult<FFlockTravelToSessionResult> Result)
{
    if (!Game.IsValid())
    {
        return;
    }
    if (!Result.IsSuccess())
    {
        UE_LOG(LogTemp, Warning, TEXT("%s"), *Result.Error.ToDisplayText());   // a mistake, a refused publish or a cancel, with its fix
        return;
    }
    const FFlockTravelToSessionResult& Travel = Result.Value;
    if (Travel.Outcome == FlockTravelToSessionOutcomes::Restarted)
    {
        return;   // a newer Travel To Session took over
    }
    if (Travel.Outcome == FlockTravelToSessionOutcomes::StartedAsHost)
    {
        Game->ShowMessage(TEXT("Hosting. Code: ") + Game->Session->GetJoinCode());
    }
    else if (Travel.Outcome == FlockTravelToSessionOutcomes::Connected)
    {
        Game->ShowMessage(Travel.bThroughRelay ? TEXT("Connected through Flock's relay.") : TEXT("Connected."));
    }
    else if (Travel.Outcome == FlockTravelToSessionOutcomes::Refused)
    {
        Game->ShowMessage(TEXT("The host refused you: ") + Travel.RefusedReason);
    }
    else if (Travel.Outcome == FlockTravelToSessionOutcomes::RelayFailed)
    {
        Game->ShowMessage(TEXT("The relay could not be used: ") + Travel.RelayFailureReason);
    }
    else
    {
        Game->ShowMessage(TEXT("Could not connect: ") + Travel.Outcome);
    }
});

// MyGameMode.h
virtual void PreLoginAsync(const FString& Options, const FString& Address, const FUniqueNetIdRepl& UniqueId,
    const FOnPreLoginCompleteDelegate& OnComplete) override;

// MyGameMode.cpp
#include "Multiplayer/FlockJoinChecks.h"

void AMyGameMode::PreLoginAsync(const FString& Options, const FString& Address, const FUniqueNetIdRepl& UniqueId,
    const FOnPreLoginCompleteDelegate& OnComplete)
{
    // Flock's check, then the engine's own (PreLogin, such as a full game), then your own below.
    const TWeakObjectPtr<AMyGameMode> Mode = this;
    FlockJoinChecks::CheckJoiningPlayer(this, Options, Address, UniqueId, OnComplete,
        [Mode](const FFlockJoiningPlayer& Player, FString& OutRefusedReason)
        {
            if (Mode.IsValid() && Mode->IsBanned(Player.PlayerId))
            {
                OutRefusedReason = TEXT("banned");   // the joining player's RefusedReason
                return false;
            }
            return true;
        });
}

FString PlayerId = Session->PlayerForConnection(PlayerController);   // empty for a connection Flock's check did not let in

// Once the session is held.
Session->OnHostChanged.AddDynamic(this, &UMyGameInstance::PlayAgain);
Session->OnRelayLost.AddDynamic(this, &UMyGameInstance::PlayAgainAfterRelayLost);

void UMyGameInstance::PlayAgain()
{
    if (!Session->HasEnded())
    {
        Session->TravelToSession(this, TravelOptions, [](TFlockResult<FFlockTravelToSessionResult> Result)
        {
            // restarted: a newer call took over, and its own answer follows.
        });
    }
}

void UMyGameInstance::PlayAgainAfterRelayLost(const FString& Reason)
{
    PlayAgain();
}

// The host says how to reach it: a mode of its own (32 characters at most) and the values it needs, under 4 KB.
Session->PublishConnection(TEXT("steam"), FFlockCommandData().Set(TEXT("lobby"), LobbyId), nullptr);

// A player waits for it: the session comes back with HasConnection(), HasEnded(), or neither when the time passes.
Session->WaitForConnection(60.f, [this](TFlockResult<UFlockMultiplayerSession*> Waited)
{
    FString Lobby;
    if (Waited.IsSuccess() && Waited.Value->HasConnection()
        && Waited.Value->GetConnection().Mode.Equals(TEXT("steam"), ESearchCase::CaseSensitive)
        && Waited.Value->GetConnection().Values.TryGetString(TEXT("lobby"), Lobby))
    {
        JoinSteamLobby(Lobby);
    }
});

// The player proves its seat with a token, good for 60 seconds, sent over your own networking.
Session->RequestJoinToken([this](TFlockResult<FFlockMultiplayerSessionJoinToken> Token)
{
    if (Token.IsSuccess()) { SendToHost(Token.Value.Token); }
});

// The host checks it and learns who the player is; a bad token fails with MultiplayerInvalidJoinToken.
Session->VerifyJoinToken(TokenFromPlayer, [this](TFlockResult<FString> PlayerId) { /* PlayerId.Value */ });