Party

In order to access online features, the player must be logged in with the Online Subsystem. Please visit the Logging In page for more information.

Overview

Parties can be created directly in the main menu. The player who creates the party will become the party host. Other players will be able to connect to the party by accepting a party invite, or by matchmaking for it (if the party is not private of course). When the party host is joining a session, party clients will automatically follow the host into the session.

Parties are implemented using OnlineBeacons. Let's take a look at the different classes that make up a party.

Class	Description
KronosPartyListener	Beacon listening for client connections. This is essentially the server that other players connect to. Only exists on the server.
KronosPartyHost	Beacon that handles party client connections. Similar to the GameMode in the Unreal game framework. Only exists on the server.
KronosPartyClient	Beacon that connects to the remote host. It represents a player in a party. Similar to the PlayerController in the Unreal game framework. Exists on both the server and the client.
KronosPartyState	Shared state of the party. Similar to the GameState in the Unreal game framework. Exists on both the server and the client.
KronosPartyPlayerState	Lightweight representation of a player while connected to a party. Similar to the PlayerState in the Unreal game framework. Exists on both the server and the client.
KronosPartyPlayerActor	An actor that visually represents a party member in the game world. Not replicated, they are always created locally both by the server and the client.

Creating Parties

As an example, let's say we want to create a party for up to 5 players. I'll be reacting to the OnClicked event of a button inside a UMG widget, but feel free to do this wherever it makes sense for you, like the GameInstance for example.

You will most likely want to create private parties, and invite your friends into it. To do this, all you have to do is disable the "ShouldAdvertise" param and enable the "AllowInvites" param.

If your Online Subsystem requires the session to be advertised for some reason, you can create hidden sessions instead by enabling both the "ShouldAdvertise" and the "Hidden" params. Hidden sessions can only be found during specific session queries (in which case other filters will prevent us from finding this session accidentally if it was not the target).

The "StartingLevel" param is irrelevant when creating a party.

Blueprint

C++

#include "KronosMatchmakingManager.h"
#include "KronosMatchmakingPolicy.h"

// Get the matchmaking manager.
UKronosMatchmakingManager* MatchmakingManager = UKronosMatchmakingManager::Get(this);

// Request a new matchmaking policy. This operation is async!
// If matchmaking is in-progress, it will be canceled first.
MatchmakingManager->CreateMatchmakingPolicy(FOnCreateMatchmakingPolicyComplete::CreateLambda([this](UKronosMatchmakingPolicy* MatchmakingPolicy)
{
    // Parameters to be used for the party session.
    // Here's a private party configuration for up to 5 players.
    FKronosHostParams HostParams;
    HostParams.MaxNumPlayers = 5;
    HostParams.bShouldAdvertise = false;
    HostParams.bIsLanMatch = false;
    HostParams.bUsesPresence = true;
    HostParams.bAllowInvites = true;
    HostParams.bAllowJoinViaPresence = true;
    
    // If for some reason private sessions are not suitable for you,
    // you can make the session hidden instead. Hidden sessions can only be found when SpecificSessionQuery is used.
    // Steam for example doesn't allow you to join a friend through the Steam Overlay if he is in a private session.
    // Hidden sessions only make sense with bShouldAdvertise set to true!
    HostParams.bHidden = false;
    
    // Initialize matchmaking params from the host params.
    // Only the host params matter when starting matchmaking in CreateOnly mode.
    FKronosMatchmakingParams MatchmakingParams = FKronosMatchmakingParams(HostParams);
    
    // No matchmaking flags needed.
    uint8 MatchmakingFlags = static_cast<uint8>(EKronosMatchmakingFlags::None);
    
    // Tell the matchmaking that we only want to create a session.
    EKronosMatchmakingMode MatchmakingMode = EKronosMatchmakingMode::CreateOnly;
    
    // Start matchmaking.
    // Notice that we are using NAME_PartySession!
    MatchmakingPolicy->StartMatchmaking(NAME_PartySession, MatchmakingParams, MatchmakingFlags, MatchmakingMode);
}));

Joining Parties

When accepting a party invite, players join the party automatically!

If for some reason the invite approach doesn't suit your needs, you can also start matchmaking for parties just like you would for matches. You can join a party directly after finding the session via a search.

Blueprint

C++

#include "KronosMatchmakingManager.h"
#include "KronosMatchmakingPolicy.h"

// The session you want to join. You must get this somehow, for example by doing a SearchOnly matchmaking.
// Please note that search results cannot be replicated or sent via RPCs! This is an Online Subsystem limitation.
// Notice that this is passed into the lambda so that we can access it.
FKronosSearchResult SessionToJoin;

// Get the matchmaking manager.
UKronosMatchmakingManager* MatchmakingManager = UKronosMatchmakingManager::Get(this);

// Request a new matchmaking policy. This operation is async!
// If matchmaking is in-progress, it will be canceled first.
MatchmakingManager->CreateMatchmakingPolicy(FOnCreateMatchmakingPolicyComplete::CreateLambda([this, SessionToJoin](UKronosMatchmakingPolicy* MatchmakingPolicy)
{
    // Matchmaking params are irrelevant in JoinOnly mode.
    FKronosMatchmakingParams MatchmakingParams = FKronosMatchmakingParams();

    // Matchmaking flags to use.
    uint8 MatchmakingFlags = static_cast<uint8>(EKronosMatchmakingFlags::None);

    // Tell the matchmaking that we only want to join a session that we've got already.
    EKronosMatchmakingMode MatchmakingMode = EKronosMatchmakingMode::JoinOnly;

    // Start matchmaking.
    // Notice that we are using NAME_PartySession!
    MatchmakingPolicy->StartMatchmaking(NAME_PartySession, MatchmakingParams, MatchmakingFlags, MatchmakingMode, 0.0f, SessionToJoin);
}));

Sending Party Invites

You can send party invites to your friends using the online service's external invite UI through the Online Subsystem (e.g. Steam Overlay). When the user accepts the invite, they will join the party automatically.

Additionally, you can also use the SendPartyInviteToFriend function in KronosStatics. This function requires the friend's unique id. You can get a list of online friends via the ReadUserFriendsList async node.

Blueprint

C++

#include "KronosStatics.h"

// Show the external invite UI for party sessions (e.g. Steam Overlay).
// Please note that not all online subsystems support this.
UKronosStatics::ShowPartyInviteUI();

Initializing Players

All players including the party host will have a KronosPartyClient beacon created when they join the party. This is the main class that can be used to interact with the party. It's basically the equivalent of the PlayerController in the Unreal game framework.

• ServerInitPlayer: Server side player initialization. If you have a backend service this is a good place to read the player's skill rating, fetch cosmetics, etc.

• ClientInitPlayer: Client side player initialization.

Party Player Data

The KronosPartyPlayerState includes a Player Data framework that automatically replicates an integer array to all players. This makes it very easy to advertise data about each player, such as their profile level, the banner that they are using, or the character / class they are going to play.

The LobbyPlayerState also has a player data framework, and this system is explained there in more detail. Please check out the Lobby page for more information.

Please note that BeaconPlayerStates don't have RPC capabilities, so the player data can only be changed through their owning KronosPartyClient class instead.

• SetPlayerData: Used to set the player data. Overrides previous player data entirely.

• GetPlayerData: Used to read the player data using the KronosPartyPlayerState.

• Player data can be initialized during the ServerInitPlayer and ClientInitPlayer events.

Party Player Skill Rating

The KronosPartyPlayerState also tracks the owning player's skill rating.

Please note that BeaconPlayerStates don't have RPC capabilities, so the skill rating can only be changed through their owning KronosPartyClient class instead.

• SetPlayerElo: Used to set the player's skill rating.

• GetPlayerElo: Used to read the player's skill rating using the KronosPartyPlayerState.

• Skill rating can be initialized during the ServerInitPlayer and ClientInitPlayer events.

The player's skill rating must be set properly for the GetPartyEloAverage helper function to work!

Party Player Actors

As of version 1.8.0, the party system has the ability to spawn a KronosPartyPlayerActor for each party member in the party. The spawning is handled automatically, you just have to select which class to spawn in the KronosPartyState. These player actors are not replicated, they are always spawned locally.

To define where these player actors should be spawned, you'll have to place KronosPartyPlayerStart actors into your level. You can find this actor in the "Place Actors" tab on the left in the "Kronos Matchmaking" category. After placing these into the level, one of them should be marked as the local player start (by toggling the param on it).

The example content provided with the plugin showcases how this feature works. The example blueprints also contain additional information.

Leaving Parties

You can leave a party at any time using a simple function call. Please keep in mind that if the party host leaves, the party will be disbanded.

Blueprint

C++

#include "KronosPartyManager.h"

// Get the party manager.
UKronosPartyManager* PartyManager = UKronosPartyManager::Get(this);

// Begin leaving the party. The player will disconnect from the party
// immediately, but it may take a second for the session to be destroyed.
PartyManager->LeaveParty();

// Optionally, a delegate can be passed in which will be executed once the
// party session was destroyed. The function should look like this:
// MyFunction(FName SessionName, bool bWasSuccessful)
FOnDestroySessionCompleteDelegate CompletionDelegate = FOnDestroySessionCompleteDelegate::CreateUObject(this, &ThisClass::MyFunction);
PartyManager->LeaveParty(CompletionDelegate);

Limitations

Parties are created on the hosting player's machine. They do not exist on a backend service. Due to this and due to the nature of OnlineBeacons:

Parties are disbanded when initiating a map change.

As of version 1.9.0, party reconnection is supported by the plugin! Although parties are still going to be disbanded, it is now possible to recreate and reconnect parties after returning to the main menu. For more information please visit the Reconnect Parties page of the documentation.