Set up party with the SDK - Introduction to party - (Unity module)

Last updated on March 24, 2025

Unwrap the online session

Creating a party is essentially creating a new session of type "party", so managing a party is similar to managing game session. In this section, you learn how to set up essential party features using the AccelByte Gaming Services (AGS) SDK. In Byte Wars, there is a completed wrapper defined in the PartyEssentialsWrapper_Starter class. In this tutorial, you use the starter version of that wrapper to integrate the functionalities from scratch.

What's in the starter pack

To follow this tutorial, you use the starter wrapper class called PartyEssentialsWrapper_Starter. This wrapper is defined in the file below:

• CS file: Assets/Resources/Modules/PartyEssentials/Scripts/PartyEssentialsWrapper_Starter.cs

There is also a model class containing helper constant variables and struct defined in the file below:

• CS file: Assets/Resources/Modules/PartyEssentials/Scripts/PartyEssentialsModels.cs

The PartyEssentialsWrapper_Starter class has several pre-defined components below.

• Helper variables to reference the AGS SDK interfaces. These variables are assigned when the wrapper is initialized.

    private User userApi;
    private Session sessionApi;
    private Lobby lobbyApi;
  
    private void OnEnable()
    {
        userApi = AccelByteSDK.GetClientRegistry().GetApi().GetUser();
        sessionApi = AccelByteSDK.GetClientRegistry().GetApi().GetSession();
        lobbyApi = AccelByteSDK.GetClientRegistry().GetApi().GetLobby();
    }

• A helper property to cache the current party session.

  public SessionV2PartySession CurrentPartySession { private set; get; }

• A delegate to broadcast when the party session is updated, such as when a new party member joined, party member left, or new party leader promoted. This delegate will be used for UI integration later.

  public Action OnPartyUpdateDelegate = delegate { };

The PartyEssentialsModels class has several helpers below.

• Constant defining the party session configuration.

  public static readonly string PartySessionTemplateName = "unity-party";
  public static readonly int PartyMaxMembers = 4;

• String to display party related pop-up message.

  public static readonly string PartyPopUpMessage = "Party";
  public static readonly string JoinNewPartyConfirmationMessage = "Leave Current Party and Join a New One?";
  
  public static readonly string SuccessSendPartyInviteMessage = "Party Invitation Sent";
  public static readonly string FailedSendPartyInviteMessage = "Failed to Send Party Invitation";
  
  public static readonly string PartyNewLeaderMessage = "Is Now the Party Leader";
  public static readonly string PartyMemberJoinedMessage = "Joined the Party";
  public static readonly string PartyMemberLeftMessage = "Left the Party";
  public static readonly string PartyInviteReceivedMessage = "Invites You to Party";
  public static readonly string PartyInviteRejectedMessage = "Rejected Your Party Invite";
  public static readonly string KickedFromPartyMessage = "Kicked From the Party";
  
  public static readonly string AcceptPartyInviteMessage = "Accept";
  public static readonly string RejectPartyInviteMessage = "Reject";

• A struct to construct the party details info, consisting the party session info and the list of party members.

  public struct PartyDetailsModel
  {
      public SessionV2PartySession PartySession;
      public BaseUserInfo[] MemberUserInfos;
  }

Implement create party

In this section, you learn how to create a new party session.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to create a new party request with joinability set to invite-only. After the request is complete, this function updates the cached party session and broadcasts the party creation result by invoking the assigned delegate.

   public void CreateParty(ResultCallback<SessionV2PartySession> onComplete = null)
   {
       SessionV2PartySessionCreateRequest request = new SessionV2PartySessionCreateRequest()
       {
           configurationName = PartyEssentialsModels.PartySessionTemplateName,
           joinability = SessionV2Joinability.INVITE_ONLY
       };
   
       sessionApi.CreateParty(request, (Result<SessionV2PartySession> result) =>
       {
           if (result.IsError)
           {
               BytewarsLogger.LogWarning($"Failed to create party. Error {result.Error.Code}: {result.Error.Message}");
           }
           else 
           {
               CurrentPartySession = result.Value;
               BytewarsLogger.Log($"Success to create party. Party id: {CurrentPartySession.id}");
               OnPartyUpdateDelegate?.Invoke();
           }
           
           onComplete?.Invoke(result);
       });
   }

2. And that's it! You've created a function to create a new party.

Implement leave party

In this section, you learn how to leave a party session.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to leave the current joined party session, if it exists. After the request is complete, this function resets the cached party session and broadcasts the result by invoking the assigned delegate.

   public void LeaveParty(ResultCallback onComplete = null)
   {
       if (CurrentPartySession == null)
       {
           const string errorMessage = "Failed to leave party. Current party session is null.";
           BytewarsLogger.LogWarning(errorMessage);
           onComplete?.Invoke(Result.CreateError(ErrorCode.None, errorMessage));
           return;
       }
   
       sessionApi.LeaveParty(CurrentPartySession.id, (Result result) =>
       {
           if (result.IsError)
           {
               BytewarsLogger.LogWarning($"Failed to leave party. Error {result.Error.Code}: {result.Error.Message}");
           }
           else 
           {
               BytewarsLogger.Log($"Success to leave party. Party id: {CurrentPartySession.id}");
               CurrentPartySession = null;
               OnPartyUpdateDelegate?.Invoke();
           }
           
           onComplete?.Invoke(result);
       });
   }

2. And that's it! You've created a function to leave a party.

Implement get party details

In this section, you learn how to get the party and its members' details.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to send a request to get the party details. After the party details are received, this function queries each member's information to retrieve their details, such as player name and avatar. Then, this function consolidates the party details and member details into a custom struct named PartyDetailsModel and returns it by invoking the assigned delegate.

   public void GetPartyDetails(ResultCallback<PartyEssentialsModels.PartyDetailsModel> onComplete = null) 
   {
       if (CurrentPartySession == null) 
       {
           const string errorMessage = "Failed to get party details. Current party session is null.";
           BytewarsLogger.LogWarning(errorMessage);
           onComplete?.Invoke(Result<PartyEssentialsModels.PartyDetailsModel>.CreateError(ErrorCode.None, errorMessage));
           return;
       }
   
       sessionApi.GetPartyDetails(CurrentPartySession.id, (Result<SessionV2PartySession> result) =>
       {
           if (result.IsError) 
           {
               string errorMessage = $"Failed to get party details. Error {result.Error.Code}: {result.Error.Message}";
               BytewarsLogger.LogWarning(errorMessage);
               onComplete?.Invoke(Result<PartyEssentialsModels.PartyDetailsModel>.CreateError(ErrorCode.None, errorMessage));
               return;
           }
   
           SessionV2PartySession partySession = result.Value;
           string[] memberIds = result.Value.members.Where(x => x.StatusV2 == SessionV2MemberStatus.JOINED).Select(x => x.id).ToArray();
           userApi.BulkGetUserInfo(memberIds, (Result<ListBulkUserInfoResponse> userDataResult) =>
           {
               if (userDataResult.IsError)
               {
                   string errorMessage = $"Failed to get party details. Error {userDataResult.Error.Code}: {userDataResult.Error.Message}";
                   BytewarsLogger.LogWarning(errorMessage);
                   onComplete?.Invoke(Result<PartyEssentialsModels.PartyDetailsModel>.CreateError(ErrorCode.None, errorMessage)); 
                   return;
               }
   
               CurrentPartySession = partySession;
               BytewarsLogger.Log($"Success to get party details. Party id: {CurrentPartySession.id}");
   
               PartyEssentialsModels.PartyDetailsModel partyDetails = new PartyEssentialsModels.PartyDetailsModel
               {
                   PartySession = CurrentPartySession,
                   MemberUserInfos = userDataResult.Value.data
               };
               onComplete?.Invoke(Result<PartyEssentialsModels.PartyDetailsModel>.CreateOk(partyDetails));
           });
       });
   }

2. And that's it! You've created a function to get the party details.

Implement send party invitation

In this section, you learn how to send party invitation.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to send a party invitation to the target player. In this function, if the sender has not joined any party, the function will first request to create a new party before sending the invitation. After the request to send the party invitation is complete, the function broadcasts the result by invoking the assigned delegate and displays a notification on the screen.

   public void SendPartyInvite(string inviteeUserId, ResultCallback onComplete = null) 
   {
       // If not in any party, create a new one first.
       if (CurrentPartySession == null) 
       {
           CreateParty((Result<SessionV2PartySession> result) => 
           {
               if (result.IsError) 
               {
                   BytewarsLogger.LogWarning($"Cannot send a party invitation. Failed to create a new party.");
                   onComplete?.Invoke(Result.CreateError(result.Error));
                   return;
               }
   
               SendPartyInvite(inviteeUserId, onComplete);
           });
           return;
       }
   
       sessionApi.InviteUserToParty(CurrentPartySession.id, inviteeUserId, (Result result) =>
       {
           if (result.IsError) 
           {
               BytewarsLogger.LogWarning($"Failed to send a party invitation. Invitee user ID: {inviteeUserId}. Error {result.Error.Code}: {result.Error.Message}");
           }
           else 
           {
               BytewarsLogger.Log($"Success to send a party invitation. Invitee user ID: {inviteeUserId}.");
           }
   
           // Display push notification.
           MenuManager.Instance.PushNotification(new PushNotificationModel 
           {
               Message = result.IsError ? PartyEssentialsModels.FailedSendPartyInviteMessage : PartyEssentialsModels.SuccessSendPartyInviteMessage
           });
           
           onComplete?.Invoke(result);
       });
   }

2. And that's it! You've created a function to send a party invitation.

Implement accept party invitation

In this section, you learn how to accept a party invitation by joining the party.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to join a party by the party ID. In this function, if the player is already in a party, the function will first request to leave the current party before joining the new one. After the request to join the new party is complete, the function updates the cached party session and broadcasts the result by invoking the assigned delegate.

   public void JoinParty(string partyId, ResultCallback<SessionV2PartySession> onComplete = null) 
   {
       // Leave current party first.
       if (CurrentPartySession != null) 
       {
           LeaveParty((Result result) =>
           {
               if (result.IsError) 
               {
                   BytewarsLogger.LogWarning($"Cannot join a new party. Failed to leave current party. Error {result.Error.Code}: {result.Error.Message}");
                   onComplete.Invoke(Result<SessionV2PartySession>.CreateError(result.Error));
                   return;
               }
   
               JoinParty(partyId, onComplete);
           });
           return;
       }
   
       sessionApi.JoinParty(partyId, (Result<SessionV2PartySession> result) =>
       {
           if (result.IsError) 
           {
               BytewarsLogger.LogWarning($"Failed to join party. Party Id: {partyId}. Error {result.Error.Code}: {result.Error.Message}");
           }
           else 
           {
               CurrentPartySession = result.Value;
               BytewarsLogger.Log($"Success to join party. Party id: {CurrentPartySession.id}");
           }
   
           onComplete?.Invoke(result);
       });
   }

2. And that's it! You've created a function to accept a party invitation by joining the party.

Implement reject party invitation

In this section, you learn how to reject a party invitation.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to reject the party invitation. After the request is complete, the function broadcasts the result by invoking the assigned delegate.

   public void RejectPartyInvite(string partyId, ResultCallback onComplete = null) 
   {
       sessionApi.RejectPartyInvitation(partyId, (Result result) =>
       {
           if (result.IsError)
           {
               BytewarsLogger.LogWarning($"Failed to reject a party invitation. Error {result.Error.Code}: {result.Error.Message}");
           }
           else
           {
               BytewarsLogger.Log($"Success to reject a party invitation.");
           }
   
           onComplete?.Invoke(result);
       });
   }

2. Next, create a callback function to be called when the invitation is rejected, which is triggered on the sender's side. This function queries the rejection information and then displays it as a notification.

   private void OnPartyInviteRejected(Result<SessionV2PartyInvitationRejectedNotification> result)
   {
       if (result.IsError)
       {
           BytewarsLogger.LogWarning($"Failed to handle on-party invitation rejected event. Error {result.Error.Code}: {result.Error.Message}");
           return;
       }
   
       string rejecterId = result.Value.rejectedId;
       BytewarsLogger.Log($"Party invitation is rejected by user: {rejecterId}");
   
       // Display push notification.
       userApi.GetUserByUserId(rejecterId, (Result<PublicUserData> userDataResult) =>
       {
           string rejecterName = userDataResult.IsError || string.IsNullOrEmpty(userDataResult.Value.displayName) ? 
               AccelByteWarsUtility.GetDefaultDisplayNameByUserId(rejecterId) : userDataResult.Value.displayName;
           string rejecterAvatarUrl = userDataResult.IsError ? string.Empty : userDataResult.Value.avatarUrl;
   
           MenuManager.Instance.PushNotification(new PushNotificationModel
           {
               Message = $"{rejecterName} {PartyEssentialsModels.PartyInviteRejectedMessage}",
               IconUrl = rejecterAvatarUrl,
               UseDefaultIconOnEmpty = true
           });
       });
   }

3. Then, you need to bind the callback function when the wrapper is initialized. To do this, add the code below to the pre-defined OnEnable() function.

   private void OnEnable()
   {
       ...
       lobbyApi.SessionV2UserRejectedPartyInvitation += OnPartyInviteRejected;
   }

4. Finally, you also need to unbind the callback function when the wrapper is deinitialized. To do this, add the code below to the pre-defined OnDisable() function.

   private void OnDisable()
   {
       ...
       lobbyApi.SessionV2UserRejectedPartyInvitation -= OnPartyInviteRejected;
   }

5. And there you go! You've created a function to reject a party invitation and handle the on-invitation rejected event.

Handle received party invitations

In the previous sections, you created the functions to accept and reject a party invitation. In this section, you learn how to handle the received party invitation event, allowing the players to decide whether they want to accept or reject the invitation.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new helper function below to display a confirmation prompt asking whether the player really wants to accept the party invitation if the player is already in a party.

   private void DisplayJoinPartyConfirmation(SessionV2PartyInvitationNotification partyInvite) 
   {
       // Join the party if not in any party yet.
       bool isAloneInParty = CurrentPartySession != null && CurrentPartySession.members.Length <= 1;
       if (CurrentPartySession == null || isAloneInParty) 
       {
           JoinParty(partyInvite.partyId);
           return;
       }
   
       // Show confirmation to leave current party and join the new party.
       MenuManager.Instance.PromptMenu.ShowPromptMenu(
           PartyEssentialsModels.PartyPopUpMessage,
           PartyEssentialsModels.JoinNewPartyConfirmationMessage,
           PartyEssentialsModels.RejectPartyInviteMessage,
           () => { RejectPartyInvite(partyInvite.partyId); },
           PartyEssentialsModels.AcceptPartyInviteMessage,
           () => { JoinParty(partyInvite.partyId); });
   }

2. Next, create a new callback function to be called when the party invitation is received. This function queries the invitation sender's information and displays a notification with buttons for the player to accept or reject. If the player chooses to accept, it calls the DisplayJoinPartyConfirmation() function you created earlier to reconfirm whether the player really wants to join, in case the player is already in a party.

   private void OnPartyInviteReceived(Result<SessionV2PartyInvitationNotification> result)
   {
       if (result.IsError) 
       {
           BytewarsLogger.LogWarning($"Failed to handle received party invitation. Error {result.Error.Code}: {result.Error.Message}");
           return;
       }
   
       string senderId = result.Value.senderId;
       string partyId = result.Value.partyId;
   
       BytewarsLogger.Log($"Receives party invitation from {result.Value.senderId}");
   
       // Display push notification.
       userApi.GetUserByUserId(senderId, (Result<PublicUserData> userDataResult) =>
       {
           string senderName = userDataResult.IsError || string.IsNullOrEmpty(userDataResult.Value.displayName) ?
               AccelByteWarsUtility.GetDefaultDisplayNameByUserId(senderId) : userDataResult.Value.displayName;
           string senderAvatarUrl = userDataResult.IsError ? string.Empty : userDataResult.Value.avatarUrl;
   
           MenuManager.Instance.PushNotification(new PushNotificationModel
           {
               Message = $"{senderName} {PartyEssentialsModels.PartyInviteReceivedMessage}",
               IconUrl = senderAvatarUrl,
               UseDefaultIconOnEmpty = true,
               ActionButtonTexts = new string[] { PartyEssentialsModels.AcceptPartyInviteMessage, PartyEssentialsModels.RejectPartyInviteMessage },
               ActionButtonCallback = (PushNotificationActionResult actionResult) =>
               {
                   switch (actionResult)
                   {
                       // Show accept party invitation confirmation.
                       case PushNotificationActionResult.Button1:
                           DisplayJoinPartyConfirmation(result.Value);
                           break;
                       // Reject party invitation.
                       case PushNotificationActionResult.Button2:
                           RejectPartyInvite(result.Value.partyId);
                           break;
                   }
               }
           });
       });
   }

3. Then, you need to bind the callback function when the wrapper is initialized. To do this, add the code below to the pre-defined OnEnable() function.

   private void OnEnable()
   {
       ...
       lobbyApi.SessionV2InvitedUserToParty += OnPartyInviteReceived;
   }

4. Finally, you also need to unbind the callback function when the wrapper is deinitialized. To do this, add the code below to the pre-defined OnDisable() function.

   private void OnDisable()
   {
       ...
       lobbyApi.SessionV2InvitedUserToParty -= OnPartyInviteReceived;
   }

5. And there you go! You've handled the received party invitation event by displaying a confirmation prompt to the player, allowing them to accept or reject the invitation.

Implement kick party members

In this section, you learn how to kick a member from the party.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to kick a member from the current party. This function can only be called by the party leader. After the request is complete, the function broadcasts the result by invoking the assigned delegate.

   public void KickPlayerFromParty(string targetUserId, ResultCallback<SessionV2PartySessionKickResponse> onComplete = null) 
   {
       if (CurrentPartySession == null)
       {
           const string errorMessage = "Failed to kick player from party. Current party session is null.";
           BytewarsLogger.LogWarning(errorMessage);
           onComplete?.Invoke(Result<SessionV2PartySessionKickResponse>.CreateError(ErrorCode.None, errorMessage));
           return;
       }
   
       sessionApi.KickUserFromParty(CurrentPartySession.id, targetUserId, (Result<SessionV2PartySessionKickResponse> result) =>
       {
           if (result.IsError) 
           {
               BytewarsLogger.LogWarning($"Failed to kick player from party. Target user: {targetUserId}. Error {result.Error.Code}: {result.Error.Message}");
           }
           else 
           {
               BytewarsLogger.LogWarning($"Success to kick player from party. Target user: {targetUserId}");
           }
   
           onComplete?.Invoke(result);
       });
   }

2. Next, create a callback function to be called when a member is kicked from the party, which is triggered on the member who got kicked. This function displays a notification on the screen.

   private void OnKickedFromParty(Result<SessionV2PartyUserKickedNotification> result)
   {
       if (result.IsError)
       {
           BytewarsLogger.LogWarning($"Failed to handle on-kicked from party event. Error {result.Error.Code}: {result.Error.Message}");
           return;
       }
   
       BytewarsLogger.Log($"Kicked from party. Party id: {result.Value.partyId}");
       CurrentPartySession = null;
   
       // Display push notification.
       MenuManager.Instance.PushNotification(new PushNotificationModel
       {
           Message = $"You are {PartyEssentialsModels.KickedFromPartyMessage}"
       });
   
       OnPartyUpdateDelegate?.Invoke();
   }

3. Then, you need to bind the callback function when the wrapper is initialized. To do this, add the code below to the pre-defined OnEnable() function.

   private void OnEnable()
   {
       ...
       lobbyApi.SessionV2UserKickedFromParty += OnKickedFromParty;
   }

4. Finally, you also need to unbind the callback function when the wrapper is deinitialized. To do this, add the code below to the pre-defined OnDisable() function.

   private void OnDisable()
   {
       ...
       lobbyApi.SessionV2UserKickedFromParty -= OnKickedFromParty;
   }

5. And there you go! You've created a function to kick a member from the party and handle the on-kicked from party event.

Implement promoting a new party leader

In this section, you learn how to kick a member from the party.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new function below to promote a member as the new party leader. This function can only be called by the current party leader. After the request is complete, the function broadcasts the result by invoking the assigned delegate.

   public void PromotePartyLeader(string targetUserId, ResultCallback<SessionV2PartySession> onComplete = null) 
   {
       if (CurrentPartySession == null)
       {
           const string errorMessage = "Failed to promote a new party leader. Current party session is null.";
           BytewarsLogger.LogWarning(errorMessage);
           onComplete?.Invoke(Result<SessionV2PartySession>.CreateError(ErrorCode.None, errorMessage));
           return;
       }
   
       sessionApi.PromoteUserToPartyLeader(CurrentPartySession.id, targetUserId, (Result<SessionV2PartySession> result) =>
       {
           if (result.IsError) 
           {
               BytewarsLogger.LogWarning($"Failed to promote new party leader. Target user id: {targetUserId}. Error {result.Error.Code}: {result.Error.Message}");
           }
           else
           {
               BytewarsLogger.Log($"Success to promote a new party leader. New leader user id: {CurrentPartySession.leaderId}");
           }
   
           onComplete?.Invoke(result);
       });
   }

2. And that's it! You've created a function to promote a new party leader.

Handle party session updates

The party session will be updated when party-related events occur. For example, when a new member joins or leaves, a new party leader is set, and members got kicked. In this section, you learn how to handle these events to update the cache party session so you can display the latest party information on the UI.

1. Open the PartyEssentialsWrapper_Starter class. Then, create a new callback function to be called when the party session is updated, such as when the members list changes or the party leader changes. This function displays a notification on the screen if the party leader changes. Then, it broadcasts the event by invoking the OnPartyUpdateDelegate helper delegate.

   private void OnPartyUpdated(Result<SessionV2PartySessionUpdatedNotification> result)
   {
       if (result.IsError)
       {
           BytewarsLogger.LogWarning($"Failed to handle on-party updated event. Error {result.Error.Code}: {result.Error.Message}");
           return;
       }
   
       BytewarsLogger.Log("Party update received.");
       SessionV2PartySessionUpdatedNotification partyUpdateNotif = result.Value;
   
       // Display push notification regarding new party leader.
       if (CurrentPartySession.leaderId != partyUpdateNotif.leaderId) 
       {
           string newLeaderId = partyUpdateNotif.leaderId;
           CurrentPartySession.leaderId = newLeaderId;
   
           userApi.GetUserByUserId(newLeaderId, (Result<PublicUserData> userDataResult) =>
           {
               string leaderName = userDataResult.IsError || string.IsNullOrEmpty(userDataResult.Value.displayName) ?
                   AccelByteWarsUtility.GetDefaultDisplayNameByUserId(newLeaderId) : userDataResult.Value.displayName;
               string leaderAvatarUrl = userDataResult.IsError ? string.Empty : userDataResult.Value.avatarUrl;
   
               MenuManager.Instance.PushNotification(new PushNotificationModel
               {
                   Message = $"{leaderName} {PartyEssentialsModels.PartyNewLeaderMessage}",
                   IconUrl = leaderAvatarUrl,
                   UseDefaultIconOnEmpty = true
               });
           });
       }
   
       OnPartyUpdateDelegate?.Invoke();
   }

2. Although the party update event mentioned previously is also called when the member list changes, it does not contain details (e.g., who's been kicked, who's joining, who's leaving). Thus, you need to create a new callback function to be called when the party member list changes. This function collects the member change status and displays a notification on the screen based on the change status. Then, it broadcasts the event by invoking the OnPartyUpdateDelegate helper delegate.

   private void OnPartyMemberChanged(Result<SessionV2PartyMembersChangedNotification> result)
   {
       if (result.IsError)
       {
           BytewarsLogger.LogWarning($"Failed to handle on-party member changed event. Error {result.Error.Code}: {result.Error.Message}");
           return;
       }
   
       SessionV2PartyMembersChangedNotification changeNotif = result.Value;
       Dictionary<string, SessionV2MemberStatus> updatedMemberStatus = new Dictionary<string, SessionV2MemberStatus>();
   
       HashSet<SessionV2MemberData> updatedMemberList = 
           CurrentPartySession == null ? 
           new HashSet<SessionV2MemberData>() : 
           CurrentPartySession.members.ToHashSet();
   
       // Collect changed member status and their user ids.
       if (changeNotif.joinerId != null) 
       {
           updatedMemberStatus.TryAdd(changeNotif.joinerId, SessionV2MemberStatus.JOINED);
           updatedMemberList.Add(new SessionV2MemberData
           {
               id = changeNotif.joinerId,
               StatusV2 = SessionV2MemberStatus.JOINED
           });
       }
       if (changeNotif.ImpactedUserIds != null) 
       {
           if (changeNotif.ImpactedUserIds.LeftUserIds != null)
           {
               foreach (string leftMember in changeNotif.ImpactedUserIds.LeftUserIds)
               {
                   updatedMemberStatus.TryAdd(leftMember, SessionV2MemberStatus.LEFT);
               }
               updatedMemberList.RemoveWhere(x => changeNotif.ImpactedUserIds.LeftUserIds.Contains(x.id));
           }
           if (changeNotif.ImpactedUserIds.KickedUserIds != null)
           {
               foreach (string kickedMember in changeNotif.ImpactedUserIds.KickedUserIds)
               {
                   updatedMemberStatus.TryAdd(kickedMember, SessionV2MemberStatus.KICKED);
               }
               updatedMemberList.RemoveWhere(x => changeNotif.ImpactedUserIds.KickedUserIds.Contains(x.id));
           }
       }
   
       // Update the cached party session members if any.
       if (CurrentPartySession != null) 
       {
           CurrentPartySession.members = updatedMemberList.ToArray();
       }
   
       // Query user information and display the push notification based on member status.
       if (updatedMemberStatus.Count > 0) 
       {
           userApi.BulkGetUserInfo(updatedMemberStatus.Keys.ToArray(), (Result<ListBulkUserInfoResponse> userDataResult) =>
           {
               if (userDataResult.IsError)
               {
                   BytewarsLogger.LogWarning(
                       $"Failed to handle on-party member changed event. " +
                       $"Error {userDataResult.Error.Code}: {userDataResult.Error.Message}");
                   return;
               }
   
               foreach (BaseUserInfo memberInfo in userDataResult.Value.data)
               {
                   if (!updatedMemberStatus.ContainsKey(memberInfo.userId))
                   {
                       continue;
                   }
   
                   string memberName = string.IsNullOrEmpty(memberInfo.displayName) ?
                       AccelByteWarsUtility.GetDefaultDisplayNameByUserId(memberInfo.userId) : memberInfo.displayName;
   
                   string pushNotifMessage = string.Empty;
                   switch (updatedMemberStatus[memberInfo.userId])
                   {
                       case SessionV2MemberStatus.JOINED:
                           pushNotifMessage = $"{memberName} {PartyEssentialsModels.PartyMemberJoinedMessage}";
                           break;
                       case SessionV2MemberStatus.LEFT:
                           pushNotifMessage = $"{memberName} {PartyEssentialsModels.PartyMemberLeftMessage}";
                           break;
                       case SessionV2MemberStatus.KICKED:
                           pushNotifMessage = $"{memberName} {PartyEssentialsModels.KickedFromPartyMessage}";
                           break;
                   }
   
                   MenuManager.Instance.PushNotification(new PushNotificationModel
                   {
                       Message = pushNotifMessage,
                       IconUrl = memberInfo.avatarUrl,
                       UseDefaultIconOnEmpty = true
                   });
               }
           });
       }
   
       OnPartyUpdateDelegate?.Invoke();
   }

3. Next, you need to bind those callback functions when the wrapper is initialized. To do this, add the code below to the pre-defined OnEnable() function.

   private void OnEnable()
   {
       ...
       lobbyApi.SessionV2PartyUpdated += OnPartyUpdated;
       lobbyApi.SessionV2PartyMemberChanged += OnPartyMemberChanged;
   }

4. Finally, you also need to unbind those callback functions when the wrapper is deinitialized. To do this, add the code below to the pre-defined OnDisable() function.

   private void OnDisable()
   {
       ...
       lobbyApi.SessionV2PartyUpdated -= OnPartyUpdated;
       lobbyApi.SessionV2PartyMemberChanged -= OnPartyMemberChanged;
   }

5. And there you go! You've handled the party update events by displaying a notification on the screen and broadcasting the event so you can display the latest party information on the UI later.

Resources

• The files used in this tutorial are available in the Unity Byte Wars GitHub repository.

  • Assets/Resources/Modules/PartyEssentials/Scripts/PartyEssentialsWrapper_Starter.cs
    • Assets/Resources/Modules/PartyEssentials/Scripts/PartyEssentialsModels.cs