This document is about: QUANTUM 1

SWITCH TO

QUANTUM 1 QUANTUM 2 QUANTUM 3

Unityプラグイン

開始方法

Unityプラグインをインストールする

Unityパッケージをダウンロードしてインストールします（SDKへのアクセス権が与えられると、ダウンロードリンクが表示されます）。
Assets/Import package/Custom Packageで通常どおりにパッケージをインポートします。

これには、ゲームクライアント内でトーナメントを実行するために必要なdllが含まれます。

新しいゲームを作成してgameIdをセットアップする

すべてのファイルをゲーム/プロジェクトにインポートしたら、ゲームIDを作成する必要があります。
これを行うには、トーナメントダッシュボードにログインし、add new gameボタンをクリックし、新しいゲームを作成するまでウィザードの手順に従います。

次にGame settings/Generalを開き、自分のゲームIDを見つけます。

次に、Unityプロジェクトで、以下の名前のインポート済みファイルを見つけます。
Plugins/Gimmebreak.Backbone/Resources/フォルダーにある BackboneClientSetting.asset。
以下に示すように、ファイルを開き、自分の ゲームIDにコピーします。

SDKクライアントを初期化する

BackboneManagerスクリプトをシーンオブジェクトに追加します。
Unityの Start() が呼び出されたときにクライアントを初期化する場合は、Initialize on startと書かれたボックスにチェックマークを付けます。

クライアントを手動で初期化する場合（例：インターネット接続を確認した後）には、後から明示的な呼び出しでおこなうことができます。

public class MyMonoBehaviour : MonoBehaviour
{
    //例1、コールバックを使用
    public void ExplicitInitializeCall()
    {
        //バックボーン（TournamentSDK）クライアントの初期化
        BackboneManager.Initialize()
            .ResultCallback((result) => {
                if(result)
                {
                    //成功
                }
                else
                {
                    //失敗
                }
            })
            .Run(this);
    }

    //例2、Unityコルーチンを使用
    public IEnumerator ExplicitInitializeCallCoroutine()
    {
        //他のコード初期化
        //...
        //インターネット接続を待っています
        //...
        //バックボーン（TournamentSDK）クライアントの初期化
        AsyncOperation<bool> asyncOperation = BackboneManager.Initialize();
        //初期化が完了するまで待つ
        yield return asyncOperation;
        //結果を確認
        if(asyncOperation.ReturnValue)
        {
            //成功
        }
        else
        {
            //失敗
        }
    }
}

BackboneManager.IsInitializedを使用して、クライアントが初期化されているかどうかを確認できます。

ログインユーザー

ダッシュボードでログインプロバイダーを有効にする

トーナメントダッシュボードを開き、Game Settings/Authentication providersに移動します。
ゲームに関連するプロバイダーを有効にします。
有効な各プロバイダーに必要な設定を入力して保存します。

ログインユーザー

ログインプロバイダーがセットアップされている場合は、ユーザーのログインに進むことができます
クライアントの初期化後、ユーザーがログインしているかどうかを確認できます。
そうでない場合は、ログイン操作を続行できます。

この例では、Steam認証を使用しています。

private IEnumerator Start()
{
    //バックボーンクライアントが初期化されるまで待ちます
    while (!BackboneManager.IsInitialized)
    {
        yield return null;
    }
    //ユーザーがログインしているかどうかを確認します
    if (!BackboneManager.IsUserLoggedIn)
    {
        //Steamユーザー名、認証セッションチケット、優先SteamからのSteamIDを取得します
        //apiライブラリ
        //...
        //Steam認証プロバイダーを使用してユーザーにログインします
        var steamLogin = LoginProvider.Steam(true, userName, steamAuthCode, steamUserId);
        yield return BackboneManager.Client.Login(steamLogin);
    }
}

これにより、Steamログインプロバイダーを使用してユーザーがログインします。
ユーザーが正常にログインした後、クライアントAPIとインタラクトできます。

基本的なトーナメント操作

トーナメントのリストを取得する

すべてのトーナメントのリストが以下の場所に格納されています：

var allTournaments = BackboneManager.Client.Tournaments.TournamentList;

リストを読み込むまたは更新するには（ログイン後に空にすることができます）、 BackboneManager.Client.LoadTournamentList()操作を呼び出す必要があります。

 //トーナメントリストの読み込み/更新
 BackboneManager.Client.LoadTournamentList()
     //終了コールバックを設定
     .FinishCallback(() =>
     {
         //操作の終了後にデータをバインド
         BindData();
     })
     //このMonoBehaviourで非同期操作を実行
     .Run(this);

注：この操作は、リストが正常に更新されたかどうかを示すbool結果を返します。
この操作が頻繁に呼び出されると、falseを返します。
現在の「許可された更新制限」は1分に設定されています。
登録することで操作結果を取得できます。

ResultCallback((result) => {}) は以下のようになります：

 //トーナメントリストの読み込み/更新
 BackboneManager.Client.LoadTournamentList()
     //終了コールバックを設定します
     .FinishCallback(() =>
     {
         //操作の終了後にデータをバインド
         BindData();
     })
     .ResultCallback((result) => {
         if(result)
         {
             //更新/読み込みに成功
         }
         else
         {
             //更新/読み込みません
         }
     })
     //このMonoBehaviourで非同期操作を実行
     .Run(this);

トーナメントリストが読み込まれた後、トーナメントクラスのすべてのプロパティが設定されるわけではありません。
すべてのトーナメントデータを読み込むには、 BackboneManager.Client.LoadTournament(tournamentId)を呼び出す必要があります。
トーナメントクラスにはフラグが含まれています：すべてのデータ読み込まれたかどうかを確認できるHasAllDataLoaded。

トーナメントを取得する

すべてのトーナメントデータを読み込む/更新するには、 BackboneManager.Client.LoadTournament（tournament）を呼び出します。
この操作は、トーナメントが正常に読み込まれた/リフレッシュされたかどうかを示すboolを返します。
また、トーナメントクラスには、tournament.HasAllDataLoadedというプロパティがあり、すべてのデータが既に読み込まれているかどうかを示します。

//リストの最初のトーナメントを取得
var tournament = BackboneManager.Client.Tournaments.TournamentList[0];
//すべてのトーナメントデータを読み込む/更新
BackboneManager.Client.LoadTournament(tournament)
    //終了コールバックを設定
    .FinishCallback(() =>
    {
        if(tournament.HasAllDataLoaded)
        {
            //すべてのデータが読み込み/リフレッシュされました
        }
    })
    //このMonoBehaviourで非同期操作を実行
    .Run(this);

トーナメントにサインアップする

ユーザーが既にサインアップしているかどうかを確認するには、トーナメントプロパティ： tournament.Inviteを確認してください。
招待がnullの場合、ユーザーには招待がなく、確認もされていません。
招待が利用可能かどうかを確認するには、ユーザーのトーナメントの招待ステータスを保持するtournament.Invite.Statusを確認します。

//トーナメントを取得する
var tournament = BackboneManager.Client.Tournaments.GetTournamentById(tournamentId);
//ユーザーがサインアップしているかどうかを確認
if (tournament.Invite == null ||
    tournament.Invite.Status != TournamentUserStatus.Confirmed)
{
    //ユーザーはトーナメントにサインアップしていません
}

トーナメントにサインアップするには以下を呼びます: SignupForTournament(tournamentId)。

//トーナメントにユーザーをサインアップ
BackboneManager.Client.SignupForTournament(tournamentId)
    //結果コールバックを設定
    .ResultCallback((result) =>
    {
        //サインアップ結果を確認
        if (result.ProcessStatus != TournamentSignUpStatus.Ok)
        {
            LobbyAlertDialog.Show("Sign up process failed with status: " + result.ProcessStatus.ToString());
        }
    })
    //このMonoBehaviourで非同期操作を実行
    .Run(this);

この操作は、サインアップ結果に関する情報を含むInviteResultオブジェクトを返します。
サインアッププロセスの外部サーバーがダッシュボードで設定されている場合（例：通貨、アイテムなどを差し引くため）、inviteResult.IsExternalSignupErrorはこの操作中に問題があったかどうかを示します。
また、カスタムサーバーによってスローされたエラーメッセージはすべて、 inviteResult.ErrorMessageで参照できます。

トーナメントハブ

トーナメントハブの初期化

トーナメントハブは、トーナメントのカスタムロビーとして機能します。
接続すると、マッチに関する情報とトーナメントの進行状況/ステータスが提供されます。
トーナメントハブコールバックを受信するには、 ITournamentHubCallbackHandlerインターフェースを実装します。

public void OnInitialized(ITournamentHubController controller)
{
    //トーナメントハブは初期化され、コントローラーを提供する
}

public void OnHubStatusChanged(TournamentHubStatus newStatus)
{
    //トーナメントハブのステータスが変更されました
}

public void OnTournamentUpdate()
{
    //トーナメントデータが更新されました
}

public void OnHubMatchStatusChanged(TournamentHubMatchStatus newStatus)
{
    //参加したトーナメントのマッチステータスが変更されました
}

public void OnHubMatchUpdate()
{
    //参加したトーナメントのマッチデータが更新されました
}

Tournament Hubを初期化するには： ConnectTournamentHub(callbackHandler, tournament);を呼び出します。コールバックハンドラーはITournamentHubCallbackHandlerを実装するオブジェクトです。

var tournament = BackboneManager.Client.Tournaments.GetTournamentById(tournamentId);
BackboneManager.Client.ConnectTournamentHub(this, tournament);

トーナメントハブが初期化されると、OnInitialized(ITournamentHubController controller)を呼び出し、ユーザーの観点から特定のトーナメントフローを制御するために使用されるコントローラーを返します（例：ユーザーが次のマッチの準備ができていることを示す）。

トーナメントハブのステータス

OnHubStatusChanged（TournamentHubStatus newStatus）は、ユーザーの観点からトーナメントの現在のステータスを示します。 UIは、それに応じて変更に対応する必要があります。

public void OnHubStatusChanged(TournamentHubStatus newStatus)
{
    switch (newStatus)
    {
        case TournamentHubStatus.RegistrationClosed:
            //登録は閉じられており、まだ開かれていません。
            //トーナメントプロパティ「RegistrationOpenTime」のオープンタイムを確認できます。
            break;
        case TournamentHubStatus.RegistrationOpening:
            //「RegistrationOpenTime」に達したため、登録が開始されますが、
            //サーバーからの確認を待っています。
            break;
        case TournamentHubStatus.RegistrationOpened:
            //登録が開かれ、ユーザーはトーナメントにサインアップできます。
            break;
        case TournamentHubStatus.RegistrationClosing:
            //'InvitationCloseTime' に達したため、登録/招待は終了しますが
            //サーバーからの確認を待っています。
            break;
        case TournamentHubStatus.WaitingForTournamentStart:
            //登録は終了し、トーナメントの開始確認を
            //サーバーが待機しています。
            break;
        case TournamentHubStatus.Starting:
            //トーナメント'Time'に到達したためトーナメントが開始されますが、
            //サーバーからの確認を待っています。
            break;
        case TournamentHubStatus.Started:
            //トーナメントが開始されました。ユーザーの順位を含む'tournament.GetCurrentTournamentPhase（）'から
            //現在のフェーズを取得。
            break;
        case TournamentHubStatus.MatchInProgress:
            //ユーザーは自分が参加すべきマッチを進行中です。
            //'tournament.UserActiveMatch'からすべての一致メタデータを取得。
            break;
        case TournamentHubStatus.ResolvingPartiallyFilledMatch:
            //ユーザーの有効なマッチが時間内に満たされなかった。マッチがプレイされるべきか
            //サーバーからの確認待ち。
            break;
        case TournamentHubStatus.ClosingOverdueMatch:
            //ユーザーの有効なマッチの締切に達し、閉鎖の期限が来ました。
            //サーバーからの確認を待っています。
            break;
        case TournamentHubStatus.WaitingForUserReadyConfirmation:
            //ユーザーはトーナメントの次のラウンドに進むことができます。
            //'tournamentHubController.SetUserReady()'を呼び出すことによる明示的な確認がリクエストされています。
            break;
        case TournamentHubStatus.WaitingForNextPhase:
            //トーナメントの現在のフェーズが終了します。次のフェーズの開始を
            //待っています。
            break;
        case TournamentHubStatus.WaitingForTournamentToFinish:
            //ユーザーは現在の段階ですべてのラウンドを終了したか、すでにトーナメントから
            //ノックアウトされており、トーナメントが終了するのを待っています。
            break;
        case TournamentHubStatus.Finishing:
            //最終フェーズの最終ラウンドが期限に達し、すべてのマッチが
            //終了します。サーバーからの確認を待っています。
            break;
        case TournamentHubStatus.Finished:
            //トーナメントが終了しました。'tournament.Winner.Users'を確認して誰が勝ったかを
            //見ることが出来ます。
            break;
    }
}

ユーザーの有効なマッチ

トーナメントの実行中にユーザーがサインアップすると、すべてのメタデータとステータスを含む有効なマッチが自動的に与えられます。
ユーザーの有効なマッチには、トーナメントハブの次からアクセスできます： tournamentHub.Tournament.UserActiveMatch。

UserActiveMatch.Secretは、ネットワークルーム/ロビーのパスワードまたは名前として使用できます。
これは、特定のマッチへの参加が許可されているユーザーにのみ配布されます。

UserActiveMatch.Statusを使用して、ユーザーが他のユーザー/対戦相手を待っているか、ゲームの進行中に特定のルーム/ロビーに接続する必要があるか、ユーザーが別の試合に進む必要があるかを判断します。

switch (tournamentHubController.Tournament.UserActiveMatch.Status)
{
    case TournamentMatchStatus.Created:
        //マッチが正常に作成されました。
        break;
    case TournamentMatchStatus.WaitingForOpponent:
        //マッチは満たされず、対戦相手はまだ参加するのを待っています。
        break;
    case TournamentMatchStatus.GameReady:
        //マッチゲームをプレイする準備ができました。ゲームセッションの作成に進みます
        //ステータスを'GameInProgress'に変更します。
        //注意: ユーザーがチェックイン中でルーム・ロビーに接続中の可能性があります。
       //クライアントは全パーティが無事に接続し準備が整うまで待つようにしてください。
       //その後、ゲームセッションの作成に進みます。
        break;
    case TournamentMatchStatus.GameInProgress:
        //マッチゲームが進行中で、ゲームセッションが作成され、進行中です。
        //NB：ユーザーは進行中のゲームセッションに再接続可能であるべきです。
        break;
    case TournamentMatchStatus.GameFinished:
        //結果が報告されたので、試合は終了しました。 試合でシリーズごとにさらに多くのゲームを
        //プレイする必要がある場合（例：3つのうち最高のもの）、再び'GameInProgress' に
        //ステータスを変更する別のゲームセッションを作成します。
        break;
    case TournamentMatchStatus.MatchFinished:
        //すべてのゲームがプレイされた（または締め切りに達した）ため、マッチは終了しました。
        //間もなく終了します。ユーザーは別のマッチに進むことができます。
        break;
    case TournamentMatchStatus.Closed:
        //マッチが確定され、サーバーによって閉じられました。
    break;
}

UserActiveMatch.Users[i].IsCheckedInを確認することで、対戦相手の準備ができているかどうかを判断できます。
次を呼び出すことで、UserActiveMatchデータをリフレッシュできます：tournamentHubController.RefreshActiveMatch()。
ユーザーがロビー/ルームに参加するたびにこれを呼び出すことをお勧めします。

UserActiveMatchはnullまたは終了済みステータスの可能性があることに留意してください。他のマッチをリクエスト してトーナメントに進むには、ユーザーは明示的にtournamentHubController.SetUserReady()を呼び出す必要があります。
ユーザーは、トーナメントハブがTournamentHubStatus.WaitingForUserReadyConfirmationステートに入ったらこれを行うようにしてください。このアクションはUI（例：次のマッチへ準備）で示したり、ユーザーインタラクションで先導することなくトーナメントハブがそのステートに入ったら即時で次のマッチへ 自動実行　させたりすることができます。

マッチ参加インターフェース

ゲームにプライベートゲーム/ロビー作成のメソッドが定義されている場合、マッチインターフェースを実装すると、ユーザーの参加とトーナメントマッチの開始を管理しやすくなります。
ロビースクリプトにITournamentMatchCallbackHandlerインターフェイスを実装するか、これを実装する新しいスクリプトを作成します。ロビーの状態をトーナメントハブに伝えるための簡単なメソッドのセットが提供されます。

public void OnJoinTournamentMatch(Tournament tournament, TournamentMatch match, ITournamentMatchController controller)
{
    //Callback from tournament hub passing tournament, match and controller object.
    //Use match data to join correct lobby/room.
    //User controller to inform tournament hub about changes in your lobby/room.
}

public bool IsConnectedToGameServerNetwork()
{
    //クライアントがネットワークバックエンドに正常に接続されているかどうかを確認します。
    //ユーザーが接続され、ロビー・ルームに参加する準備ができている場合はtrueを返します。
}

public bool IsUserConnectedToMatch(long userId)
{
    //特定のユーザーが既にロビー/ルームに接続しているかどうかを確認します。

    //ユーザーが接続されている場合はtrueを返します。
}

public bool IsUserReadyForMatch(long userId)
{
    //特定のユーザーの準備ができているかどうかを確認します（例：正しいスロットに移動された）
    //ユーザーが開始する準備ができたらtrueを返します。
    //注意: まだチェックインしていないローカルユーザーがチェックインできるのはtrueを
   //返した後のみです。
}

public bool IsGameSessionInProgress()
{
    //特定のトーナメントのマッチでゲームセッションが既に進行中かどうかを確認します。
    //ゲームセッションが進行中の場合はtrueを返します。
}

public void OnLeaveTournamentMatch()
{
    //トーナメントハブからのコールバックは、ユーザーに参加したロビー/ルームから退出するよう通知します。
}

public void StartGameSession(IEnumerable<TournamentMatch.User> checkedInUsers)
{
    //ゲームセッションがすぐに開始することをリクエストするトーナメントハブからのコールバック。また、//現在のマッチのために正常にチェックインしたユーザーを渡します。
    //トーナメントゲームセッションを作成し、ゲームを開始します。
    //IsGameSessionInProgressがtrueを返すまで、これは複数回呼び出される場合があります。
}

このインターフェイスを実装するオブジェクトは、特定のマッチに参加するときにトーナメントハブコントローラーメソッドに渡すことができます： tournamentHubController.JoinTournamentMatch()。

コードフローの例：

//トーナメントハブの初期化
BackboneManager.Client.ConnectTournamentHub(hubCallbackHandler, tournament);
//...
//ハブコントローラを取得します
public void OnInitialized(ITournamentHubController controller)
{
    hubController = controller
}
//...
//トーナメントハブが"MatchInProgress"ステータスであることを確認します
public void OnHubStatusChanged(TournamentHubStatus newStatus)
{
    switch (newStatus)
    {
        case TournamentHubStatus.MatchInProgress:
        case TournamentHubStatus.ResolvingPartiallyFilledMatch:
            //...
            //ユーザーの有効なマッチに参加
            var match = hubController.Tournament.UserActiveMatch;
            hubController.JoinTournamentMatch(match, matchCallbackHandler);
            //...
            break;
    }
}

注: OnJoinTournamentMatchにパスされたtournamentMatchControllerでレポートメソッド を使用することも重要です。
接続済みのとび―・ルームで特定のイベントが発生したらコントローラメソッドを呼び出します。
トーナメントハブはこれらを使用してメタデータを更新するタイミングを決定しています。
これを怠ると、不一致となりマッチできるクライアントとそうでないクライアントが出てきてしまいます。（例：他のクライアントにはユーザーがチェックインをしていないように見えます）

レポートをtournamentMatchControllerに変更するPhotonのルームコールバックの使用例

//Photon callback when new player joined room
public void OnPlayerEnteredRoom(Player newPlayer)
{
    long userId;
    //extract user id from player custom properties
    if (this.tournamentMatchController != null &&
        TryGetPlayerBackboneUserId(newPlayer, out userId))
    {
        //report user who joined room
        this.tournamentMatchController.ReportJoinedUser(userId);
    }
}
//Photon callback when player disconnected from room
public void OnPlayerLeftRoom(Player otherPlayer)
{
    long userId;
    //extract user id from player custom properties
    if (this.tournamentMatchController != null &&
        TryGetPlayerBackboneUserId(otherPlayer, out userId))
    {
        //report user who disconnected from room
        this.tournamentMatchController.ReportDisconnectedUser(userId);
    }
}
//Photon callback when room properties are updated
public void OnRoomPropertiesUpdate(Hashtable propertiesThatChanged)
{
    if (this.tournamentMatchController != null)
    {
        //reporting status change will refresh match metadata
        this.tournamentMatchController.ReportStatusChange();
    }
}
//Photon callback when player properties are updated
public void OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
{
    if (this.tournamentMatchController != null)
    {
        //reporting status change will refresh match metadata
        this.tournamentMatchController.ReportStatusChange();
    }
}

トーナメントゲームセッションと結果提出

トーナメント設定に基づいて、マッチには複数のゲームセッションを含めることができます。
たとえば、1対1のマッチが「ベストオブ3」シリーズとして設定されている場合、少なくとも2つのゲームセッションをプレイする必要があります。
「ゲームセッション」は、試合シリーズのうちの1つのゲームを表します。

ゲームセッションを作成

ゲームセッションを作成するには、 CreateGameSession(users, userActiveMatchId, sessionType)を呼び出します。
返されたゲームセッションIDは、他のクライアントに配布できます。
後続されて別の呼び出しが行われた場合、同じゲームセッションIDが返されます。

//チェックインしたユーザーのみにゲームセッションを作成します
var checkedInUsers = userActiveMatch.Users.Where(user => user.IsCheckedIn);
//特定のゲームモードを識別するためにゲームセッションタイプを使用できます
//例： 0-default, 1-4player mode, 2-8player mode
var sessionType = 0;
//ゲームセッションを作成
BackboneManager.Client.CreateGameSession(checkedInUsers, userActiveMatch.Id, sessionType)
    //結果コールバックを設定
    .ResultCallback((gameSession) =>
    {
        //ゲームセッションIDを取得し、他のクライアントに配布します
        //NB：これは開発者次第です。例：カスタムルーム/ロビープロパティを使用する
        //またはメッセージをブロードキャストする
        var gameSessionId = gameSession.Id;
    })
    //このMonoBehaviourで非同期操作を実行
    .Run(this);

結果を送信

ゲームセッションが終了したら、マッチの締め切りに達する前に結果を報告する必要があります。
マッチが複数のゲームセッション（例：3シリーズのうちのベスト）を持つように設定されている場合、 GetMatchNextGameDeadline(match)を使用して現在のゲームセッションの理想的な期限を決定し、後続のゲームセッションをプレイする時間があるかを判断します。

//ユーザーの有効なマッチを取得
var userActiveMatch = tournament.UserActiveMatch;
//次のゲームセッションの適切な期限を取得
var deadline = tournament.GetMatchNextGameDeadline(userActiveMatch);

ゲームセッションの結果を送信するには、 SubmitGameSession（gameSession）呼び出しを使用します。
ゲームセッションオブジェクトは、 CreateGameSession呼び出しから返された分散ゲームセッションIDを使用して、すべてのクライアントで作成する必要があります。
特定のゲームセッションのポイント分布を決定するユーザーの場所を設定することが重要です。

//チェックインしたユーザーのみにゲームセッションを作成
var matchUsers = userActiveMatch.Users.Where(user => user.IsCheckedIn).ToList();
//ゲームセッションの結果に基づいてユーザーを並べ替えます。例：死亡など
matchUsers.Sort((user1, user2) =>{
    //特定のゲームルールに基づいてユーザーを最高から最低まで並べ替えます
});
//ゲームセッションユーザーのリストを作成
List<GameSession.User> gameSessionUsers = new List<GameSession.User>();
//ソートされたユーザーを最高から最低までループします
for(var i = 0; i < matchUsers.Count; i++)
{
    var userId = matchUsers[i].UserId;
    var teamId = matchUsers[i].TeamId;
    //ゲームセッションの最終場所を設定してゲームセッションユーザーを追加します（より多くのユーザーが
    //必要に応じて同じ配置にすることができます）
    gameSessionUsers.Add(new GameSession.User(userId, teamId) { Place = (i + 1) });
}
//ユーザーの有効なマッチIDを取得
var matchId = userActiveMatch.Id;
//'CreateGameSession'呼び出しから取得したIDを使用してゲームセッションを作成します
//また、トーナメントのマッチIDを渡す
GameSession gameSession = new GameSession(gameSessionId, 0, gameSessionUsers, matchId);
//プレイ日とゲームセッション期間を設定します
gameSession.PlayDate = DateTime.UtcNow;
gameSession.PlayTime = gameTime;
//ゲームセッションをサーバーに送信
BackboneManager.Client.SubmitGameSession(gameSession)
    .ResultCallback((result) => {
        if (result)
        {
            //ゲームセッションが正常に送信されました
        }
    })
    .Run(this);

カスタムアセットサーバーの統合

カスタムアセットサーバーからアイテム/通貨を読み込み、トーナメントの報酬または参加料として使用することができます。
また、すべてのサインアップは、それらのアイテムを差し引くかトーナメントサインアップを拒否できるカスタムサーバーを介してルーティングできます（例：ユーザーに十分な通貨がない場合）。

サーバーからストアアイテムを読み込む

カスタムサーバーからアイテムと通貨を読み込むには、特定のJSON形式でアイテムを返すHTTPエンドポイントを作成する必要があります。
これは、サーバーが内部使用のためにアイテムを読み込み、それらのアイテム/通貨を外部リソースから「読み込み済み」としてマークするようにするために行う必要があります。

JSON形式：

JSON

{
   items:[
       {
           id:"itemId1",
           name:"itemName1",
           image:"imageUrl (optional)"
       },
       {
           id:"itemId2",
           name:"itemName2",
           image:"imageUrl (optional)"
       }],
       currencies:[
       {
           id:"currencyId1",
           name:"currencyName1"
       },
       {
           id:"currencyId2",
           name:"currencyName2"
       }]
}

エンドポイントは、ステータスコード200でレスポンスする必要もあります。
インポートしたいすべてのアイテムを常に返します。
既に終了しているアイテム/通貨は更新されます。

必要な形式を返すエンドポイントが見つかったら、Game Settings/Store Integration に移動し、"external store hookup"を有効にします。
有効なHTTPパスを挿入し、サーバーが求める認証に必要なヘッダー/パラメーターを追加します。

Sync data nowボタンをクリックして、アイテム/通貨をインポートします。
これで、トーナメントテンプレートの報酬と参加費を編集しているときに、インポートしたアイテムにアクセスできるようになります。

アセットに更新がある場合は、Sync data now ボタンをクリックしてアセットを再度インポートします。

カスタムサーバー経由でサインアップ

トーナメントサインアップをカスタムサーバー経由でルーティングするには、特定のJSON形式を受け入れるHTTPエンドポイントを作成する必要があります。
ユーザーがサインアップするたびに、トーナメント、ユーザー、エントリー費などに関する情報を含むペイロードを使用して、カスタムサーバーへの呼び出しが行われます。

HTTP呼び出しは、JSONペイロードを含むuserTicketというパラメーターを持つPOSTです。

JSON形式：

JSON

{
   isSignup:true,
   isSignout:false,
   userId:"64bit number as string",
   userExternalId:"string",
   ticketId:"64bit number as string",
   tournamentId:"64bit number as string",
   customRequirements:[{
    name:"string",
    value:"string"
   }],
   fees:{
    items:[{
       id:"64bit number as string",
       externalId:"string",
       amount:1
    }],
    currencies:[{
       id:"64bit number as string",
       externalId:"string",
       amount:1
    }]
   }
}

次に、HTTPステータスコード200（または拒否の場合は別のコード）で成功したレスポンスが待機されます。

必要なJSON形式を受け入れるエンドポイントがある場合は、Game Settings/Tournament settings Integrationに移動し、"external signup"を有効にします。
有効なHTTPパスを挿入し、サーバーに必要な認証に必要なヘッダー/パラメーターを追加します。

このセットアップ後、クライアントからのサインアップは、受け入れられて確認される前にカスタムサーバーを経由する必要があります。

カスタムサーバーへのトーナメント結果報告

カスタムサーバーを介してトーナメント結果を受信するには、特定のJSON形式を受け入れるHTTPエンドポイントを作成する必要があります。
すべてのトーナメントが終了すると、トーナメント、ユーザー、賞品などに関する情報を含むペイロードを使用して、カスタムサーバーへの呼び出しが行われます。

HTTP呼び出しは、JSONペイロードを含むjsonPayloadというパラメーターを持つPOSTです。

JSON形式：

JSON

{
   "tournamentId":"64bit number as string",
   "prizes":[{
       "ticketId":"64bit number as string",
       "userId":"64bit number as string",
       "userExternalId":"string",
       "place":1,
       "items":[{
           "id":"64bit number as string",
           "amount":1,
           "externalId":"string"}],
       "currencies":[{
           "id":"64bit number as string",
           "amount":1,
           "externalId":"string"}]
    }]
}

その後、HTTPステータスコード200で正常なレスポンスが待機されます。
失敗した場合、数回繰り返されます。

必要なJSON形式を受け入れるエンドポイントが見つかったら、Game Settings/Tournament settings Integrationに移動し、"external prize delivery"を有効にします。
有効なHTTPパスを挿入し、サーバーに必要な認証に必要なヘッダー/パラメーターを追加します。

開始方法

Unityプラグインをインストールする
新しいゲームを作成してgameIdをセットアップする
SDKクライアントを初期化する

ログインユーザー

ダッシュボードでログインプロバイダーを有効にする
ログインユーザー

基本的なトーナメント操作

トーナメントのリストを取得する
トーナメントを取得する
トーナメントにサインアップする

トーナメントハブ

トーナメントハブの初期化
トーナメントハブのステータス
ユーザーの有効なマッチ
マッチ参加インターフェース

トーナメントゲームセッションと結果提出

ゲームセッションを作成
結果を送信

カスタムアセットサーバーの統合

サーバーからストアアイテムを読み込む
カスタムサーバー経由でサインアップ
カスタムサーバーへのトーナメント結果報告