パーティをゲームに統合する

Last updated on February 4, 2026

注釈：本資料はAI技術を用いて翻訳されています。

概要

AccelByte Gaming Services (AGS) セッションには、マルチプレイヤープレイのパーティを処理するサービスである AGS パーティが含まれています。プレイヤーは次のようなさまざまな方法でパーティと対話できます。

ユーザーパーティ情報: パーティ ID、リーダー ID、パーティメンバーのリストなど、パーティに関する情報をプレイヤーに表示します。
パーティを作成: プレイヤーが他のプレイヤーが参加できる新しいパーティを作成できるようにします。
パーティに招待: プレイヤーが友達をパーティに招待できるようにします。招待者と被招待者の両方が、招待が送信されたときに通知を受け取ります。
パーティに参加: プレイヤーが招待されたパーティに参加できるようにします。プレイヤーがパーティに参加すると、招待者と他のパーティメンバーに通知されます。
パーティ招待をキャンセル: プレイヤーがパーティ招待をキャンセルできるようにします。被招待者と招待者の両方が、招待がキャンセルされたという通知を受け取ります。被招待者は、キャンセル後に以前の招待に参加することはできません。
パーティ招待を拒否: プレイヤーがパーティ招待を拒否できるようにします。招待者は招待が拒否されたことを通知されます。
メンバーをパーティリーダーに昇格: プレイヤーが他のプレイヤーをパーティリーダーとして設定できるようにします。
パーティから追放: パーティリーダーが他のプレイヤーをパーティから削除(追放)できるようにします。
パーティから退出: プレイヤーがすでに参加しているパーティから退出できるようにします。プレイヤーがパーティから退出すると、他のパーティメンバーに通知されます。

この記事では、AGS パーティを使用したプレイヤーパーティの統合について説明します。

パーミッション

パーミッションは、AGS 内の特定のリソースへのアクセスを許可するために使用されます。パーティセッション V2 を管理する前に、アカウントに次のパーミッションがあることを確認してください。

用途	パーミッション	アクション
セッションテンプレートの追加、編集、削除	ADMIN:NAMESPACE:*:SESSION:CONFIGURATION	CREATE, READ, UPDATE, DELETE
セッションとパーティでセッションを表示	NAMESPACE:*:SESSION:GAME	CREATE, READ, UPDATE, DELETE

前提条件

セッションインターフェース V2 を使用するには、次のファイルをインクルードします。

#include "OnlineSubsystem.h"
#include "OnlineSubsystemUtils.h"
#include "Interfaces/OnlineSessionInterface.h"
#include "Engine/World.h"
#include "Engine/GameEngine.h"

#include "OnlineSessionInterfaceV2AccelByte.h"
#include "OnlineSubsystemAccelByteSessionSettings.h"
#include "OnlineSubsystemSessionSettings.h"

次の関数を使用して、ゲームから FOnlineSessionV2AccelByte と LocalPlayerId を取得します。

注記

チュートリアルの残りの部分では、インターフェースの各機能に焦点を当てるために、このコードスニペットは含まれません。

// ゲームから FOnlineSessionV2AccelByte を取得
const UWorld* World = GEngine->GetCurrentPlayWorld();
const IOnlineSubsystem* Subsystem = Online::GetSubsystem(World, ACCELBYTE_SUBSYSTEM);
const auto SessionInterface = StaticCastSharedPtr<FOnlineSessionV2AccelByte>(Subsystem->GetSessionInterface());

// ゲームから LocalPlayerId を取得
const int PlayerIndex = 0;
const ULocalPlayer* LocalPlayer = GEngine->GetLocalPlayerFromControllerId(GEngine->GetCurrentPlayWorld(), PlayerIndex );
const FUniqueNetIdPtr LocalPlayerId = LocalPlayer->GetPreferredUniqueNetId().GetUniqueNetId();

セッション V2 を使用するには、次のファイルをインクルードします。

using AccelByte.Api;
using AccelByte.Core;

次の関数を使用して、AGS と対話するための API クライアントを取得します。

注記

チュートリアルの残りの部分では、各機能に焦点を当てるために、このコードスニペットは含まれません。パーティは V2 のセッション API の一部であり、AGS ロビーはパーティに関する通知を送受信するために使用されます。

var apiClient = AccelByteSDK.GetClientRegistry().GetApi();
var lobby = apiClient.GetLobby();
var session = apiClient.GetSession();

using AccelByte.Sdk.Api;
using AccelByte.Sdk.Api.Session.Model;

C# Extend SDK オブジェクトの作成方法については、Extend SDK の開始を参照してください。

partyService := &session.PartyService{
    Client:          factory.NewSessionClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}

Go Extend SDK オブジェクトの作成方法については、Extend SDK の開始を参照してください。

Refer to [getting started with Extend SDK](../../01-foundations/extend/06-extend-sdk/01-get-started-with-extend-sdk.md) on how to create JavaExtend SDK object.

import accelbyte_py_sdk.api.session as session_service
import accelbyte_py_sdk.api.session.models as session_models

Python Extend SDK オブジェクトの作成方法については、AGS SDK を使用したアプリケーションアクセストークンの取得を参照してください。

パーティを作成する

プレイヤーは、マッチメイキングに使用できるパーティを作成できます。プレイヤーは一度に1つのパーティのみを作成でき、作成したパーティのリーダーになります。

SessionInterface->AddOnCreateSessionCompleteDelegate_Handle(
  FOnCreateSessionCompleteDelegate::CreateLambda([](const FName SessionName, const bool bWasSuccessful)
    {
      if (SessionName == NAME_PartySession)
      {
        if(!bWasSuccessful)
        {
          // パーティ作成エラー処理
        }
        // パーティ作成処理
      }
    }));

FOnlineSessionSettings NewSessionSettings;
NewSessionSettings.NumPrivateConnections = 4;

NewSessionSettings.Set(SETTING_SESSION_JOIN_TYPE, TEXT("INVITE_ONLY"));
NewSessionSettings.Set(SETTING_SESSION_TYPE, SETTING_SESSION_TYPE_PARTY_SESSION);
NewSessionSettings.Set(SETTING_SESSION_TEMPLATE_NAME, TEXT("TemplateNameFromAP"));

SessionInterface->CreateSession(LocalPlayerId.ToSharedRef().Get(), NAME_PartySession, NewSessionSettings);

var request = new SessionV2PartySessionCreateRequest
{
    attributes = new Dictionary<string, object>(), // 必要に応じてカスタム属性を追加
    configurationName = "config-name-from-admin-portal",
    joinability = SessionV2Joinability.INVITE_ONLY,
    members = Array.Empty<SessionV2MemberData>(), // パーティ作成時に他のユーザーを招待する場合はオプション
    textChat = true // チャットパーティトピックを自動的に作成する場合は有効にする
};

session.CreateParty(request, result =>
{
    if (result.IsError)
    {
        // CreateParty にエラーがある場合の処理
        Debug.Log($"Error CreateParty, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // CreateParty が成功した場合の処理
});

ApimodelsCreatePartyRequest createPartyRequest = new ApimodelsCreatePartyRequest()
{
    ConfigurationName = "config-name-from-admin-portal",
    Joinability = "INVITE_ONLY",
    TextChat = true, // チャットパーティトピックを自動的に作成する場合は有効にする
    Attributes = new Dictionary<string, object>(), // 必要に応じてカスタム属性を追加
    Members = new List<ApimodelsRequestMember>() // パーティ作成時に他のユーザーを招待する場合はオプション
};

var response = sdk.Session.Party.PublicCreatePartyOp
    .Execute(createPartyRequest, sdk.Namespace);
if (response != null)
{
    //パーティ作成後の処理
}

body := sessionclientmodels.ApimodelsCreatePartyRequest {
    ConfigurationName: "config-name-from-admin-portal",
    Joinability: "INVITE_ONLY",
    TextChat: true, // チャットパーティトピックを自動的に作成する場合は有効にする
    Attributes:map[string]interface{}, // 必要に応じてカスタム属性を追加
    Members: []*sessionclientmodels.ApimodelsRequestMember{} // パーティ作成時に他のユーザーを招待する場合はオプション
}
namespace := "mygame"
input := &party.PublicCreatePartyParams{
    Body:      &body,
    Namespace: namespace,
}
result, err := partyService.PublicCreatePartyShort(input)

final Party player1PartyWrapper = new Party(sdk);

ApimodelsCreatePartyRequest body = ApimodelsCreatePartyRequest.builder()
    .configurationName("config-name-from-admin-portal")
    .joinability("INVITE_ONLY")
    .textChat(true) // チャットパーティトピックを自動的に作成する場合は有効にする
    .attributes(new HashMap<>())  // 必要に応じてカスタム属性を追加
    .members(
        Collections.singletonList(ApimodelsRequestMember.builder().id("<player2UserId>").build()))// パーティ作成時に他のユーザーを招待する場合はオプション
    .build();

ApimodelsPartySessionResponse response;
try {
    response = player1PartyWrapper.publicCreateParty(PublicCreateParty.builder()
      .namespace("<namespace>")
      .body(body)
      .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}

if (response == null) {
    // サーバーからの null レスポンス
} else {
    // 成功時の処理
}

result, error = session_service.public_create_party(
    body=session_models.ApimodelsCreatePartyRequest()
        .with_configuration_name("config-name-from-admin-portal")
        .with_joinability("INVITE_ONLY")
        .with_text_chat(True),
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティに招待する

プレイヤーは他のプレイヤーをパーティに招待できます。被招待者はパーティへの招待を受けたという通知を受け取り、現在のパーティメンバーも誰かがパーティに招待されたという通知を受け取ります。

// パーティ招待をリッスン
SessionInterface->AddOnV2SessionInviteReceivedDelegate_Handle(FOnV2SessionInviteReceivedDelegate::CreateLambda(
[](const FUniqueNetId& UserId, const FUniqueNetId&, const FOnlineSessionInviteAccelByte& InviteResult)
{
    if (InviteResult.SessionType == EAccelByteV2SessionType::PartySession)
    {
        // パーティセッション招待通知を処理
        // InviteResult にはパーティの詳細が含まれます
    }
}));

// 他のユーザーに招待を送信
SessionInterface->SendSessionInviteToFriend(LocalPlayerId.ToSharedRef().Get(), NAME_PartySession, OtherUserPlayerId.ToSharedRef().Get());

// パーティ招待通知をリッスン
lobby.SessionV2InvitedUserToParty += result =>
{
    if (result.IsError)
    {
        // SessionV2InvitedUserToParty にエラーがある場合の処理
        Debug.Log($"Error SessionV2InvitedUserToParty, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // SessionV2InvitedUserToParty を受信した場合の処理
};

// 他のユーザーに招待を送信
string partyId = "current-party-id";
string otherUserId = "other-user-id";
session.InviteUserToParty(
    partyId,
    otherUserId,
    result =>
    {
        if (result.IsError)
        {
            // InviteUserToParty にエラーがある場合の処理
            Debug.Log($"Error InviteUserToParty, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
            return;
        }

        // InviteUserToParty が成功した場合の処理
    }
);

string partyId = "<party id>";
string otherUserId = "<user id>";

var response = sdk.Session.Party.PublicPartyInviteOp
    .Execute(new ApimodelsSessionInviteRequest()
    {
        UserID = otherUserId

    }, sdk.Namespace, partyId);
if (response != null)
{
    //招待後の処理
}

otherUserId := "otheruserid"
body := sessionclientmodels.ApimodelsSessionInviteRequest {
    UserID: &otherUserId,
}
namespace := "mygame"
partyId := "mypartyid"
input := &party.PublicPartyInviteParams{
    Body:      &body,
    Namespace: namespace,
    PartyID:   partyId,
}
result, err := partyService.PublicPartyInviteShort(input)

final Party player1PartyWrapper = new Party(sdk);
String partyId = "<party id>";
String otherUserId = "<user id>";
ApimodelsSessionInviteResponse response;
try {
    response = player1PartyWrapper.publicPartyInvite(PublicPartyInvite.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .body(ApimodelsSessionInviteRequest.builder().userID(otherUserId).build())
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// 招待後の処理

result, error = session_service.public_party_invite(
    body=session_models.ApimodelsSessionInviteRequest()
        .with_platform_id("PlatformId")
        .with_user_id("OtherUserId"),
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

送信中のパーティ招待をキャンセルする

プレイヤーは送信中の招待をキャンセルできます。被招待者と招待者は、招待がキャンセルされたという通知を受け取ります。被招待者は、キャンセル後に以前の招待を受け入れることはできません。

// 被招待者と招待者がセッション招待キャンセル通知をリッスン
auto OnSessionInviteCanceledDelegate = SessionInterface->AddOnSessionInviteCanceledDelegate_Handle(
	FOnSessionInviteCanceledDelegate::CreateLambda([](const FString& SessionID) // キャンセルされたパーティの ID
	{
		// 招待キャンセルを受信
	}));

// パーティリーダー(招待者)が招待をキャンセル
FName PartyName = NAME_PartySession;
auto OnCancelSessionInviteCompleteDelegate = SessionInterface->AddOnCancelSessionInviteCompleteDelegate_Handle(FOnCancelSessionInviteCompleteDelegate::CreateLambda(
	[&](const FUniqueNetId& LocalUserId, FName SessionName, const FUniqueNetId& Invitee, const FOnlineError& ErrorInfo)
	{
		bool bInvitationCanceled = ErrorInfo.bSucceeded;
		// セッション招待キャンセル完了
	}));

SessionInterface->CancelSessionInvite(PlayerIndex, PartyName, *InviteeUniqueNetId);

パーティに参加する

パーティに招待されたプレイヤーは、招待を受け入れてパーティに参加できます。パーティ被招待者はパーティに参加したという通知を受け取り、現在のパーティメンバーも誰かがパーティに参加しているという通知を受け取ります。

// パーティ招待をリッスン
SessionInterface->AddOnV2SessionInviteReceivedDelegate_Handle(FOnV2SessionInviteReceivedDelegate::CreateLambda(
[](const FUniqueNetId& UserId, const FUniqueNetId&, const FOnlineSessionInviteAccelByte& InviteResult)
{
    if (InviteResult.SessionType == EAccelByteV2SessionType::PartySession)
    {
        // パーティセッション招待通知を処理
        // InviteResult にはパーティの詳細が含まれます
    }
}));

// パーティセッションへの参加完了のデリゲートを追加
SessionInterface->AddOnJoinSessionCompleteDelegate_Handle(
    FOnJoinSessionCompleteDelegate::CreateLambda([](FName SessionName, EOnJoinSessionCompleteResult::Type Result){
        if (SessionName == NAME_PartySession)
        {
            // パーティセッションへの参加が完了、結果を確認
        }
    }));

// パーティセッションに参加
FOnlineSessionInviteAccelByte Invitation; // 通知からの招待
SessionInterface->JoinSession(*LocalPlayerId.Get(), NAME_PartySession, Invitation.Session);

// パーティ参加通知をリッスン
lobby.SessionV2UserJoinedParty += result =>
{
    if (result.IsError)
    {
        // SessionV2UserJoinedParty にエラーがある場合の処理
        Debug.Log($"Error SessionV2UserJoinedParty, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // SessionV2UserJoinedParty を受信した場合の処理
};

// パーティセッションに参加
string partyId = "invited-party-id";
session.JoinParty(partyId, result =>
{
    if (!result.IsError)
    {
        if (result.IsError)
        {
            // JoinParty にエラーがある場合の処理
            Debug.Log($"Error JoinParty, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
            return;
        }

        // JoinParty が成功した場合の処理
    }
});

string partyId = "<party id>";

var response = sdk.Session.Party.PublicPartyJoinOp
    .Execute(sdk.Namespace, partyId);
if (response != null)
{
    //参加後の処理
}

namespace := "namespace"
partyId := "mypartyid"
input := &party.PublicPartyJoinParams{
    Namespace: namespace,
    PartyID:   partyId,
}
result, err := partyService.PublicPartyJoinShort(input)

final Party player1PartyWrapper = new Party(sdk);
String partyId = "<party id>";
ApimodelsPartySessionResponse response;
try {
    response = player1PartyWrapper.publicPartyJoin(PublicPartyJoin.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// 参加後の処理

result, error = session_service.public_party_join(
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティ招待を拒否する

プレイヤーがパーティに招待された場合、招待を拒否することができます。パーティ被招待者と現在のパーティメンバーは、招待を拒否したという通知を受け取ります。

FOnRejectSessionInviteComplete OnRejectSessionInviteComplete = FOnRejectSessionInviteComplete::CreateLambda([](const bool bWasSuccessful)
    {
        if (bWasSuccessful)
        {
            // パーティ招待の拒否に成功
        }
    });

// パーティセッションに参加
FOnlineSessionInviteAccelByte Invitation; // 通知からの招待
SessionInterface->RejectInvite(LocalPlayerId.ToSharedRef().Get(), Invitation, OnRejectSessionInviteComplete);

// パーティ拒否通知をリッスン
lobby.SessionV2UserRejectedPartyInvitation += result =>
{
    if (result.IsError)
    {
        // SessionV2UserRejectedPartyInvitation にエラーがある場合の処理
        Debug.Log($"Error SessionV2UserRejectedPartyInvitation, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // SessionV2UserRejectedPartyInvitation を受信した場合の処理
};

// パーティ招待を拒否
string partyId = "invited-party-id";
session.RejectPartyInvitation(partyId, result =>
{
    if (result.IsError)
    {
        // RejectPartyInvitation にエラーがある場合の処理
        Debug.Log($"Error RejectPartyInvitation, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // RejectPartyInvitation が成功した場合の処理
});

string partyId = "<party id>";

sdk.Session.Party.PublicPartyRejectOp
    .Execute(sdk.Namespace, partyId);

namespace := "namespace"
partyId := "mypartyid"
input := &party.PublicPartyRejectParams{
    Namespace: namespace,
    PartyID:   partyId,
}
err := partyService.PublicPartyRejectShort(input)

final Party player1PartyWrapper = new Party(sdk);
String partyId = "<party id>";
try {
    player1PartyWrapper.publicPartyReject(PublicPartyReject.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// パーティ拒否成功後の処理

result, error = session_service.public_party_reject(
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

メンバーをパーティリーダーに昇格する

パーティリーダーは、他のパーティメンバーを新しいパーティリーダーに昇格させることができます。すべてのパーティメンバーに新しいパーティリーダーが通知されます。これは、パーティリーダーが他のパーティメンバーを新しいパーティリーダーに昇格させる方法です。新しいパーティリーダーは、パーティメンバーの特定のユーザー ID によって識別されます。

// パーティセッション更新をリッスン
SessionInterface->AddOnSessionUpdateReceivedDelegate_Handle(FOnSessionUpdateReceivedDelegate::CreateLambda([SessionInterface](FName SessionName)
{
    if (SessionName == NAME_PartySession)
    {
        // パーティの更新通知があります
        auto LatestPartySession = SessionInterface->GetNamedSession(NAME_PartySession);
    }
}));

// 他のパーティメンバーをパーティリーダーに昇格
FOnPromotePartySessionLeaderComplete OnPromotePartySessionLeaderComplete =
    FOnPromotePartySessionLeaderComplete::CreateLambda([](const FUniqueNetId& PromotedUserId, const FOnlineError& Result)
    {
        if (Result.bSucceeded)
        {
            // 新しいパーティリーダーの昇格に成功
        }
    });

SessionInterface->PromotePartySessionLeader(LocalPlayerId.ToSharedRef().Get(), NAME_PartySession, OtherUserPlayerId.ToSharedRef().Get(), OnPromotePartySessionLeaderComplete);

// パーティセッション更新通知をリッスン
lobby.SessionV2PartyUpdated += result =>
{
    if (result.IsError)
    {
        // SessionV2PartyUpdated にエラーがある場合の処理
        Debug.Log($"Error SessionV2PartyUpdated, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // SessionV2PartyUpdated を受信した場合の処理
};

lobby.SessionV2PartyMemberChanged += result =>
{
    if (result.IsError)
    {
        // SessionV2PartyMemberChanged にエラーがある場合の処理
        Debug.Log($"Error SessionV2PartyMemberChanged, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // SessionV2PartyMemberChanged を受信した場合の処理
};

// 他のパーティメンバーをパーティリーダーに昇格
string partyId = "current-party-id";
string leaderId = "current-party-leader-id";
session.PromoteUserToPartyLeader(
    partyId,
    leaderId,
    result =>
    {
        if (result.IsError)
        {
            // PromoteUserToPartyLeader にエラーがある場合の処理
            Debug.Log($"Error PromoteUserToPartyLeader, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
            return;
        }

        // PromoteUserToPartyLeader が成功した場合の処理
    }
);

var response = sdk.Session.Party.PublicPromotePartyLeaderOp
    .Execute(new ApimodelsPromoteLeaderRequest()
    {
        LeaderID = leaderId
    }, sdk.Namespace, partyId);
if (response != null)
{
    // 昇格が成功した場合の処理
}

leaderId := "myleaderid"
body := sessionclientmodels.ApimodelsPromoteLeaderRequest {
    LeaderID: &leaderId,
}
namespace := "mygame"
partyId := "mypartyid"
input := &party.PublicPromotePartyLeaderParams{
    Body:      &body,
    Namespace: namespace,
    PartyID:   partyId,
}
result, err := partyService.PublicPromotePartyLeaderShort(input)

final Party player1PartyWrapper = new Party(sdk);
try {
    player1PartyWrapper.publicPromotePartyLeader(PublicPromotePartyLeader.builder()
        .namespace("<namespace>")
        .partyId("<party id>")
        .body(ApimodelsPromoteLeaderRequest.builder().leaderID("<leaderId>").build())
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// パーティリーダー昇格成功後の処理

result, error = session_service.public_promote_party_leader(
    body=session_models.ApimodelsPromoteLeaderRequest()
        .with_leader_id("LeaderId"),
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティからプレイヤーを追放する

パーティリーダーは、パーティメンバーをパーティから削除(追放)する権限を持っています。追放されたパーティメンバーはパーティから追放されたという通知を受け取り、現在のパーティメンバーも誰かがパーティから追放されたという通知を受け取ります。

// パーティセッションからプレイヤーを追放する通知をリッスン
SessionInterface->AddOnKickedFromSessionDelegate_Handle(FOnKickedFromSessionDelegate::CreateLambda([](FName SessionName)
{
    if (SessionName == NAME_PartySession)
    {
        // プレイヤーがパーティから追放されました
    }
}));

// パーティセッションからプレイヤーを追放
FOnKickPlayerComplete OnKickPlayerComplete =
    FOnKickPlayerComplete::CreateLambda([](const bool bWasSuccessful, const FUniqueNetId& KickedPlayerId)
{
    if (bWasSuccessful)
    {
        // プレイヤーがパーティから正常に追放されました
    }
});

SessionInterface->KickPlayer(LocalPlayerId.ToSharedRef().Get(), NAME_PartySession, PlayerIdToKick.ToSharedRef().Get());

// パーティセッションからプレイヤーを追放する通知をリッスン
lobby.SessionV2UserKickedFromParty += result =>
{
    if (result.IsError)
    {
        // SessionV2UserKickedFromPart にエラーがある場合の処理
        Debug.Log($"Error SessionV2UserKickedFromPart, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // SessionV2UserKickedFromPart を受信した場合の処理
};

// パーティセッションからプレイヤーを追放
string partyId = "current-party-id";
string otherUserId = "user-id-to-be-kicked";
session.KickUserFromParty(
    partyId,
    otherUserId,
    result =>
    {
        if (result.IsError)
        {
            // KickUserFromParty にエラーがある場合の処理
            Debug.Log($"Error KickUserFromParty, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
            return;
        }

        // KickUserFromParty が成功した場合の処理
    }
);

string partyId = "<party id>";
string otherUserId = "<user id>";

var response = sdk.Session.Party.PublicPartyKickOp
    .Execute(sdk.Namespace, partyId, otherUserId);
if (response != null)
{
    //プレイヤーがパーティから正常に追放された場合の処理
}

namespace := "namespace"
partyId := "mypartyid"
userId := "myuserid"
input := &party.PublicPartyKickParams{
    Namespace: namespace,
    PartyID:   partyId,
    UserID:    userId,
}
result, err := partyService.PublicPartyKickShort(input)

final Party player1PartyWrapper = new Party(sdk);
String partyId = "<party id>";
String otherUserId = "<user id>";
ApimodelsKickResponse response;
try {
    response = player1PartyWrapper.publicPartyKick(PublicPartyKick.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .userId(otherUserId)
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// プレイヤーがパーティから正常に追放された場合の処理

result, error = session_service.public_party_kick(
    party_id="PartyId",
    user_id="OtherUserId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティから退出する

パーティメンバーは、パーティから退出することを選択できます。パーティリーダーがパーティから退出すると、パーティのリーダーシップは自動的に別のパーティメンバーに渡されます。パーティから退出したパーティメンバーはパーティから退出したという通知を受け取り、現在のパーティメンバーも誰かがパーティから退出しているという通知を受け取ります。

// パーティセッション更新をリッスン
SessionInterface->AddOnSessionUpdateReceivedDelegate_Handle(FOnSessionUpdateReceivedDelegate::CreateLambda([SessionInterface](FName SessionName)
{
    if (SessionName == NAME_PartySession)
    {
    // パーティの更新通知があります
        auto LatestPartySession = SessionInterface->GetNamedSession(NAME_PartySession);
    }
}));

// パーティから退出
PartySession = SessionInterface->GetNamedSession(NAME_PartySession);
auto PartySessionInfo = StaticCastSharedPtr<FOnlineSessionInfoAccelByteV2>(PartySession->SessionInfo);
FString PartyId = PartySessionInfo->GetBackendSessionDataAsPartySession()->ID;

FOnLeaveSessionComplete OnLeavePartyComplete =
    FOnLeaveSessionComplete::CreateLambda([](const bool bWasSuccessful, FString SessionId)
{
    if (bWasSuccessful)
    {
        // パーティの退出に成功
    }
});
SessionInterface->LeaveSession(LocalPlayerId.ToSharedRef().Get(), EAccelByteV2SessionType::PartySession, PartyId, OnLeavePartyComplete);

// パーティセッション更新通知をリッスン
lobby.SessionV2PartyUpdated += result =>
{
    if (result.IsError)
    {
        // SessionV2PartyUpdated にエラーがある場合の処理
        Debug.Log($"Error SessionV2PartyUpdated, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // SessionV2PartyUpdated を受信した場合の処理
};

// パーティから退出
string partyId = "current-party-id";
session.LeaveParty(partyId, result =>
{
    if (result.IsError)
    {
        // LeaveParty にエラーがある場合の処理
        Debug.Log($"Error LeaveParty, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // LeaveParty が成功した場合の処理
});

string partyId = "<party id>";
sdk.Session.Party.PublicPartyLeaveOp
    .Execute(sdk.Namespace, partyId);

namespace := "mygame"
partyId := "mypartyid"
input := &party.PublicPartyLeaveParams{
    Namespace: namespace,
    PartyID:   partyId,
}
err := partyService.PublicPartyLeaveShort(input)

final Party player1PartyWrapper = new Party(sdk);
String partyId = "<party id>";
try {
    player1PartyWrapper.publicPartyLeave(PublicPartyLeave.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// パーティ退出後の処理

result, error = session_service.public_party_leave(
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティコード

パーティリーダーは、プレイヤーがパーティに参加できるように、プレイヤーにパーティコードを送信できます。パーティコードを更新または取り消すことができるのは、パーティリーダーのみです。

パーティコードを取得する

コードが生成されると、パーティリーダーはコードを取得して他のプレイヤーと共有できます。この関数により、パーティリーダーはパーティコードを取得できます。

FString Code;
auto PartySession = SessionInterface->GetNamedSession(NAME_PartySession);
auto PartySessionInfo = StaticCastSharedPtr<FOnlineSessionInfoAccelByteV2>(PartySession->SessionInfo);
FString PartyCode = PartySessionInfo->GetBackendSessionDataAsPartySession()->Code;

PartySession->SessionSettings.Get(SETTING_PARTYSESSION_CODE, PartyCode);

var partyId = "current-party-id";
session.GetPartyDetails(partyId, result =>
{
    if (result.IsError)
    {
        // GetPartyDetails にエラーがある場合の処理
        Debug.Log($"Error GetPartyDetails, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // GetPartyDetails が成功した場合の処理
    var code = result.Value.Code;
});

string partyId = "<party id>";

var response = sdk.Session.Party.PublicGetPartyOp
    .Execute(sdk.Namespace, partyId);
if (response != null)
{
    string partyCode = response.Code!;
    //パーティコードを取得して他のプレイヤーに送信
}

namespace := "mygame"
partyId := "mypartyid"
input := &party.PublicGetPartyParams{
    Namespace: namespace,
    PartyID:   partyId,
}
result, err := partyService.PublicGetPartyShort(input)

String partyId = "<party id>";
final Party player1PartyWrapper = new Party(sdk);
ApimodelsPartySessionResponse response;
try {
    response = player1PartyWrapper.publicGetParty(PublicGetParty.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// パーティコードを取得して他のプレイヤーに送信

result, error = session_service.public_get_party(
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティコードを生成または更新する

次の関数を使用して、パーティコードを生成または更新します。

const FOnGenerateNewPartyCodeComplete OnGenerateNewPartyCodeCompleteDelegate =
    FOnGenerateNewPartyCodeComplete::CreateLambda([](const bool bWasSuccessful, FString NewPartyCode)
{
    if (bWasSuccessful)
    {
        // 新しいパーティコードの生成に成功
    }
});

var partyId = "current-party-id";
session.GenerateNewPartyCode(partyId, result =>
{
    if (result.IsError)
    {
        // GenerateNewPartyCode にエラーがある場合の処理
        Debug.Log($"Error GenerateNewPartyCode, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // GenerateNewPartyCode が成功した場合の処理
});

string partyId = "<party id>";

var response = _Sdk.Session.Party.PublicGeneratePartyCodeOp.
    Execute(_Sdk.Namespace, partyId);
if (response != null)
{
    string partyCode = response.Code!;
    //パーティコードを取得して他のプレイヤーに送信
}

namespace := "mygame"
partyId := "mypartyid"
input := &party.PublicGeneratePartyCodeParams{
    Namespace: namespace,
    PartyID:   partyId,
}
result, err := partyService.PublicGeneratePartyCodeShort(input)

String partyId = "<party id>";
final Party player1PartyWrapper = new Party(sdk);
ApimodelsPartySessionResponse response;
try {
    response = player1PartyWrapper.publicGeneratePartyCode(PublicGeneratePartyCode.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// パーティコードを取得して他のプレイヤーに送信

result, error = session_service.public_generate_party_code(
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティコードを取り消す

パーティリーダーはパーティコードを取り消すことができます。パーティコードが取り消されると、プレイヤーはそれを使用してパーティに参加できなくなります。この関数により、パーティリーダーはパーティコードを取り消すことができます。

const FOnRevokePartyCodeComplete OnRevokePartyCodeComplete =
    FOnRevokePartyCodeComplete::CreateLambda([](const bool bWasSuccessful)
{
    if (bWasSuccessful)
    {
        // パーティコードの取り消しに成功
    }
});

SessionInterface->RevokePartyCode(LocalPlayerId.ToSharedRef().Get(), NAME_PartySession, OnRevokePartyCodeComplete);

var partyId = "current-party-id";
session.RevokePartyCode(partyId, result =>
{
    if (result.IsError)
    {
        // RevokePartyCode にエラーがある場合の処理
        Debug.Log($"Error RevokePartyCode, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // RevokePartyCode が成功した場合の処理
});

string partyId = "<party id>";

sdk.Session.Party.PublicRevokePartyCodeOp
    .Execute(sdk.Namespace, partyId);

namespace := "mygame"
partyId := "mypartyid"
input := &party.PublicRevokePartyCodeParams{
    Namespace: namespace,
    PartyID:   partyId,
}
err := partyService.PublicRevokePartyCodeShort(input)

String partyId = "<party id>";
final Party player1PartyWrapper = new Party(sdk);
try {
    player1PartyWrapper.publicRevokePartyCode(PublicRevokePartyCode.builder()
        .namespace("<namespace>")
        .partyId(partyId)
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// 取り消し成功後の処理

result, error = session_service.public_revoke_party_code(
    party_id="PartyId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティコードでパーティに参加する

パーティコードを送信されたプレイヤーは、それを使用してパーティに参加できます。この関数により、プレイヤーはパーティコードを使用してパーティに参加できます。

// パーティセッションへの参加完了のデリゲートを追加
SessionInterface->AddOnJoinSessionCompleteDelegate_Handle(
    FOnJoinSessionCompleteDelegate::CreateLambda([](FName SessionName, EOnJoinSessionCompleteResult::Type Result){
        if (SessionName == NAME_PartySession)
        {
            // パーティセッションへの参加が完了、結果を確認
        }
    }));

// パーティリーダーからのパーティコード
FString PartyCode = TEXT("PARTY_CODE");
SessionInterface->JoinSession(LocalPlayerId.ToSharedRef().Get(), NAME_PartySession, PartyCode);

var partyCode = "targeted-party-code";
session.JoinPartyByCode(partyCode, result =>
{
    if (result.IsError)
    {
        // JoinPartyByCode にエラーがある場合の処理
        Debug.Log($"Error JoinPartyByCode, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // JoinPartyByCode が成功した場合の処理
});

var response = _Sdk.Session.Party.PublicPartyJoinCodeOp
    .Execute(new ApimodelsJoinByCodeRequest()
    {
        Code = "<targeted party code>"
    }, _Sdk.Namespace);
if (response != null)
{
    //パーティ参加が成功した場合の処理
}

code := "mypartycode"
body := sessionclientmodels.ApimodelsJoinByCodeRequest {
    Code: &code,
}
namespace := "mygame"
input := &party.PublicPartyJoinCodeParams{
    Body:      &body,
    Namespace: namespace,
}
result, err := partyService.PublicPartyJoinCodeShort(input)

final Party player1PartyWrapper = new Party(sdk);
ApimodelsPartySessionResponse response;
try {
    response = player1PartyWrapper.publicPartyJoinCode(PublicPartyJoinCode.builder()
        .namespace("<namespace>")
        .body(ApimodelsJoinByCodeRequest.builder().code("<targeted party code>").build())
        .build());
} catch (Exception e) {
  // 失敗時の処理
  return;
}
// パーティ参加が成功した場合の処理

result, error = session_service.public_party_join_code(
    body=session_models.ApimodelsJoinByCodeRequest()
        .with_code("PartyCode"),
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

パーティセッションを更新する

ゲームセッションは、Refresh Session メソッドを使用してバックエンドと同期するために更新できます。提供される SessionName パラメーターは、NAME_PartySession に対応する場合があります。

OSS Unreal

SessionInterface->RefreshSession(SessionName, FOnRefreshSessionComplete::CreateLambda([]()
{
    // セッション更新完了時
}));

アクティブセッションを更新する

問題を防ぎ、バックエンドとの適切な同期を確保するには、次の関数を使用して、クライアントにローカルにキャッシュされているすべてのアクティブセッションを更新します。

OSS Unreal

SessionInterface->RefreshActiveSessions(FOnRefreshActiveSessionsComplete::CreateLambda(
    [&](bool bWasSuccessful)
{
    // アクティブセッション更新完了時
}));

概要​

パーミッション​

前提条件​

パーティを作成する​

パーティに招待する​

送信中のパーティ招待をキャンセルする​

パーティに参加する​

パーティ招待を拒否する​

メンバーをパーティリーダーに昇格する​

パーティからプレイヤーを追放する​

パーティから退出する​

パーティコード​

パーティコードを取得する​

パーティコードを生成または更新する​

パーティコードを取り消す​

パーティコードでパーティに参加する​

パーティセッションを更新する​

アクティブセッションを更新する​

概要