Godot on Game Server Services | Docs

GS2の利用を開始

Mon, 01 Jan 0001 00:00:00 +0000

SDK

Game Engine

Game Server Services は主要なゲームエンジンから利用できるSDKを提供しています。
ゲームエンジン向け SDK では、ゲーム内から利用することにフォーカスして通常の SDK より高レベルなAPI形式で提供しています。

GS2 SDK for Unity

本 SDK は Apache License 2.0 で提供されています。
プログラムのどこかで Apache License 2.0 で提供されているライブラリを使用していることを明示する必要があります。

サンプルコード全文

Mon, 01 Jan 0001 00:00:00 +0000

using System.Collections;
using Gs2.Core.Model;
using Gs2.Unity.Core;
using Gs2.Unity.Gs2Account.Model;
using Gs2.Unity.Util;
using UnityEngine;

    public class Tutorial : MonoBehaviour
    {
        IEnumerator Start()
        {
            // Setup variables

            var clientId = "YourClientId";
            var clientSecret = "YourClientSecret";
            var accountNamespaceName = "game-0001";
            var accountEncryptionKeyId = "grn:gs2:{region}:{ownerId}:key:account-encryption-key-namespace:key:account-encryption-key";

            // Initialize GS2 SDK
            Gs2Domain gs2;
            {
                var future = Gs2Client.CreateFuture(
                    new BasicGs2Credential(
                        clientId,
                        clientSecret
                    ),
                    Region.ApNortheast1
                );
                yield return future;
                if (future.Error != null) {
                    throw future.Error;
                }
                gs2 = future.Result;
            }

            // define GS2-Account namespace
            var gs2Account = gs2.Account.Namespace(
                accountNamespaceName
            );

            // Create an anonymous account
            EzAccount account;
            {
                Debug.Log("Create an anonymous account");
                var future = gs2Account.CreateFuture();
                yield return future;
                if (future.Error != null) {
                    throw future.Error;
                }
                var future2 = future.Result.ModelFuture();
                yield return future2;
                if (future2.Error != null) {
                    throw future2.Error;
                }
                account = future2.Result;
            }

            // Dump anonymous account

            Debug.Log($"UserId: {account.UserId}");
            Debug.Log($"Password: {account.Password}");

            // Log-in created anonymous account
            GameSession gameSession;
            {
                var future = gs2.LoginFuture(
                    new Gs2AccountAuthenticator(
                        accountSetting: new AccountSetting {
                            accountNamespaceName = accountNamespaceName,
                            keyId = accountEncryptionKeyId,
                        }
                    ),
                    account.UserId,
                    account.Password
                );
                yield return future;
                if (future.Error != null) {
                    throw future.Error;
                }
                gameSession = future.Result;
            }

            // Load TakeOver settings
            {
                var it = gs2Account.Me(
                    gameSession
                ).TakeOvers();
                while (it.HasNext()) {
                    yield return it.Next();
                    if (it.Error != null)
                    {
                        throw it.Error;
                    }
                    if (it.Current != null)
                    {
                        Debug.Log($"Type: {it.Current.Type}");
                        Debug.Log($"Identifier: {it.Current.UserIdentifier}");
                    }
                }
            }

            // Finalize GS2-SDK
            {
                var future = gs2.DisconnectFuture();
                yield return future;
                if (future.Error != null) {
                    throw future.Error;
                }
            }
        }
    }

    // Gs2Tutorial.cpp

    #include "Sample/Gs2Tutorial.h"

    #include "Core/Gs2Domain.h"
    #include "Util/Authentication/Gs2AccountAuthenticator.h"

    DEFINE_LOG_CATEGORY(GameLog);

    class EZGS2_API FSampleTask final : public Gs2::Core::Util::TGs2Future<void*>
    {
    public:
        virtual ~FSampleTask() override = default;

        virtual Gs2::Core::Model::FGs2ErrorPtr Action(const TSharedPtr<TSharedPtr<void*>> Result) override
        {
            // Setup variables

            const auto ClientId = "YourClientId";
            const auto ClientSecret = "YourClientSecret";
            const auto AccountNamespaceName = "game-0001";
            const auto AccountEncryptionKeyId = "grn:gs2:{region}:{ownerId}:key:account-encryption-key-namespace:key:account-encryption-key";

            // Create GS2 client

            const auto InitializeFuture = Gs2::UE5::Core::FGs2Client::Create(
                MakeShared<Gs2::Core::Model::FBasicGs2Credential>(
                    ClientId,
                    ClientSecret
                ),
                Gs2::Core::Model::ApNorthEast1
            );
            InitializeFuture->StartSynchronousTask();
            if (InitializeFuture->GetTask().IsError())
            {
                UE_LOG(GameLog, Error, TEXT("%s"), ToCStr(InitializeFuture->GetTask().Error()->String()));
                return InitializeFuture->GetTask().Error();
            }
            const auto Gs2 = InitializeFuture->GetTask().Result();

            // Create an anonymous account

            UE_LOG(GameLog, Display, TEXT("Create anonymous account"));

            const auto CreateFuture = Gs2->Account->Namespace(
                AccountNamespaceName
            )->Create();
            CreateFuture->StartSynchronousTask();
            if (CreateFuture->GetTask().IsError())
            {
                UE_LOG(GameLog, Error, TEXT("%s"), ToCStr(CreateFuture->GetTask().Error()->String()));
                return CreateFuture->GetTask().Error();
            }

            // Load created account

            const auto LoadFuture = CreateFuture->GetTask().Result()->Model();
            LoadFuture->StartSynchronousTask();
            if (LoadFuture->GetTask().IsError())
            {
                UE_LOG(GameLog, Error, TEXT("%s"), ToCStr(LoadFuture->GetTask().Error()->String()));
                return LoadFuture->GetTask().Error();
            }
            const auto Account = LoadFuture->GetTask().Result();

            // Dump anonymous account

            UE_LOG(GameLog, Display, TEXT("UserId: %s"), ToCStr(*Account->GetUserId()));
            UE_LOG(GameLog, Display, TEXT("Password: %s"), ToCStr(*Account->GetPassword()));

            // Log-in created anonymous account

            const auto LoginFuture = Gs2->Login(
                MakeShareable<Gs2::UE5::Util::IAuthenticator>(
                    new Gs2::UE5::Util::FGs2AccountAuthenticator(
                        MakeShared<Gs2::UE5::Util::FAccountSetting>(
                            AccountNamespaceName,
                            AccountEncryptionKeyId
                        )
                    )
                ),
                *Account->GetUserId(),
                *Account->GetPassword()
            );
            LoginFuture->StartSynchronousTask();
            if (LoginFuture->GetTask().IsError())
            {
                UE_LOG(GameLog, Error, TEXT("%s"), ToCStr(LoginFuture->GetTask().Error()->String()));
                return LoginFuture->GetTask().Error();
            }
            const auto GameSession = LoginFuture->GetTask().Result();

            // Load TakeOver settings

            const auto It = Gs2->Account->Namespace(
                AccountNamespaceName
            )->Me(
                GameSession
            )->TakeOvers();
            for (const auto TakeOver : *It)
            {
                UE_LOG(GameLog, Display, TEXT("Type: %d"), *TakeOver->GetType());
                UE_LOG(GameLog, Display, TEXT("Identifier: %s"), ToCStr(*TakeOver->GetUserIdentifier()));
            }

            // Finalize GS2-SDK

            const auto FinalizeFuture = Gs2->Disconnect();
            FinalizeFuture->StartSynchronousTask();
            if (FinalizeFuture->GetTask().IsError())
            {
                UE_LOG(GameLog, Error, TEXT("%s"), ToCStr(FinalizeFuture->GetTask().Error()->String()));
                return FinalizeFuture->GetTask().Error();
            }

            return nullptr;
        }
    };

    AGs2Tutorial::AGs2Tutorial()
    {
        PrimaryActorTick.bCanEverTick = true;
    }

    void AGs2Tutorial::BeginPlay()
    {
        Super::BeginPlay();

        (new FAsyncTask<FSampleTask>())->StartBackgroundTask();
    }

    void AGs2Tutorial::Tick(float DeltaTime)
    {
        Super::Tick(DeltaTime);
    }

    // Gs2Tutorial.h

    #pragma once

    #include "CoreMinimal.h"
    #include "GameFramework/Actor.h"
    #include "Gs2Tutorial.generated.h"

    DECLARE_LOG_CATEGORY_EXTERN(GameLog, Log, All);

    UCLASS()
    class EZGS2_API AGs2Tutorial : public AActor
    {
        GENERATED_BODY()

    public:
        AGs2Tutorial();

    protected:
        virtual void BeginPlay() override;

    public:
        virtual void Tick(float DeltaTime) override;
    };

extends Node


func _ready() -> void:
    # Setup variables
    var client_id = "YourClientId"
    var client_secret = "YourClientSecret"
    var account_namespace_name = "game-0001"
    var account_encryption_key_id = "grn:gs2:{region}:{ownerId}:key:account-encryption-key-namespace:key:account-encryption-key"

    # Initialize GS2 SDK
    var credential = Gs2BasicCredential.new(client_id, client_secret)
    var connection = Gs2Connection.new(credential, Gs2Region.AP_NORTHEAST_1)
    var ez = Gs2EzDomain.new(connection)

    # Define the GS2-Account namespace
    var gs2_account = ez.account.namespace_(
        account_namespace_name
    )

    # Create an anonymous account
    var create_result = await gs2_account.create()
    if create_result.error != null:
        push_error(str(create_result.error))
        return

    # Load the created account
    var model_result = await create_result.result.model()
    if model_result.error != null:
        push_error(str(model_result.error))
        return
    var account = model_result.result

    # Dump the anonymous account
    print("UserId: ", account.user_id)
    print("Password: ", account.password)

    # Log in with the created anonymous account
    var authenticator = Gs2AccountAuthenticator.new(
        account_namespace_name,
        account_encryption_key_id
    )
    var game_session = Gs2GameSession.new(
        authenticator,
        connection,
        account.user_id,
        account.password
    )
    var login_result = await game_session.login()
    if login_result.error != null:
        push_error(str(login_result.error))
        return

    # Load TakeOver settings
    var load_result = await gs2_account.me(
        game_session
    ).take_overs().load()
    if load_result.error != null:
        push_error(str(load_result.error))
        return

    for take_over in load_result.result:
        print("Type: ", take_over.type)
        print("Identifier: ", take_over.user_identifier)

    # Finalize GS2 SDK
    connection.disconnect_session()

SDKのセットアップ

Mon, 01 Jan 0001 00:00:00 +0000

このセクションでは、Game Engine 向けの SDK、GS2 SDK for Unity、GS2 SDK for Unreal Engine 5、GS2 SDK for Godot のインストール手順について詳述しています。

GS2 SDK for Unityのインストール手順

GS2 SDK for Unity Installer Version 2024.4.1

上記のリンクよりUnityPackege形式のインストーラーをダウンロードします。

新規で Unity プロジェクトを作成するか、既存の Unity プロジェクトを準備し、Unity Editor で開きます。

メニューの『Assets > Import Package > Custum Packages…』から gs2-unity-installer_2024.4.1.unitypackage ファイルをインポートします。

Unity Editor のメニューから『Window > Game Server Services > SDK Installer』を選択します。

SDK インストーラーのウィンドウが表示されます。『Install』を選択します。

インストールが完了すると、プロジェクトの『Packeges』にSDKがインストールされ、Package Managerでインストールされていることが確認できます。

GS2 SDK for Unity は GS2-CSharp-SDK と GS2 SDK for Unity で構成されています、

実装

Mon, 01 Jan 0001 00:00:00 +0000

ここでは、GS2 SDK を使用してアカウントの作成とログインを行う最小限の実装方法を解説します。

各プラットフォームごとの完全なコードはサンプルコード全文をご確認ください。

Unity での実装について

Unity SDK では非同期処理に Coroutine を使用しています。以下のコード例は Coroutine 内（IEnumerator を返すメソッド内）で実行することを想定しています。

GS2 SDKの初期化

    // Setup variables

    var clientId = "YourClientId";
    var clientSecret = "YourClientSecret";
    var accountNamespaceName = "game-0001";
    var accountEncryptionKeyId = "grn:gs2:{region}:{ownerId}:key:account-encryption-key-namespace:key:account-encryption-key";

    // Setup general setting
    Gs2Domain gs2;
    {
        var future = Gs2Client.CreateFuture(
            new BasicGs2Credential(
                clientId,
                clientSecret
            ),
            Region.ApNortheast1
        );
        yield return future;
        if (future.Error != null) {
            throw future.Error;
        }
        gs2 = future.Result;
    }

	// Setup variables

	const auto ClientId = "YourClientId";
	const auto ClientSecret = "YourClientSecret";
	const auto AccountNamespaceName = "game-0001";
    const auto AccountEncryptionKeyId = "grn:gs2:{region}:{ownerId}:key:account-encryption-key-namespace:key:account-encryption-key";

    // Create GS2 client

    const auto InitializeFuture = Gs2::UE5::Core::FGs2Client::Create(
        MakeShared<Gs2::Core::Model::FBasicGs2Credential>(
            ClientId,
            ClientSecret
        ),
        Gs2::Core::Model::ApNorthEast1
    );
    InitializeFuture->StartSynchronousTask();
    if (InitializeFuture->GetTask().IsError())
    {
        UE_LOG(GameLog, Error, TEXT("%s"), ToCStr(InitializeFuture->GetTask().Error()->String()));
        return InitializeFuture->GetTask().Error();
    }
    const auto Gs2 = InitializeFuture->GetTask().Result();

    # Setup variables

    var client_id = "YourClientId"
    var client_secret = "YourClientSecret"
    var account_namespace_name = "game-0001"
    var account_encryption_key_id = "grn:gs2:{region}:{ownerId}:key:account-encryption-key-namespace:key:account-encryption-key"

    # Initialize GS2 SDK

    var credential = Gs2BasicCredential.new(client_id, client_secret)
    var connection = Gs2Connection.new(credential, Gs2Region.AP_NORTHEAST_1)
    var ez = Gs2EzDomain.new(connection)

Setup variables

まずは4つの変数を定義しています。