NAV Navbar
Python Java GS2-Formation
 

GS2-Matchmaking

対戦相手や協力相手を実現するサービスです。

マッチメイキングの流れは以下です。

ホストがギャザリングの作成 ↓ 参加者が条件にみあうギャザリングを検索 ↓ 規定人数が集まったらマッチメイキング完了

GS2-Matchmaking はこの流れのうち 参加者が条件にみあうギャザリングを検索 に関してできるだけ多くのニーズをみたせるよう設計されています。 ここでは、ユースケースを交えつつ、その設計例を解説します。

ゲーム内には、カジュアルプレイヤー向けと、コアゲーマー向けの2種類のゲームモードがあります。 これらのプレイヤーを混ぜることなくマッチメイキング処理を行いたいとします。

ギャザリングを作成する際にも、ギャザリングを検索する際にも、最大5つの属性値を指定できます。 ギャザリングを作成する際には募集するプレイヤーが持つ属性値の範囲を指定し、 ギャザリングを検索する際には、自身の属性値の値を指定して処理依頼をします。

つまり、ホストがギャザリングを作成する際に 属性値1 に募集するゲームモードを指定し、 検索する側も自分が参加したいゲームモードを 属性値1 に指定することで、希望するゲームモードが同じプレイヤー同士がマッチメイキングされます。

ホストはギャザリングを作成する際に 属性値2 に募集するレベルの最小値と最大値を指定します。 検索する側は自分のレベルを 属性値2 に指定することで、同じレベル帯のプレイヤー同士がマッチメイキングされます。

複数の属性値を指定した場合はすべての属性値の範囲をみたす相手を探すよう処理されます。

最初は狭い範囲で募集し、なるべく同じレベルのプレイヤー同士でマッチメイキングするが、なかなか対戦相手が見つからない場合、募集するレベル帯を広げて募集したいとします。 ギャザリングを作成しておよそ1分ごとに発火する GS2-Script イベントがあります。 このスクリプトにて、ギャザリングの属性値の範囲を緩和することで、徐々に希望する条件を緩和する処理を実装できます。

ギャザリングを作成するときのオプションとして、参加を許可するユーザIDリストを指定できます。 これを使い、フレンドのユーザIDリストを指定することで、参加者を限定することができます。

ギャザリングの作成時・検索時にユーザIDのブラックリストを指定できます。 検索時に指定したブラックリストは、条件に一致するギャザリングを発見し、参加したギャザリングのブラックリストに加えられます。 検索する際に自身がブラックリストに入っている場合はマッチメイキングの対象から除外されます。

ゲームによっては盾役1人、回復役1人、攻撃役2人でマッチメイキングを行いたいことがあります。 このときに使用できるのが ロール属性 です。

盾役として tank を、回復役として healer を、攻撃役として attacker というロールを想定します。 ギャザリングを作成するときに各ロールの募集人数を設定します。 ギャザリングの検索時に自分のロールに設定することで、ロールに関して空きのあるギャザリングだけが参加可能なギャザリングとして処理されます。

募集ロールにはエイリアスを設定することもできます。 例えば、 tank を更に具体的なロールで表現し、 paladinwarriordark_knight のいずれかとしてギャザリングの検索を行うとします。 ギャザリングを作成するときに、 tank のエイリアスに paladindark_knight を指定した場合、 warrior は参加できないギャザリングが作成できます。

マッチメイキング完了後に、1名が離脱し 1名だけ補充したいときに使用します。 このときに使用するのがパーティトークンです。パーティトークンを発行するにはパーティを編成するプレイヤーのプレイヤートークンです。 プレイヤートークンはプレイヤー自身が自分の代わりにパーティの代表者がマッチメイキングを行うことを許可するトークンで、3分間の有効期限があります。 パーティメンバーはそれぞれ、プレイヤートークンを発行するAPIに依頼をしてプレイヤートークンを入手し、パーティの代表者に送信します。 パーティの代表者はパーティメンバーからプレイヤートークンを受け取り、3分以内にパーティトークン発行APIに送信することで、パーティトークンを入手できます。 パーティトークンには10分の有効期限があり、10分以内にパーティトークンを使用してギャザリング作成処理または、ギャザリング検索処理を呼び出します。 こうすることで、パーティメンバー全員が参加した状態のギャザリングを作成、またはパーティメンバー全員が参加できるギャザリングに参加します。

4 vs 4 で対戦するゲームで、事前に編成したパーティを敵味方に分散することなく対戦したいことがあります。 たとえば、事前に3人で編成したパーティと、事前に4人で編成したパーティ、そして1人の野良プレイヤーをマッチメイキングして、 事前に3人で編成したパーティ + 1人の野良プレイヤー vs 事前に4人で編成したパーティ という対戦を実現したいとします。 このようなケースでは、まずは4人のマッチメイキングを実行します。 すると、3人で編成したパーティ + 1人の野良プレイヤー事前に4人で編成したパーティ の2つのギャザリングができます。 その後、それぞれのパーティの代表者が 定員2人のマッチメイキングをおこない、パーティ同士がマッチメイキングされます。 こうすることで 事前に3人で編成したパーティ + 1人の野良プレイヤー vs 事前に4人で編成したパーティ を実現できます。

マッチメイキングが完了していない状態でプレイヤー間のやりとりを必要とすることがあります。 GS2-Matchmaking では、ギャザリングの作成時にプレイヤー間の通信をする手段として2種類の方法を提供します。

募集が終わっていない状態でも、プレイヤー間のでメタデータを低頻度で交換したい場合は前者を、 募集しながらNPCを交えたり人数が不足した状態でゲームを遊ばせたい場合は後者を使用します。

低頻度・高頻度の判断基準として使用できるのが GS2-Chat の持つ制限です。 GS2-Chat は1つのチャットルームに対して秒間3回しか発言ができません。この頻度を超える場合は GS2-Realtime を使用してください。

マッチメイキングが完了したときに GS2-Gateway を使用したゲーム内プッシュ通知GS2-JobQueue によるジョブ登録 でプレイヤーにマッチメイキングの完了を知らせることができます。 また、GS2-Script を使用して任意のスクリプトを実行することもできます。 GS2-Realtime を使用してマッチメイキング後の対戦・協力プレイを実現する場合は、マッチメイキング完了後に実行される GS2-Script で GS2-Realtime のギャザリングを作成し、そのギャザリングのIPアドレス・ポートの情報を GS2-Gateway を使用したゲーム内プッシュ通知GS2-JobQueue によるジョブ登録 を使用して通知することで、ゲームサーバに誘導できます。

GS2-Matchmaking のデータ構造は以下です。

モデル

Namespace

ネームスペース

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
createGatheringTriggerType string true ギャザリング新規作成時のアクション
createGatheringTriggerRealtimeNamespaceId string true ギャザリング新規作成時 にルームを作成するネームスペース のGRN
createGatheringTriggerScriptId string true ギャザリング新規作成時 に実行されるスクリプト のGRN
completeMatchmakingTriggerType string true マッチメイキング完了時のアクション
completeMatchmakingTriggerRealtimeNamespaceId string true マッチメイキング完了時 にルームを作成するネームスペース のGRN
completeMatchmakingTriggerScriptId string true マッチメイキング完了時 に実行されるスクリプト のGRN
joinNotification NotificationSetting false ギャザリングに新規プレイヤーが参加したときのプッシュ通知
leaveNotification NotificationSetting false ギャザリングからプレイヤーが離脱したときのプッシュ通知
completeNotification NotificationSetting false マッチメイキングが完了したときのプッシュ通知
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

Gathering

ギャザリング

編成中・編成されたギャザリングの参加条件や参加メンバーに関する情報を保持。

パラメータ データ型 必須 説明
gatheringId string true ギャザリング
name string true ギャザリング名
attributeRanges list[AttributeRange] false 募集条件
capacityOfRoles list[CapacityOfRole] true 参加者
allowUserIds list[string] true 参加を許可するユーザIDリスト
metadata string false メタデータ
createdAt long true 作成日時
updatedAt long true 最終更新日時

ResponseCache

レスポンスキャッシュ

パラメータ データ型 必須 説明
region string false
ownerId string true オーナーID
responseCacheId string true レスポンスキャッシュ のGRN
requestHash string false
result string true APIの応答内容

NotificationSetting

プッシュ通知設定

パラメータ データ型 必須 説明
gatewayNamespaceId string false プッシュ通知に使用する GS2-Gateway のネームスペース のGRN
enableTransferMobileNotification boolean false モバイルプッシュ通知へ転送するか
sound string false モバイルプッシュ通知で使用するサウンドファイル名

LogSetting

ロギング通知設定

パラメータ データ型 必須 説明
loggingNamespaceId string false ログの記録に使用する GS2-Log のネームスペース のGRN

AttributeRange

ギャザリング参加可能な属性値の範囲

パラメータ データ型 必須 説明
name string true 属性名
min integer true ギャザリング参加可能な属性値の最小値
max integer true ギャザリング参加可能な属性値の最大値

CapacityOfRole

ロールごとのキャパシティ

パラメータ データ型 必須 説明
roleName string true ロール名
roleAliases list[string] false ロール名の別名リスト
capacity integer true 募集人数
participants list[Player] true 参加者のプレイヤー情報リスト

Attribute

プレイヤーの属性値

パラメータ データ型 必須 説明
name string true 属性名
value integer true 属性値

Player

プレイヤー情報

パラメータ データ型 必須 説明
userId string false ユーザーID
attributes list[Attribute] false 属性値のリスト
roleName string true ロール名
denyUserIds list[string] true 参加を拒否するユーザIDリスト

初期化処理

HTTPプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_matchmaking_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2MatchmakingRestClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.matchmaking.rest.Gs2MatchmakingRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)
session.connect()
Gs2MatchmakingRestClient client = new Gs2MatchmakingRestClient(session)
初期化処理は不要です

HTTPプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_matchmaking_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2MatchmakingRestClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.matchmaking.rest.Gs2MatchmakingRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2MatchmakingRestClient client = new Gs2MatchmakingRestClient(session)
    }
)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_matchmaking_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2MatchmakingWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.matchmaking.webSocket.Gs2MatchmakingWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect()
Gs2MatchmakingWebSocketClient client = new Gs2MatchmakingWebSocketClient(session)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_matchmaking_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2MatchmakingWebSocketClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.matchmaking.webSocket.Gs2MatchmakingWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2MatchmakingWebSocketClient client = new Gs2MatchmakingWebSocketClient(session)
    }
)
初期化処理は不要です

GS2-Matchmaking は HTTPプロトコル と WebSocketプロトコル の2種類のプロトコルをサポートしています。

HTTPプロトコル と WebSocketプロトコル の違いは以下に示すとおりです。

HTTP WebSocket
接続方式 都度接続 常時接続
応答性能 優れている
API制限 なし 大容量のデータをやりとりするAPIには使用不可(主にマスターデータ系処理)
利用料金 WebSocketと同一 HTTPと同一

終了処理

HTTPプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

WebSocketプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

session オブジェクトの切断処理を行って終了処理を行います。 同一 session オブジェクトを複数の異なる Client オブジェクトに渡すことができます。

メソッド

cancelMatchmaking

同期処理

from gs2_matchmaking_client.request import CancelMatchmakingRequest
from gs2_matchmaking_client.result import CancelMatchmakingResult

result = client.cancel_matchmaking(
    CancelMatchmakingRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name(gathering1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.CancelMatchmakingRequest
import io.gs2.matchmaking.result.CancelMatchmakingResult

result = client.cancelMatchmaking(
    CancelMatchmakingRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName(gathering1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import CancelMatchmakingRequest
from gs2_matchmaking_client.result import CancelMatchmakingResult

def callback(async_result: AsyncResult[CancelMatchmakingResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.cancel_matchmaking_async(
    CancelMatchmakingRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name(gathering1['name']),
    callback
)
import io.gs2.matchmaking.request.CancelMatchmakingRequest
import io.gs2.matchmaking.result.CancelMatchmakingResult

result = client.cancelMatchmaking(
    CancelMatchmakingRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName(gathering1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

マッチメイキングをキャンセルする

ギャザリングから離脱する前にマッチメイキングが完了した場合は、NotFoundException(404エラー) が発生し失敗します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
gatheringName string true ギャザリング名
パラメータ データ型 説明
item Gathering ギャザリング

cancelMatchmakingByUserId

同期処理

from gs2_matchmaking_client.request import CancelMatchmakingByUserIdRequest
from gs2_matchmaking_client.result import CancelMatchmakingByUserIdResult

result = client.cancel_matchmaking_by_user_id(
    CancelMatchmakingByUserIdRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name('gathering-0003')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.CancelMatchmakingByUserIdRequest
import io.gs2.matchmaking.result.CancelMatchmakingByUserIdResult

result = client.cancelMatchmakingByUserId(
    CancelMatchmakingByUserIdRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName("gathering-0003")
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import CancelMatchmakingByUserIdRequest
from gs2_matchmaking_client.result import CancelMatchmakingByUserIdResult

def callback(async_result: AsyncResult[CancelMatchmakingByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.cancel_matchmaking_by_user_id_async(
    CancelMatchmakingByUserIdRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name('gathering-0003')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.matchmaking.request.CancelMatchmakingByUserIdRequest
import io.gs2.matchmaking.result.CancelMatchmakingByUserIdResult

result = client.cancelMatchmakingByUserId(
    CancelMatchmakingByUserIdRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName("gathering-0003")
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してマッチメイキングをキャンセルする

ギャザリングから離脱する前にマッチメイキングが完了した場合は、NotFoundException(404エラー) が発生し失敗します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
gatheringName string true ギャザリング名
userId string true ユーザーID
パラメータ データ型 説明
item Gathering ギャザリング

createGathering

同期処理

from gs2_matchmaking_client.request import CreateGatheringRequest
from gs2_matchmaking_client.result import CreateGatheringResult

result = client.create_gathering(
    CreateGatheringRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_player(Object("Player", {"attributes": [
Object("Attribute", {"name": 'stage', "value": 1}), 
Object("Attribute", {"name": 'level', "value": 10})
]}))\
        .with_attribute_ranges([
Object("AttributeRange", {"name": 'stage', "min": 1, "max": 1}),    
Object("AttributeRange", {"name": 'level', "min": 0, "max": 10})
])\
        .with_capacity_of_roles([
Object("CapacityOfRole", {"roleName": 'default', "capacity": 4})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.CreateGatheringRequest
import io.gs2.matchmaking.result.CreateGatheringResult

result = client.createGathering(
    CreateGatheringRequest()
        .withNamespaceName("matchmaking-0001")
        .withPlayer(Object("Player", {"attributes": new [] {
Object("Attribute", {"name": "stage", "value": 1}), 
Object("Attribute", {"name": "level", "value": 10})
}}))
        .withAttributeRanges(new [] {
Object("AttributeRange", {"name": "stage", "min": 1, "max": 1}),    
Object("AttributeRange", {"name": "level", "min": 0, "max": 10})
})
        .withCapacityOfRoles(new [] {
Object("CapacityOfRole", {"roleName": "default", "capacity": 4})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import CreateGatheringRequest
from gs2_matchmaking_client.result import CreateGatheringResult

def callback(async_result: AsyncResult[CreateGatheringResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_gathering_async(
    CreateGatheringRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_player(Object("Player", {"attributes": [
Object("Attribute", {"name": 'stage', "value": 1}), 
Object("Attribute", {"name": 'level', "value": 10})
]}))\
        .with_attribute_ranges([
Object("AttributeRange", {"name": 'stage', "min": 1, "max": 1}),    
Object("AttributeRange", {"name": 'level', "min": 0, "max": 10})
])\
        .with_capacity_of_roles([
Object("CapacityOfRole", {"roleName": 'default', "capacity": 4})
]),
    callback
)
import io.gs2.matchmaking.request.CreateGatheringRequest
import io.gs2.matchmaking.result.CreateGatheringResult

result = client.createGathering(
    CreateGatheringRequest()
        .withNamespaceName("matchmaking-0001")
        .withPlayer(Object("Player", {"attributes": new [] {
Object("Attribute", {"name": "stage", "value": 1}), 
Object("Attribute", {"name": "level", "value": 10})
}}))
        .withAttributeRanges(new [] {
Object("AttributeRange", {"name": "stage", "min": 1, "max": 1}),    
Object("AttributeRange", {"name": "level", "min": 0, "max": 10})
})
        .withCapacityOfRoles(new [] {
Object("CapacityOfRole", {"roleName": "default", "capacity": 4})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Matchmaking::Gathering
Properties:
  NamespaceName: String
  Player:
    UserId: Optional[String]
    Attributes:
      - Attribute
      - Attribute
    RoleName: String
    DenyUserIds:
      - String
      - String
  AttributeRanges:
    -
      Name: String
      Min: Integer
      Max: Integer
    -
      Name: String
      Min: Integer
      Max: Integer
  CapacityOfRoles:
    -
      RoleName: String
      RoleAliases:
        - String
        - String
      Capacity: Integer
      Participants:
        - Player
        - Player
    -
      RoleName: String
      RoleAliases:
        - String
        - String
      Capacity: Integer
      Participants:
        - Player
        - Player
  AllowUserIds:
    - String
    - String

ギャザリングを作成して募集を開始

募集条件 には、作成したギャザリングに参加を許可する各属性値の範囲を指定します。

たとえば、同一ゲームモードを希望するプレイヤーを募集したい場合は、ゲームモードに対応した属性値が完全一致する参加条件プレイヤーとマッチメイキングするように 属性名:ゲームモード 属性最小値: ゲームモードを表す数値 属性最大値: ゲームモードを表す数値 とすることで、同一ゲームモードを希望するプレイヤー同士をマッチメイキングできます。

他にレーティングをベースにしたマッチメイキングを実施したい場合は、 ルーム作成者のレーティング値を中心とした属性値の範囲を指定することで、レーティング値の近いプレイヤー同士をマッチメイキングできます。 この 募集条件 はあとで更新することができますので、徐々に条件を緩和していくことができます。

ロール とは 盾役1人・回復役1人・攻撃役2人 などの役割ごとに募集人数を設定したい場合に使用します。 ロールにはエイリアスを指定できます。 たとえば、盾役は パラディン と ナイト の2種類の ジョブ に更に分類できるとします。 この場合、ロール名 に 盾役 エイリアス に パラディン ナイト として募集を出すようにゲームを実装します。 そして、プレイヤーは自分自身の ジョブ を自身のプレイヤー情報のロールに指定します。

こうすることで、募集条件が 盾役 になっているギャザリングには パラディンナイト も参加できます。 一方で、ギャザリングを作成するときに、 パラディン だけ募集したくて、 ナイト を募集したくない場合は、 募集するロール名に パラディン を直接指定したり、エイリアスに ナイト を含めないようにすることで実現できます。

参加者募集人数 はプレイヤーの募集人数を指定します。ロール名を指定することで、ロール名ごとの募集人数を設定できます。

参加者参加者のプレイヤー情報リスト には事前にプレイヤー間でパーティを構築している場合や、参加者が離脱したあとの追加募集で使用します。

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
player Player true 自身のプレイヤー情報
attributeRanges list[AttributeRange] false 募集条件
capacityOfRoles list[CapacityOfRole] true 参加者
allowUserIds list[string] true 参加を許可するユーザIDリスト
パラメータ データ型 説明
item Gathering ギャザリング

createGatheringByUserId

同期処理

from gs2_matchmaking_client.request import CreateGatheringByUserIdRequest
from gs2_matchmaking_client.result import CreateGatheringByUserIdResult

result = client.create_gathering_by_user_id(
    CreateGatheringByUserIdRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_user_id('user-0001')\
        .with_player(Object("Player", {"attributes": [
Object("Attribute", {"name": 'stage', "value": 2}), 
Object("Attribute", {"name": 'level', "value": 10})
]}))\
        .with_attribute_ranges([
Object("AttributeRange", {"name": 'stage', "min": 2, "max": 2}),    
Object("AttributeRange", {"name": 'level', "min": 0, "max": 10})
])\
        .with_capacity_of_roles([
Object("CapacityOfRole", {"roleName": 'default', "capacity": 8})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.CreateGatheringByUserIdRequest
import io.gs2.matchmaking.result.CreateGatheringByUserIdResult

result = client.createGatheringByUserId(
    CreateGatheringByUserIdRequest()
        .withNamespaceName("matchmaking-0001")
        .withUserId("user-0001")
        .withPlayer(Object("Player", {"attributes": new [] {
Object("Attribute", {"name": "stage", "value": 2}), 
Object("Attribute", {"name": "level", "value": 10})
}}))
        .withAttributeRanges(new [] {
Object("AttributeRange", {"name": "stage", "min": 2, "max": 2}),    
Object("AttributeRange", {"name": "level", "min": 0, "max": 10})
})
        .withCapacityOfRoles(new [] {
Object("CapacityOfRole", {"roleName": "default", "capacity": 8})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import CreateGatheringByUserIdRequest
from gs2_matchmaking_client.result import CreateGatheringByUserIdResult

def callback(async_result: AsyncResult[CreateGatheringByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_gathering_by_user_id_async(
    CreateGatheringByUserIdRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_user_id('user-0001')\
        .with_player(Object("Player", {"attributes": [
Object("Attribute", {"name": 'stage', "value": 2}), 
Object("Attribute", {"name": 'level', "value": 10})
]}))\
        .with_attribute_ranges([
Object("AttributeRange", {"name": 'stage', "min": 2, "max": 2}),    
Object("AttributeRange", {"name": 'level', "min": 0, "max": 10})
])\
        .with_capacity_of_roles([
Object("CapacityOfRole", {"roleName": 'default', "capacity": 8})
]),
    callback
)
import io.gs2.matchmaking.request.CreateGatheringByUserIdRequest
import io.gs2.matchmaking.result.CreateGatheringByUserIdResult

result = client.createGatheringByUserId(
    CreateGatheringByUserIdRequest()
        .withNamespaceName("matchmaking-0001")
        .withUserId("user-0001")
        .withPlayer(Object("Player", {"attributes": new [] {
Object("Attribute", {"name": "stage", "value": 2}), 
Object("Attribute", {"name": "level", "value": 10})
}}))
        .withAttributeRanges(new [] {
Object("AttributeRange", {"name": "stage", "min": 2, "max": 2}),    
Object("AttributeRange", {"name": "level", "min": 0, "max": 10})
})
        .withCapacityOfRoles(new [] {
Object("CapacityOfRole", {"roleName": "default", "capacity": 8})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Matchmaking::Gathering
Properties:
  NamespaceName: String
  UserId: String
  Player:
    UserId: Optional[String]
    Attributes:
      - Attribute
      - Attribute
    RoleName: String
    DenyUserIds:
      - String
      - String
  AttributeRanges:
    -
      Name: String
      Min: Integer
      Max: Integer
    -
      Name: String
      Min: Integer
      Max: Integer
  CapacityOfRoles:
    -
      RoleName: String
      RoleAliases:
        - String
        - String
      Capacity: Integer
      Participants:
        - Player
        - Player
    -
      RoleName: String
      RoleAliases:
        - String
        - String
      Capacity: Integer
      Participants:
        - Player
        - Player
  AllowUserIds:
    - String
    - String

ギャザリングを作成して募集を開始

募集条件 には、作成したギャザリングに参加を許可する各属性値の範囲を指定します。

たとえば、同一ゲームモードを希望するプレイヤーを募集したい場合は、ゲームモードに対応した属性値が完全一致する参加条件プレイヤーとマッチメイキングするように 属性名:ゲームモード 属性最小値: ゲームモードを表す数値 属性最大値: ゲームモードを表す数値 とすることで、同一ゲームモードを希望するプレイヤー同士をマッチメイキングできます。

他にレーティングをベースにしたマッチメイキングを実施したい場合は、 ルーム作成者のレーティング値を中心とした属性値の範囲を指定することで、レーティング値の近いプレイヤー同士をマッチメイキングできます。 この 募集条件 はあとで更新することができますので、徐々に条件を緩和していくことができます。

ロール とは 盾役1人・回復役1人・攻撃役2人 などの役割ごとに募集人数を設定したい場合に使用します。 ロールにはエイリアスを指定できます。 たとえば、盾役は パラディン と ナイト の2種類の ジョブ に更に分類できるとします。 この場合、ロール名 に 盾役 エイリアス に パラディン ナイト として募集を出すようにゲームを実装します。 そして、プレイヤーは自分自身の ジョブ を自身のプレイヤー情報のロールに指定します。

こうすることで、募集条件が 盾役 になっているギャザリングには パラディンナイト も参加できます。 一方で、ギャザリングを作成するときに、 パラディン だけ募集したくて、 ナイト を募集したくない場合は、 募集するロール名に パラディン を直接指定したり、エイリアスに ナイト を含めないようにすることで実現できます。

参加者募集人数 はプレイヤーの募集人数を指定します。ロール名を指定することで、ロール名ごとの募集人数を設定できます。

参加者参加者のプレイヤー情報リスト には事前にプレイヤー間でパーティを構築している場合や、参加者が離脱したあとの追加募集で使用します。

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
player Player true 自身のプレイヤー情報
attributeRanges list[AttributeRange] false 募集条件
capacityOfRoles list[CapacityOfRole] true 参加者
allowUserIds list[string] true 参加を許可するユーザIDリスト
パラメータ データ型 説明
item Gathering ギャザリング

createNamespace

同期処理

from gs2_matchmaking_client.request import CreateNamespaceRequest
from gs2_matchmaking_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('matchmaking-0001')\
        .with_create_gathering_trigger_type('none')\
        .with_complete_matchmaking_trigger_type('none')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.CreateNamespaceRequest
import io.gs2.matchmaking.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("matchmaking-0001")
        .withCreateGatheringTriggerType("none")
        .withCompleteMatchmakingTriggerType("none")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import CreateNamespaceRequest
from gs2_matchmaking_client.result import CreateNamespaceResult

def callback(async_result: AsyncResult[CreateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_namespace_async(
    CreateNamespaceRequest()\
        .with_name('matchmaking-0001')\
        .with_create_gathering_trigger_type('none')\
        .with_complete_matchmaking_trigger_type('none')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.matchmaking.request.CreateNamespaceRequest
import io.gs2.matchmaking.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("matchmaking-0001")
        .withCreateGatheringTriggerType("none")
        .withCompleteMatchmakingTriggerType("none")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Matchmaking::Namespace
Properties:
  Name: String
  Description: Optional[String]
  CreateGatheringTriggerType: String
  CreateGatheringTriggerRealtimeNamespaceId: String
  CreateGatheringTriggerScriptId: String
  CompleteMatchmakingTriggerType: String
  CompleteMatchmakingTriggerRealtimeNamespaceId: String
  CompleteMatchmakingTriggerScriptId: String
  JoinNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  LeaveNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  CompleteNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

ネームスペースを新規作成

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
createGatheringTriggerType string true ギャザリング新規作成時のアクション
createGatheringTriggerRealtimeNamespaceId string true ギャザリング新規作成時 にルームを作成するネームスペース のGRN
createGatheringTriggerScriptId string true ギャザリング新規作成時 に実行されるスクリプト のGRN
completeMatchmakingTriggerType string true マッチメイキング完了時のアクション
completeMatchmakingTriggerRealtimeNamespaceId string true マッチメイキング完了時 にルームを作成するネームスペース のGRN
completeMatchmakingTriggerScriptId string true マッチメイキング完了時 に実行されるスクリプト のGRN
joinNotification NotificationSetting false ギャザリングに新規プレイヤーが参加したときのプッシュ通知
leaveNotification NotificationSetting false ギャザリングからプレイヤーが離脱したときのプッシュ通知
completeNotification NotificationSetting false マッチメイキングが完了したときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteGathering

同期処理

from gs2_matchmaking_client.request import DeleteGatheringRequest
from gs2_matchmaking_client.result import DeleteGatheringResult

result = client.delete_gathering(
    DeleteGatheringRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.DeleteGatheringRequest
import io.gs2.matchmaking.result.DeleteGatheringResult

result = client.deleteGathering(
    DeleteGatheringRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import DeleteGatheringRequest
from gs2_matchmaking_client.result import DeleteGatheringResult

def callback(async_result: AsyncResult[DeleteGatheringResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_gathering_async(
    DeleteGatheringRequest()\
    callback
)
import io.gs2.matchmaking.request.DeleteGatheringRequest
import io.gs2.matchmaking.result.DeleteGatheringResult

result = client.deleteGathering(
    DeleteGatheringRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ギャザリングを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
gatheringName string true ギャザリング名
パラメータ データ型 説明
item Gathering ギャザリング

deleteNamespace

同期処理

from gs2_matchmaking_client.request import DeleteNamespaceRequest
from gs2_matchmaking_client.result import DeleteNamespaceResult

result = client.delete_namespace(
    DeleteNamespaceRequest()\
        .with_namespace_name('matchmaking-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.DeleteNamespaceRequest
import io.gs2.matchmaking.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("matchmaking-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import DeleteNamespaceRequest
from gs2_matchmaking_client.result import DeleteNamespaceResult

def callback(async_result: AsyncResult[DeleteNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_namespace_async(
    DeleteNamespaceRequest()\
        .with_namespace_name('matchmaking-0001'),
    callback
)
import io.gs2.matchmaking.request.DeleteNamespaceRequest
import io.gs2.matchmaking.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("matchmaking-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace 削除したネームスペース

describeGatherings

同期処理

from gs2_matchmaking_client.request import DescribeGatheringsRequest
from gs2_matchmaking_client.result import DescribeGatheringsResult

result = client.describe_gatherings(
    DescribeGatheringsRequest()\
        .with_namespace_name('matchmaking-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.DescribeGatheringsRequest
import io.gs2.matchmaking.result.DescribeGatheringsResult

result = client.describeGatherings(
    DescribeGatheringsRequest()
        .withNamespaceName("matchmaking-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import DescribeGatheringsRequest
from gs2_matchmaking_client.result import DescribeGatheringsResult

def callback(async_result: AsyncResult[DescribeGatheringsResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_gatherings_async(
    DescribeGatheringsRequest()\
        .with_namespace_name('matchmaking-0001'),
    callback
)
import io.gs2.matchmaking.request.DescribeGatheringsRequest
import io.gs2.matchmaking.result.DescribeGatheringsResult

result = client.describeGatherings(
    DescribeGatheringsRequest()
        .withNamespaceName("matchmaking-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ギャザリングの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Gathering] ギャザリングのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeNamespaces

同期処理

from gs2_matchmaking_client.request import DescribeNamespacesRequest
from gs2_matchmaking_client.result import DescribeNamespacesResult

result = client.describe_namespaces(
    DescribeNamespacesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.DescribeNamespacesRequest
import io.gs2.matchmaking.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import DescribeNamespacesRequest
from gs2_matchmaking_client.result import DescribeNamespacesResult

def callback(async_result: AsyncResult[DescribeNamespacesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_namespaces_async(
    DescribeNamespacesRequest()\
    callback
)
import io.gs2.matchmaking.request.DescribeNamespacesRequest
import io.gs2.matchmaking.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースの一覧を取得

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Namespace] ネームスペースのリスト
nextPageToken string リストの続きを取得するためのページトークン

doMatchmaking

同期処理

from gs2_matchmaking_client.request import DoMatchmakingRequest
from gs2_matchmaking_client.result import DoMatchmakingResult

result = client.do_matchmaking(
    DoMatchmakingRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.DoMatchmakingRequest
import io.gs2.matchmaking.result.DoMatchmakingResult

result = client.doMatchmaking(
    DoMatchmakingRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import DoMatchmakingRequest
from gs2_matchmaking_client.result import DoMatchmakingResult

def callback(async_result: AsyncResult[DoMatchmakingResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.do_matchmaking_async(
    DoMatchmakingRequest()\
    callback
)
import io.gs2.matchmaking.request.DoMatchmakingRequest
import io.gs2.matchmaking.result.DoMatchmakingResult

result = client.doMatchmaking(
    DoMatchmakingRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Matchmaking::Gathering
Properties:
  NamespaceName: String
  Player:
    UserId: Optional[String]
    Attributes:
      - Attribute
      - Attribute
    RoleName: String
    DenyUserIds:
      - String
      - String
  MatchmakingContextToken: Optional[String]

自分が参加できるギャザリングを探して参加する

一定時間 検索を行い、対象が見つからなかったときには マッチメイキングの状態を保持するトークン を返す。 次回 マッチメイキングの状態を保持するトークン をつけて再度リクエストを出すことで、前回の続きから検索処理を再開できる。 すべてのギャザリングを検索したが、参加できるギャザリングが存在しなかった場合はギャザリングもトークンもどちらも null が応答される。

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
player Player true 自身のプレイヤー情報
matchmakingContextToken string false 検索の再開に使用する マッチメイキングの状態を保持するトークン
パラメータ データ型 説明
item Gathering ギャザリング
matchmakingContextToken string マッチメイキングの状態を保持するトークン

doMatchmakingByPlayer

同期処理

from gs2_matchmaking_client.request import DoMatchmakingByPlayerRequest
from gs2_matchmaking_client.result import DoMatchmakingByPlayerResult

result = client.do_matchmaking_by_player(
    DoMatchmakingByPlayerRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.DoMatchmakingByPlayerRequest
import io.gs2.matchmaking.result.DoMatchmakingByPlayerResult

result = client.doMatchmakingByPlayer(
    DoMatchmakingByPlayerRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import DoMatchmakingByPlayerRequest
from gs2_matchmaking_client.result import DoMatchmakingByPlayerResult

def callback(async_result: AsyncResult[DoMatchmakingByPlayerResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.do_matchmaking_by_player_async(
    DoMatchmakingByPlayerRequest()\
    callback
)
import io.gs2.matchmaking.request.DoMatchmakingByPlayerRequest
import io.gs2.matchmaking.result.DoMatchmakingByPlayerResult

result = client.doMatchmakingByPlayer(
    DoMatchmakingByPlayerRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

Player が参加できるギャザリングを探して参加する

一定時間 検索を行い、対象が見つからなかったときには マッチメイキングの状態を保持するトークン を返す。 次回 マッチメイキングの状態を保持するトークン をつけて再度リクエストを出すことで、前回の続きから検索処理を再開できる。 すべてのギャザリングを検索したが、参加できるギャザリングが存在しなかった場合はギャザリングもトークンもどちらも null が応答される。

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
player Player true プレイヤー情報
matchmakingContextToken string false 検索の再開に使用する マッチメイキングの状態を保持するトークン
パラメータ データ型 説明
item Gathering ギャザリング
matchmaking_context_token string マッチメイキングの状態を保持するトークン

getGathering

同期処理

from gs2_matchmaking_client.request import GetGatheringRequest
from gs2_matchmaking_client.result import GetGatheringResult

result = client.get_gathering(
    GetGatheringRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name(gathering1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.GetGatheringRequest
import io.gs2.matchmaking.result.GetGatheringResult

result = client.getGathering(
    GetGatheringRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName(gathering1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import GetGatheringRequest
from gs2_matchmaking_client.result import GetGatheringResult

def callback(async_result: AsyncResult[GetGatheringResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_gathering_async(
    GetGatheringRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name(gathering1['name']),
    callback
)
import io.gs2.matchmaking.request.GetGatheringRequest
import io.gs2.matchmaking.result.GetGatheringResult

result = client.getGathering(
    GetGatheringRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName(gathering1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ギャザリングを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
gatheringName string true ギャザリング名
パラメータ データ型 説明
item Gathering ギャザリング

getNamespace

同期処理

from gs2_matchmaking_client.request import GetNamespaceRequest
from gs2_matchmaking_client.result import GetNamespaceResult

result = client.get_namespace(
    GetNamespaceRequest()\
        .with_namespace_name('matchmaking-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.GetNamespaceRequest
import io.gs2.matchmaking.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("matchmaking-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import GetNamespaceRequest
from gs2_matchmaking_client.result import GetNamespaceResult

def callback(async_result: AsyncResult[GetNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_async(
    GetNamespaceRequest()\
        .with_namespace_name('matchmaking-0001'),
    callback
)
import io.gs2.matchmaking.request.GetNamespaceRequest
import io.gs2.matchmaking.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("matchmaking-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace ネームスペース

getNamespaceStatus

同期処理

from gs2_matchmaking_client.request import GetNamespaceStatusRequest
from gs2_matchmaking_client.result import GetNamespaceStatusResult

result = client.get_namespace_status(
    GetNamespaceStatusRequest()\
        .with_namespace_name('matchmaking-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.GetNamespaceStatusRequest
import io.gs2.matchmaking.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("matchmaking-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import GetNamespaceStatusRequest
from gs2_matchmaking_client.result import GetNamespaceStatusResult

def callback(async_result: AsyncResult[GetNamespaceStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_status_async(
    GetNamespaceStatusRequest()\
        .with_namespace_name('matchmaking-0001'),
    callback
)
import io.gs2.matchmaking.request.GetNamespaceStatusRequest
import io.gs2.matchmaking.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("matchmaking-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースの状態を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
status string

updateGathering

同期処理

from gs2_matchmaking_client.request import UpdateGatheringRequest
from gs2_matchmaking_client.result import UpdateGatheringResult

result = client.update_gathering(
    UpdateGatheringRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name(gathering1['name'])\
        .with_attribute_ranges([
Object("AttributeRange", {"name": 'stage', "min": 1, "max": 1}),    
Object("AttributeRange", {"name": 'level', "min": 0, "max": 50})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.UpdateGatheringRequest
import io.gs2.matchmaking.result.UpdateGatheringResult

result = client.updateGathering(
    UpdateGatheringRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName(gathering1.get'Name())
        .withAttributeRanges(new [] {
Object("AttributeRange", {"name": "stage", "min": 1, "max": 1}),    
Object("AttributeRange", {"name": "level", "min": 0, "max": 50})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import UpdateGatheringRequest
from gs2_matchmaking_client.result import UpdateGatheringResult

def callback(async_result: AsyncResult[UpdateGatheringResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_gathering_async(
    UpdateGatheringRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_gathering_name(gathering1['name'])\
        .with_attribute_ranges([
Object("AttributeRange", {"name": 'stage', "min": 1, "max": 1}),    
Object("AttributeRange", {"name": 'level', "min": 0, "max": 50})
]),
    callback
)
import io.gs2.matchmaking.request.UpdateGatheringRequest
import io.gs2.matchmaking.result.UpdateGatheringResult

result = client.updateGathering(
    UpdateGatheringRequest()
        .withNamespaceName("matchmaking-0001")
        .withGatheringName(gathering1.get'Name())
        .withAttributeRanges(new [] {
Object("AttributeRange", {"name": "stage", "min": 1, "max": 1}),    
Object("AttributeRange", {"name": "level", "min": 0, "max": 50})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ギャザリングを更新する

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
gatheringName string true ギャザリング名
attributeRanges list[AttributeRange] false 募集条件
パラメータ データ型 説明
item Gathering ギャザリング

updateGatheringByUserId

同期処理

from gs2_matchmaking_client.request import UpdateGatheringByUserIdRequest
from gs2_matchmaking_client.result import UpdateGatheringByUserIdResult

result = client.update_gathering_by_user_id(
    UpdateGatheringByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.UpdateGatheringByUserIdRequest
import io.gs2.matchmaking.result.UpdateGatheringByUserIdResult

result = client.updateGatheringByUserId(
    UpdateGatheringByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import UpdateGatheringByUserIdRequest
from gs2_matchmaking_client.result import UpdateGatheringByUserIdResult

def callback(async_result: AsyncResult[UpdateGatheringByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_gathering_by_user_id_async(
    UpdateGatheringByUserIdRequest()\
    callback
)
import io.gs2.matchmaking.request.UpdateGatheringByUserIdRequest
import io.gs2.matchmaking.result.UpdateGatheringByUserIdResult

result = client.updateGatheringByUserId(
    UpdateGatheringByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ギャザリングを更新する

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
gatheringName string true ギャザリング名
userId string true ユーザーID
attributeRanges list[AttributeRange] false 募集条件
パラメータ データ型 説明
item Gathering ギャザリング

updateNamespace

同期処理

from gs2_matchmaking_client.request import UpdateNamespaceRequest
from gs2_matchmaking_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_description('description1')\
        .with_create_gathering_trigger_type('none')\
        .with_complete_matchmaking_trigger_type('none')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.matchmaking.request.UpdateNamespaceRequest
import io.gs2.matchmaking.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("matchmaking-0001")
        .withDescription("description1")
        .withCreateGatheringTriggerType("none")
        .withCompleteMatchmakingTriggerType("none")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_matchmaking_client.request import UpdateNamespaceRequest
from gs2_matchmaking_client.result import UpdateNamespaceResult

def callback(async_result: AsyncResult[UpdateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_namespace_async(
    UpdateNamespaceRequest()\
        .with_namespace_name('matchmaking-0001')\
        .with_description('description1')\
        .with_create_gathering_trigger_type('none')\
        .with_complete_matchmaking_trigger_type('none')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.matchmaking.request.UpdateNamespaceRequest
import io.gs2.matchmaking.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("matchmaking-0001")
        .withDescription("description1")
        .withCreateGatheringTriggerType("none")
        .withCompleteMatchmakingTriggerType("none")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false ネームスペースの説明
createGatheringTriggerType string true ギャザリング新規作成時のアクション
createGatheringTriggerRealtimeNamespaceId string true ギャザリング新規作成時 にルームを作成するネームスペース のGRN
createGatheringTriggerScriptId string true ギャザリング新規作成時 に実行されるスクリプト のGRN
completeMatchmakingTriggerType string true マッチメイキング完了時のアクション
completeMatchmakingTriggerRealtimeNamespaceId string true マッチメイキング完了時 にルームを作成するネームスペース のGRN
completeMatchmakingTriggerScriptId string true マッチメイキング完了時 に実行されるスクリプト のGRN
joinNotification NotificationSetting false ギャザリングに新規プレイヤーが参加したときのプッシュ通知
leaveNotification NotificationSetting false ギャザリングからプレイヤーが離脱したときのプッシュ通知
completeNotification NotificationSetting false マッチメイキングが完了したときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

CreateGatheringTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
gathering = args['gathering']  -- type: Gathering

result = {
}

ギャザリング新規作成時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
gathering Gathering ギャザリング
パラメータ データ型 説明

CompleteMatchmakingTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
gathering = args['gathering']  -- type: Gathering

result = {
}

マッチメイキング完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
gathering Gathering ギャザリング
パラメータ データ型 説明

マスターデータフォーマット

マスターデータはありません

GS2-Matchmaking の制限・制約

利用いただくにあたって注意いただく制限・制約はありません