> For the complete documentation index, see [llms.txt](/llms.txt)


# Login examples for Unreal Engine and Godot

Sample code from account creation to login



These minimal Unreal Engine 5 and Godot examples are for use after installing the SDK. Create an Account namespace named `adventure-account` in GS2, and set `ApplicationClientId` / `ApplicationClientSecret` from your project's `Default` stack. Use the `default` key in the `default` namespace for authentication.

Replace `{region}` and `{ownerId}` below with your region (for example, `ap-northeast-1`) and owner ID. These examples create an account and log in once. To resume as the same player, save the created ID and password; when saved credentials exist, skip creation and use them to log in. Do not display or log the password.

For Unity code that includes saving credentials and logging in again, see [chapter 1 of the adventure tutorial]().




**Unreal Engine 5**
```cpp

    // 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 = "adventure-account";
            const auto AccountEncryptionKeyId = "grn:gs2:{region}:{ownerId}:key:default:key:default";

            // 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()));

            // 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;
    };
```
**Godot**
```gdscript

extends Node


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

    # 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)

    # 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()
```