Party

Last updated on 20 April, 2023 1:23 AM

Overview

AccelByte Gaming Services (AGS) Starter Lobby Service includes Party features that enable multiplayer play. All Party features use WebSocket to ensure smooth communication between players. Players can interact with parties in several ways, including:

• User Party Info shows players information about their party, including the Party ID, Leader ID, and a list of party members.
• Create Party allows players to create a new party that other players can join.
• Invite to Party allows players to invite their friends to join their party. Both the inviter and invitee will receive a notification when the invitation is sent.
• Join Party allows players to join a party that they’ve been invited to join. When the player joins the party the inviter and other party members will be notified.
• Reject Party allows players to reject a party invitation. The inviter will be notified that their invitation was rejected.
• Promote Member allows players to set another player as the party leader.
• Kick Party allows party leaders to remove another player from their party.

NOTE

Please click the below links to read how to implement Party in Unity and Unreal Engine.

• Unity
• Unreal Engine

Implementing Party Interaction using the Client SDKs

Create a Party

Players can create a party that is then used for matchmaking. A player can only create one party at a time and will become the leader of the party they create.

Unreal Engine

FRegistry::Lobby.SetCreatePartyResponseDelegate(Lobby::FPartyCreateResponse::CreateLambda([](FAccelByteModelsCreatePartyResponse result)  
{  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Create Party Success!"));  
 if (result.PartyId.IsEmpty())  
 {  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Create Party Error!"));  
 }  
}));  
FRegistry::Lobby.Connect();  
FRegistry::Lobby.SendCreatePartyRequest();  

Unity

//Create Party  
PartyInfo partyInfo;  

var lobby = AccelBytePlugin.GetLobby();  
lobby.CreateParty(result =>  
{  
 if(result.IsError)  
 {  
 Debug.Log("Error. Code: " + result.Error.Code + ", Reason: " + result.Error.Message);  
 }  
 else  
 {  
 partyInfo = result.Value;  
 Debug.Log("Successfully create a party");  
 }  
});  

Invite to a Party

Players can invite other players to their party, as long as the invited player is not already in a party. Party invitees will receive a notification that they have been invited to join a party and current party members will also receive a notification that someone has been invited to the party. Party invitees are identified by the inviteePlayerId in the Unreal Engine SDK and by the inviteeUserId parameter in the Unity SDK.

Unreal Engine

FRegistry::Lobby.SetInvitePartyResponseDelegate(Lobby::FPartyInviteResponse::CreateLambda([](FAccelByteModelsPartyInviteResponse result)  
{  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Invite Party Success!"));  
})  
);  
const FString InvitedPlayerId = “a1b2c3d4e5”;  
FRegistry::Lobby.SendInviteToPartyRequest(InvitedPlayerId);  

Unity

//Invite Party  
string inviteeUserId = “987654321”;  
lobby.InviteToParty(inviteeUserId, result =>  
{  
 if(result.IsError)  
 {  
 Debug.Log("Error. Code: " + result.Error.Code + ", Reason: " + result.Error.Message);  
 }  
 else  
 {  
 Debug.Log("Successfully invite an invitee");  
 }  
});  

//Notification: invited notification  
//This notification will be received by the invitee  
PartyInvitation partyInvitation;  
lobby.InvitedToParty += result  
{  
 if(!result.IsError)  
 {  
 partyInvitation = result.Value;  
 Debug.Log(“[Notification] Invited by:” + result.Value.from);  
 }  
};  

Party Codes

Party leaders can send party codes to players so that those players can join their party. Only party leaders can use party codes. They can also refresh or revoke a party code.

Generate or Refresh a Party Code

Use the following function to generate or refresh a party code.

Unreal Engine

FRegistry::Lobby.SetPartyGenerateCodeResponseDelegate(
Api::Lobby::FPartyGenerateCodeResponse::CreateLambda([](FAccelByteModelsPartyGenerateCodeResponse Response)
{
   // Handle result.PartyCode here
}));

FRegistry::Lobby.SendPartyGenerateCodeRequest();

Get a Party Code

Once a code is generated, party leaders can get the code and share it from other players. This function allows party leaders to get the party code.

Unreal Engine

FRegistry::Lobby.SetPartyGetCodeResponseDelegate(
Api::Lobby::FAccelByteModelsPartyGetCodeResponse ::CreateLambda([](FAccelByteModelsPartyGetCodeResponse  Response)
{
   // Handle result.PartyCode here
}));
FRegistry::Lobby.SendPartyGetCodeRequest();

tip

If the success response returns an empty party code, you need to call the GeneratePartyCode function to generate a new party code.

Revoke a Party Code

Party leaders can revoke a party code. If a party code is revoked, players will no longer be able to use it to join the party. This function allows party leaders to revoke the party code.

Unreal Engine

FRegistry::Lobby.SetPartyDeleteCodeResponseDelegate(
Api::Lobby::FAccelByteModelsPartyDeleteCodeResponse ::CreateLambda([](FAccelByteModelsPartyDeleteCodeResponse  Response)
{
   // Handle result here
}));
FRegistry::Lobby.SendPartyDeleteCodeRequest();

Join a Party with a Party Code

Players that have been sent a party code can use it to join a party. This function allows players to join a party using a party code.

Unreal Engine

FRegistry::Lobby.SetPartyJoinViaCodeResponseDelegate(
Api::Lobby::FPartyJoinViaCodeResponse::CreateLambda([](FPartyJoinViaCodeResponse Response)
{
   // Handle result here
}));
FRegistry::Lobby.SendPartyJoinViaCodeRequest();

Join a Party

Players that are invited to a party can accept the invitation and join the party. Party invitees will receive a notification that they’ve joined the party and current party members will also receive a notification that someone is joining the party. The party is identified by the partyID parameter and the invitation by the invitationToken parameter.

Unreal Engine

FRegistry::Lobby.SetPartyGetInvitedNotifDelegate(Lobby::FPartyGetInvitedNotif::CreateLambda([](FAccelByteModelsPartyGetInvitedNotice result)  
{  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Get Party Invitation!"));  
 FRegistry::Lobby.SendAcceptInvitationRequest(*result.PartyId, *result.InvitationToken);  
}));  

FAccelByteModelsPartyJoinReponse joinPartyResponse;  
FRegistry::Lobby.SetInvitePartyJoinResponseDelegate(Lobby::FPartyJoinResponse::CreateLambda([&joinPartyResponse](FAccelByteModelsPartyJoinReponse result)  
{  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Join Party Success! Member : %d"), result.Members.Num());  
 joinPartyResponse = result;  
 if (result.Code != "0")  
 {  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Join Party Failed!"));  
 }  
}));  

Unity

//Join a Party  
lobby.JoinParty(partyInvitation.partyID, partyInvitation.invitationToken, result =>  
{  
 if(result.IsError)  
 {  
 Debug.Log("Error. Code: " + result.Error.Code + ", Reason: " + result.Error.Message);  
 }  
 else  
 {  
 Debug.Log("Successfully join a party");  
 }  
});  

//Notification: joined from party notification  
//This notification will be received by the member of the party  
lobby.JoinedParty += result  
{  
 if(!result.IsError)  
 {  
 Debug.Log(“[Notification] Invitee join a party”);  
 }  
};  

Reject a Party Invitation

When a player has been invited to a party, they can choose to reject the invitation. Party invitees will receive a notification that they’ve rejected the invitation and current party members will also receive a notification that someone has rejected the party invitation. The party is identified by the partyID parameter and the invitation by the invitationToken parameter.

Unity

//Reject a Party  
lobby.RejectPartyInvitation(partyInvitation.partyID, partyInvitation.invitationToken, result =>  
{  
 if(result.IsError)  
 {  
 Debug.Log("Error. Code: " + result.Error.Code + ", Reason: " + result.Error.Message);  
 }  
 else  
 {  
 Debug.Log("Successfully reject a party invitation");  
 }  
});  

//Notification: rejected a party invitation notification  
//This notification will be received by the party leader of the party that send the invitation party  
lobby.RejectedPartyInvitation += result  
{  
 if(!result.IsError)  
 {  
 Debug.Log(“[Notification] Invitee reject a party invitation”);  
 }  
};  

Promote Member to Party Leader

The party leader can promote another party member to become the new party leader. All party members will be notified of the new party leader. The new party leader is identified by the memberUserId parameter.

Unity

//Promote member to be a Party Leader  
string memberUserId = “987654321”;  
lobby.PromotePartyLeader(memberUserId, result =>  
{  
 if(result.IsError)  
 {  
 Debug.Log("Error. Code: " + result.Error.Code + ", Reason: " + result.Error.Message);  
 }  
 else  
 {  
 Debug.Log("Successfully promote member to be a party leader");  
 }  
});  

Kick Player from a Party

The party leader has the privilege to remove a party member from their party by kicking them out of the party. Kicked party members will receive a notification that they’ve been kicked out of the party, and current party members will also receive a notification that someone has been kicked from the party. The kicked party member is identified by the KickPlayerId in Unreal Engine and by the memberUserId parameter in Unity.

Unreal Engine

FRegistry::Lobby.SetInvitePartyKickMemberResponseDelegate(Lobby::FPartyKickResponse::CreateLambda([](FAccelByteModelsKickPartyMemberResponse result)  
{  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Kick Party Member Success!"));  
 if (result.Code != "0")  
 {  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Kick Party Member Failed!"));  
 }  
}));  

const FString KickedPlayerId = “a1b2c3d4e5”;  
FRegistry::Lobby.SendKickPartyMemberRequest(KickedPlayerId);  

Unity

//Kick member from Party  
string memberUserId = “987654321”;  
lobby.KickPartyMember(memberUserId, result =>  
{  
 if(result.IsError)  
 {  
 Debug.Log("Error. Code: " + result.Error.Code + ", Reason: " + result.Error.Message);  
 }  
 else  
 {  
 Debug.Log("Successfully kick member from party");  
 }  
});  

//Notification: kicked from party notification  
//This notification will be received by kicked member  
lobby.KickedFromParty += result  
{  
 if(!result.IsError)  
 {  
 Debug.Log(“[Notification] You’re kicked from party”);  
 }  
};  

Leave a Party

Party members can choose to leave their party. If the party leader leaves the party, party leadership will be passed to another party member automatically. Party members that leave the party will receive a notification that they’ve left the party and current party members will also receive a notification that someone is leaving the party.

Unreal Engine

FRegistry::Lobby.SetLeavePartyResponseDelegate(Lobby::FPartyLeaveResponse::CreateLambda([](FAccelByteModelsLeavePartyResponse result)  
{  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Leave Party Success!"));  
 if (result.Code != "0")  
 {  
 UE_LOG(LogAccelByteLobbyTest, Log, TEXT("Leave Party Failed!"));  
 }  
}));  
FRegistry::Lobby.SendLeavePartyRequest();  

Unity

//Leave a Party  
lobby.LeaveParty(result =>  
{  
 if(result.IsError)  
 {  
 Debug.Log("Error. Code: " + result.Error.Code + ", Reason: " + result.Error.Message);  
 }  
 else  
 {  
 Debug.Log("Successfully leave from party");  
 }  
});  

//Notification: leave from party notification callback  
//This notification will be received by all member in party (except member who leave the party)  
lobby.LeaveFromParty += result  
{  
 if(!result.IsError)  
 {  
 Debug.Log(“[Notification] Leave from party”);  
 }  
};  

Send Notification to Party Members

Players can send a notification to all the members of their party. Call this function to send notifications to the party and allow the remaining party members to receive that notification.

Unreal Engine

ApiClient->Lobby.SetPartyNotifDelegate(Api::Lobby::FPartyNotif::CreateLambda(
    [](const FAccelByteModelsPartyNotif& Notif)
    {
        UE_LOG(LogTemp, Log, TEXT("Receive notification from other party member, topic: %s, payload: %s"), *Notif.Topic, *Notif.Payload)
    }));

ApiClient->Lobby.SendNotificationToPartyMember(Topic, Payload);

Unity

lobby.PartyNotif += result =>
{
    PartyNotif notif = result.Value;
    Debug.Log($"Receive notification from other party member, topic: {notif.topic}, payload: {notif.payload}");
};

lobby.SendNotificationToPartyMember(topic, payload, result => { });

Implementing Party Storage using the Client SDKs

Party Storage enables a party to store party attributes that can be passed from the game server to the game client. The game server will write the party’s storage to ensure that all party members get the same information or notification from the server.

Party Data Update Notification

Use this function to notify players of any updates to party data. Party members will be notified if an event occurs in the party, such as when a player accepts a party invitation, joins the party, or leaves a party.

Unreal Engine

FRegistry::Lobby.Connect();
FRegistry::Lobby.SetPartyDataUpdateNotifDelegate(AccelByte::Api::Lobby::FPartyDataUpdateNotif::CreateLambda([](const FAccelByteModelsPartyDataNotif& Result)
{
    // Do something if PartyDataUpdateNotifDelegate has been successful
}));

Unity

AccelBytePlugin.GetLobby().Connect();
        AccelBytePlugin.GetLobby().PartyDataUpdateNotif += result =>
        {
            if (result.IsError)
            {
                // Do something if PartyDataUpdateNotif has an error
                Debug.Log($"Error PartyDataUpdateNotif, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
            }
            else
            {
                // Do something if PartyDataUpdateNotif has been successful
            }
        };

Get Party Data (Client-Side)

Use this function to retrieve specific party data from the client side. Make sure you have players logged in to allow this API call.

Unreal Engine

FRegistry::Lobby.Connect();
FRegistry::Lobby.GetPartyStorage(PartyId, THandler<FAccelByteModelsPartyDataNotif>::CreateLambda([](const FAccelByteModelsPartyDataNotif& Result)
{
    // Do something if GetPartyStoraget has been successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetPartyStorage has an error
    UE_LOG(LogTemp, Log, TEXT("Error GetPartyStorage, Error Code: %d Error Message: %s"), ErrorCode, *ErrorMessage);
}));

Unity

string partyId = "SomePartyid";

        AccelBytePlugin.GetLobby().Connect();
        AccelBytePlugin.GetLobby().GetPartyStorage(partyId, result =>
        {
            if (result.IsError)
            {
                // Do something if GetPartyStorage has an error
                Debug.Log($"Error GetPartyStorage, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
            }
            else
            {
                // Do something if GetPartyStorage has been successful
            }
        });

Get Party Data (Server-Side)

Use this function to retrieve specific party data from the server side. Make sure the game server is authenticated to allow this API call.

Unreal Engine

FString PartyId = FString("SomePartyId");

FRegistry::ServerLobby.GetPartyStorage(PartyId, THandler<FAccelByteModelsPartyDataNotif>::CreateLambda([](const FAccelByteModelsPartyDataNotif& Result)
{
    // Do something if GetPartyStorage has been successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetPartyStorage has an error
    UE_LOG(LogTemp, Log, TEXT("Error GetPartyStorage, Error Code: %d Error Message: %s"), ErrorCode, *ErrorMessage);
}));

Unity

string partyId = "SomePartyId";

        AccelBytePlugin.GetLobby().Connect();
        AccelByteServerPlugin.GetLobby().GetPartyStorage(partyId, result =>
        {
            if (result.IsError)
            {
                // Do something if GetPartyStorage has an error
                Debug.Log($"Error GetPartyStorage, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
            }
            else
            {
                // Do something if GetPartyStorage has been successful
            }
        });

Write Party Data

Write Party Data is an exclusive feature for the game server. In writing party data, it can occur that multiple servers write to the same party at the same time. To avoid this, our SDK has a timestamp in the backend to ensure that the latest write data will never be overwritten with older data.

Unreal Engine

FString PartyId = FString("SomePartyId");

FRegistry::ServerLobby.WritePartyStorage(PartyId, [](FJsonObjectWrapper OldPartyData)
{
    // You can choose either to create new PartyDataStorage or modified from OldPartyDataStorage
    /*FJsonObjectWrapper NewPartyData;
    TSharedPtr<FJsonObject> MyNewJsonValue;
    MyNewJsonValue->SetStringField(FString("MyNewFieldName"), FString("MyNewStringValue"));
    NewPartyData.JsonObject->SetObjectField(FString("NewField"), MyNewJsonValue);
    return NewPartyData;*/

    FJsonObjectWrapper ModifiedPartyData = OldPartyData;
    TSharedPtr<FJsonObject> MyNewJsonValue;
    MyNewJsonValue->SetStringField(FString("MyNewFieldName"), FString("MyNewStringValue"));
    ModifiedPartyData.JsonObject->SetObjectField(FString("NewField"), MyNewJsonValue);
    return OldPartyData;
}, THandler<FAccelByteModelsPartyDataNotif>::CreateLambda([](const FAccelByteModelsPartyDataNotif& Result)
{
    // Do something if WritePartyStorage has been successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString ErrorMessage)
{
    // Do something if WritePartyStorage has an error
    UE_LOG(LogTemp, Log, TEXT("Error WritePartyStorage, Error Code: %d Error Message: %s"), ErrorCode, *ErrorMessage);
}));

Unity

string partyId = "SomePartyId";

            AccelByteServerPlugin.GetLobby().WritePartyStorage(partyId,
                result =>
                {
                    if (result.IsError)
                    {
                        // Do something if WritePartyStorage has an error
                        Debug.Log($"Error WritePartyStorage, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
                    }
                    else
                    {
                        // Do something if WritePartyStorage has been successful
                    }
                },
                oldPartyData =>
                {
                    // You can modify oldPartyData or you can input your new party data
                    /*Dictionary<string, object> newPartyData = null;
                    newPartyData.Add("newKey", "newValue");
                    return newPartyData;*/

                    Dictionary<string, object> modifiedOldPartyData = oldPartyData;
                    modifiedOldPartyData.Add("newKey", "newValue");
                    return modifiedOldPartyData;
                });

Related Concepts

• Learn about our Chat service, which let’s party members interact with each other.
• Players can form parties with their friends if you integrate our Friends service into your game.