LootLocker

https://docs.lootlocker.com
Admin
LootLocker is a backend-as-a-service platform for game developers that provides player management,...
Tokens:180,616
Snippets:1,316
Trust Score:9.1
Update:8 months ago
Show doc for...
Tokens:
Raw
### Start Google Session

Source: https://docs.lootlocker.com/players/authentication/how-to/sign-in-with-google

This section provides code examples for starting a LootLocker session using Google Sign-In across different platforms.

```APIDOC
## POST /game/session/google

### Description
Initiates a LootLocker game session using a Google Identity Token. This allows players to sign in to your game using their Google accounts.

### Method
POST

### Endpoint
https://api.lootlocker.io/game/session/google

### Parameters
#### Query Parameters
None

#### Request Body
- **game_key** (string) - Required - Your LootLocker game key.
- **id_token** (string) - Required - The Google Identity Token obtained from the Google platform.
- **game_version** (string) - Optional - The version of your game.

### Request Example
```bash
curl -X POST "https://api.lootlocker.io/game/session/google" \
  -H "LL-Version: 2021-03-01" \
  -H "Content-Type: application/json" \
  -d "{\"game_key\": \"your_game_key\", \"id_token\": \"eyJQa....\", \"game_version\": \"1.0.0.0\" }"
```

### Response
#### Success Response (200)
- **session_token** (string) - The LootLocker session token.
- **player_id** (integer) - The unique LootLocker player ID.
- **public_uid** (string) - A public identifier for the player.
- **player_name** (string) - The player's name (if available).
- **player_created_at** (string) - Timestamp when the player was created.
- **check_grant_notifications** (boolean) - Indicates if grant notifications are checked.
- **check_deactivation_notifications** (boolean) - Indicates if deactivation notifications are checked.
- **seen_before** (boolean) - Indicates if the player has signed in before.
- **refresh_token** (string) - A token to refresh the session without a full sign-in flow.

#### Response Example
```json
{
  "session_token": "eb13a7bf17efg36cb8481a8ds18809c7e85686e6",
  "player_id": 9358,
  "public_uid": "J72YP6MS",
  "player_name": null,
  "player_created_at": "2023-02-21T15:33:25+00:00",
  "check_grant_notifications": false,
  "check_deactivation_notifications": false,
  "seen_before": true,
  "refresh_token": "eyJh............................."
}
```
```

--------------------------------

### Start Apple Session with Unreal Engine Blueprints

Source: https://docs.lootlocker.com/players/authentication/how-to/sign-in-with-apple

Provides a visual Blueprint example for starting an Apple Sign-In session in Unreal Engine. It outlines the input required (Apple Authorization Code) and the expected outputs, including session tokens and player identifiers. Error handling is recommended.

```blueprint
// This is a conceptual representation. Actual Blueprint nodes would be used.
// TriggerAppleStartSession event needs to be replaced with your login flow trigger.
// REPLACE: Apple Auth Code node needs to be replaced with your method of obtaining the Apple Authentication Code.
```

--------------------------------

### Start Epic Games Session

Source: https://docs.lootlocker.com/players/authentication/how-to/sign-in-with-epic-games

This section provides code examples for starting an Epic Games session using the LootLocker SDK and REST API. It requires an Epic Identity Token obtained from the Epic Dev Console.

```APIDOC
## POST /game/session/epic

### Description
Starts a game session using Epic Games authentication. Requires an Epic Identity Token.

### Method
POST

### Endpoint
https://api.lootlocker.io/game/session/epic

### Parameters
#### Query Parameters
None

#### Request Body
- **game_key** (string) - Required - Your LootLocker game key.
- **id_token** (string) - Required - The Epic Identity Token obtained from the Epic Dev Console.
- **game_version** (string) - Optional - The version of your game.

### Request Example
```json
{
  "game_key": "your_game_key",
  "id_token": "eyJQa....",
  "game_version": "1.0.0.0"
}
```

### Response
#### Success Response (200)
- **session_token** (string) - The session token for the authenticated user.
- **player_id** (integer) - The unique LootLocker player ID.
- **public_uid** (string) - A public-facing unique identifier for the player.
- **player_name** (string) - The player's name (can be null).
- **player_created_at** (string) - The timestamp when the player was created.
- **check_grant_notifications** (boolean) - Indicates if grant notifications are checked.
- **check_deactivation_notifications** (boolean) - Indicates if deactivation notifications are checked.
- **seen_before** (boolean) - Indicates if the player has been seen before.
- **refresh_token** (string) - A token to refresh the session without a full re-authentication.

#### Response Example
```json
{
  "session_token": "eb13a7bf17efg36cb8481a8ds18809c7e85686e6",
  "player_id": 9358,
  "public_uid": "J72YP6MS",
  "player_name": null,
  "player_created_at": "2023-02-21T15:33:25+00:00",
  "check_grant_notifications": false,
  "check_deactivation_notifications": false,
  "seen_before": true,
  "refresh_token": "eyJh............................."
}
```
```

--------------------------------

### Meta / Oculus Session Start API

Source: https://docs.lootlocker.com/players/authentication/how-to/meta

This section provides instructions and code examples for starting a Meta / Oculus session with LootLocker. It includes examples for Unity, Unreal, and a REST API call.

```APIDOC
## POST /game/session/meta

### Description
Starts a Meta / Oculus session by passing the UserID and Nonce obtained from the Oculus SDK. The response includes a session token and a refresh token for subsequent requests.

### Method
POST

### Endpoint
/game/session/meta

### Parameters
#### Query Parameters
None

#### Request Body
- **game_key** (string) - Required - Your LootLocker game key.
- **user_id** (string) - Required - The UserID obtained from the Oculus SDK.
- **nonce** (string) - Required - The Nonce obtained from the Oculus SDK.
- **game_version** (string) - Required - The current version of your game.

### Request Example
```bash
curl -X POST "https://api.lootlocker.io/game/session/meta" \
  -H "LL-Version: 2021-03-01" \
  -H "Content-Type: application/json" \
  -d "{\"game_key\": \"your_game_key\", \"user_id\": \"1234567890\", \"nonce\": \"0987654321\", \"game_version\": \"1.0.0.0\" }"
```

### Response
#### Success Response (200)
- **session_token** (string) - A token to authenticate subsequent API requests.
- **player_id** (integer) - The unique LootLocker player ID.
- **public_uid** (string) - A public identifier for the player.
- **player_name** (string) - The player's name (can be null).
- **player_created_at** (string) - The timestamp when the player was created.
- **check_grant_notifications** (boolean) - Indicates if grant notifications are checked.
- **check_deactivation_notifications** (boolean) - Indicates if deactivation notifications are checked.
- **seen_before** (boolean) - Indicates if the player has been seen before.
- **refresh_token** (string) - A token to refresh the session without a full sign-in.

#### Response Example
```json
{
  "session_token": "eb13a7bf17efg36cb8481a8ds18809c7e85686e6",
  "player_id": 9358,
  "public_uid": "J72YP6MS",
  "player_name": null,
  "player_created_at": "2023-02-21T15:33:25+00:00",
  "check_grant_notifications": false,
  "check_deactivation_notifications": false,
  "seen_before": true,
  "refresh_token": "eyJh............................."
}
```

### Unity Example
```csharp
string userID = "user_id";
string nonce = "nonce";

LootLockerSDKManager.StartMetaSession(userID, nonce, (response) =>
{
    if (!response.success)
    {
        Debug.Log("error starting LootLocker session");

        return;
    }

    Debug.Log("session started successfully");

    // Store these to be able to refresh the session without using the full sign in flow
    string refreshToken = response.refresh_token;
});
```
```

--------------------------------

### Start and Maintain LootLocker Server Session in Unreal C++

Source: https://docs.lootlocker.com/server/unreal-server/how-to/unreal-server-start-server

This C++ code demonstrates how to start a LootLocker server session and set up a recurring timer to maintain it. It includes callbacks for session start and maintenance, logging success or failure messages. The session is refreshed every 55 minutes to ensure it remains valid.

```cpp
#include "ServerSession.h"
#include "LootLockerServerForCpp.h"
#include "Templates/SharedPointer.h"
#include "TimerManager.h"

// Timer handle to maintain the session
FTimerHandle MaintainSessionTimerHandle;

void OnServerAuthCompleted(FLootLockerServerAuthenticationResponse Response)
{
	if (Response.Success)
	{
		UE_LOG(LogTemp, Log, TEXT("LootLocker server session started successfully. Next refresh in 55 minutes."));
		// Here we create a new instance of ServerSession to refresh the session.
		// We recommend using a singleton pattern or a static instance for better management in a real application.
		// Adapt to your game code as needed.
		TSharedPtr<ServerSession> MyServerSession = MakeShared<ServerSession>();
		if (GWorld)
		{
			FTimerDelegate TimerDel = FTimerDelegate::CreateRaw(MyServerSession, &ServerSession::MaintainServerSession);
			GWorld->GetTimerManager().SetTimer(
				MyServerSession->MaintainSessionTimerHandle,
				TimerDel,
				3300.0f, // 3300 seconds = 55 minutes
				true // Loop the timer to maintain the session every 55 minutes
			);
		}
	}
	else
	{
		UE_LOG(LogTemp, Error, TEXT("Failed to start LootLocker session: %s"), *Response.ErrorData.Message);
	}
}

// Call this function when you start your Server: GameModeBase, GameInstance, Server Actor, etc.
void ServerSession::StartLootLockerSession()
{
	// CPP delegate
	FLootLockerServerAuthResponseDelegate CPPDelegate;
	CPPDelegate.BindStatic(&OnServerAuthCompleted);

	// Call Start Session
	ULootLockerServerForCpp::StartSession(CPPDelegate);
}

void OnMaintainSessionCompleted(FLootLockerServerMaintainSessionResponse Response)
{
	if (Response.Success)
	{
		UE_LOG(LogTemp, Log, TEXT("LootLocker server session refreshed. Next refresh in 55 minutes."));
	}
	else
	{
		UE_LOG(LogTemp, Error, TEXT("Failed to start refresh session: %s"), *Response.ErrorData.Message);
	}
}

void ServerSession::MaintainServerSession()
{
	// CPP delegate
	FLootLockerServerMaintainSessionResponseDelegate CPPDelegate;
	CPPDelegate.BindStatic(&OnMaintainSessionCompleted);

	// Call Start Session
	ULootLockerServerForCpp::MaintainSession(CPPDelegate);
}

```

--------------------------------

### Verify Steam Player and Start Session in Godot

Source: https://docs.lootlocker.com/players/authentication/how-to/steam

This snippet demonstrates how to verify a Steam player and start a session using LootLocker in Godot. It requires Steam to be initialized and retrieves the authentication ticket, parses it, and then sends it to LootLocker to start a new session. Error handling is included for ticket retrieval, parsing, and session initiation. The response contains player IDs and other useful information.

```gdscript
var auth_ticket = Steam.getAuthSessionTicket()
if !auth_ticket.has('buffer'):
    printerr("Steam Auth Session Ticket retrieval failed")
    # Handle error as fit in your code

var authTicketString : String = LL_Authentication.ParseSteamAuthTicket(auth_ticket['buffer'], auth_ticket['size'])
if authTicketString.is_empty():
    printerr("Auth ticket could not be parsed")
    # Handle error as fit in your code

var steamLoginResponse = await LL_Authentication.SteamSession.new(authTicketString).send()
if(!steamLoginResponse.success) :
    printerr("Login failed with reason: " + steamLoginResponse.error_data.to_string(), true)
    # Handle error as fit in your code
print("Successfully started Steam session with LootLocker")
```

--------------------------------

### Start White Label Session (Unity)

Source: https://docs.lootlocker.com/players/white-label-login/how-to/start-session

Initiates a White Label login and starts a game session using provided email, password, and a remember-me flag. Handles success and error responses from the SDK.

```csharp
// Remember to use the LootLocker namespace in the top of your file.
using LootLocker.Requests;

// This code should be placed in a handler when user clicks the login button.
string email = "user@lootlocker.io";
string password = "password here";
bool rememberMe = true;
LootLockerSDKManager.WhiteLabelLoginAndStartSession(email, password, rememberMe, response =>
{
    if (!response.success)
    {
        if (!response.LoginResponse.success) {
            Debug.Log("error while logging in");
        } else if (!response.SessionResponse.success) {
            Debug.Log("error while starting session");
        }
        return;
    }

     // Handle Returning Player
});
```

--------------------------------

### Start Google Session via REST API

Source: https://docs.lootlocker.com/players/authentication/how-to/sign-in-with-google

Starts a Google session by making a POST request to the LootLocker REST API. Requires game key, Google ID token, and game version. The response includes session tokens and player information.

```bash
curl -X POST "https://api.lootlocker.io/game/session/google" \
  -H "LL-Version: 2021-03-01" \
  -H "Content-Type: application/json" \
  -d "{\"game_key\": \"your_game_key\", \"id_token\": \"eyJQa....\", \"game_version\": \"1.0.0.0\" }"
```

--------------------------------

### Start Game Session with Session Token (Bash)

Source: https://docs.lootlocker.com/players/white-label-login/how-to/start-session

Initiates a game session using the LootLocker API. Requires a valid session token and game key. The request body includes game details like email and version. The response contains session details and player information.

```bash
curl -X POST "https://api.lootlocker.io/game/v2/session/white-label" \
  -H "Content-Type: application/json" \
  -d "{\"game_key\": \"your_game_key\", \"email\": \"test@lootlocker.io\", \"token\": \"afccd38d-09d5-48aa-8235-b9c4c9151596\", \"game_version\": \"0.10.0.0\"}"
```

--------------------------------

### List Broadcasts Example in Unreal Blueprints

Source: https://docs.lootlocker.com/players/broadcasts/how-to/list-broadcasts-in-game

This section provides a visual example of how to list broadcasts using Unreal Engine Blueprints. It links to an external Blueprint example demonstrating the functionality. This is useful for developers who prefer a visual scripting approach.

```blueprint
https://blueprintue.com/blueprint/a5_5dmom/
```

--------------------------------

### Refresh Apple Session (Unreal Engine Blueprint)

Source: https://docs.lootlocker.com/players/authentication/how-to/sign-in-with-apple

Provides a visual blueprint example for refreshing a game session with Apple authentication in Unreal Engine. It demonstrates how to trigger the refresh and handle the response, including success and potential errors. The example links to an external resource for detailed blueprint instructions.

```text
Blueprint example of refreshing a game session with Apple - https://blueprintue.com/blueprint/djpexw1a/
```

--------------------------------

### Start White Label Session (REST API)

Source: https://docs.lootlocker.com/players/white-label-login/how-to/start-session

Demonstrates how to initiate a White Label login via a REST API POST request to the /white-label-login/login endpoint. It requires domain-key, is-development flag, and a JSON payload with email, password, and remember flag. The response includes a session token.

```bash
curl -X POST "https://api.lootlocker.io/white-label-login/login" \
  -H "domain-key: 11aaa11" \
  -H "is-development: true" \
  -H "Content-Type: application/json" \
  -d "{\"email\": \"test@lootlocker.io\", \"password\": \"some password here\", \"remember\": true}"
```

--------------------------------

### Unity IAP Setup and Purchase Flow

Source: https://docs.lootlocker.com/commerce/real-money-purchases/how-to/google-play-store-purchasing

This snippet demonstrates how to set up Unity's In-App Purchasing (IAP) system, add products, and initiate a purchase. It requires implementing the IDetailedStoreListener interface and handling initialization and purchase processing. The code integrates with LootLocker for redeeming purchases.

```csharp
using Unity.Services.Core;
using Unity.Services.Core.Environments;
using UnityEngine;
using UnityEngine.Purchasing;
using UnityEngine.Purchasing.Extension;

public class IAPManager : MonoBehaviour, IDetailedStoreListener
{

    public IStoreController controller;
    private IExtensionProvider extensions;

    public async void Awake()
    {
        try
        {
            var options = new InitializationOptions()
                .SetEnvironmentName("production");

            await UnityServices.InitializeAsync(options);
        }
        catch (Exception exception)
        {
            Debug.Log(exception);
        }
        //Specifically creates IAP for Google Play Store, using ifdefs to determine which platform is being run is preferable.
        var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance(AppStore.GooglePlay));

        builder.AddProduct("<replace_with_product_id>", ProductType.Consumable);

        StandardPurchasingModule.Instance().useFakeStoreAlways = true;

        UnityPurchasing.Initialize(this, builder);
    }

    public void OnPurchaseClicked(string productId)
    {
        controller.InitiatePurchase(productId);
    }

    public void Purchase()
    {
        var product = controller.products.WithID("<replace_with_product_id>");

        if (product is { availableToPurchase: true })
        {
            controller.InitiatePurchase(product);
        }
    }

    /// <summary>
    /// Called when Unity IAP is ready to make purchases.
    /// </summary>
    public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
    {
        this.controller = controller;
        this.extensions = extensions;
    }

    /// <summary>
    /// Called when Unity IAP encounters an unrecoverable initialization error.
    ///
    /// Note that this will not be called if Internet is unavailable; Unity IAP
    /// will attempt initialization until it becomes available.
    /// </summary>
    public void OnInitializeFailed(InitializationFailureReason error)
    {
    }

    /// <summary>
    /// Called when a purchase completes.
    ///
    /// May be called at any time after OnInitialized().
    /// </summary>
    public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs e)
    {
        LootLockerIAPManager.RedeemPurchase(e.purchasedProduct);
        return PurchaseProcessingResult.Complete;
    }

    /// <summary>
    /// Called when a purchase fails.
    /// </summary>
    public void OnPurchaseFailed(Product i, PurchaseFailureReason p)
    {
    }

    public void OnPurchaseFailed(Product product, PurchaseFailureDescription failureDescription)
    {

    }

    public void OnInitializeFailed(InitializationFailureReason error, string message)
    {
        Debug.Log("Error: " + message);
    }
}
```

--------------------------------

### Get Trace ID in Unity

Source: https://docs.lootlocker.com/the-basics/support

This C# code snippet demonstrates how to force an error in Unity to retrieve a Trace ID. It involves starting a session and attempting to get progression with an incorrect key, then logging the error response to the console where the Trace ID can be found.

```csharp
LootLockerSDKManager.GetProgression("IncorrectKey", (response) => 
{
  if(!response.success)
    {
      Debug.Log(response.text);
    }
});
```

--------------------------------

### Register Guest Session in Unreal Engine

Source: https://docs.lootlocker.com/players/authentication/how-to/guest-login

Provides an example of implementing guest login using Unreal Engine Blueprints. It highlights the 'Guest Login' node and the importance of handling the success flag for subsequent calls. A player identifier can optionally be provided.

```blueprint
// Blueprint visual scripting example (description only, actual code cannot be represented here)
```

--------------------------------

### Register Guest Session in Godot

Source: https://docs.lootlocker.com/players/authentication/how-to/guest-login

Demonstrates how to initiate a guest session in Godot using GDScript. It utilizes the `LL_Authentication.GuestSession` class and awaits the response. Error handling is included for failed login attempts.

```gdscript
var guestLoginResponse = await LL_Authentication.GuestSession.new(playerIdentifier).send()
if(!guestLoginResponse.success) :
  printerr("Guest login failed with reason: " + guestLoginResponse.error_data.to_string())
  return

print("Guest user was successfully signed in to LootLocker")
```

--------------------------------

### Implement Classes In-Game (Unreal Engine)

Source: https://docs.lootlocker.com/game-systems/classes-and-heroes/how-to/implement-classes-in-game

Provides examples for implementing character class functionalities within Unreal Engine using Blueprints. These examples cover creating, updating, listing class types, listing player classes, and getting class loadouts.

```blueprint
Blueprint example of Creating a Class
https://blueprintue.com/blueprint/-naacq2r/
```

```blueprint
Blueprint example of Updating a Class
https://blueprintue.com/blueprint/hx54d9an/
```

```blueprint
Blueprint example of Listing Class Types
https://blueprintue.com/blueprint/brhpc7rz/
```

```blueprint
Blueprint example of listing all Player classes
https://blueprintue.com/blueprint/einioki8/
```

```blueprint
Blueprint example of getting a Class loadout
https://blueprintue.com/blueprint/8gz74522/
```

--------------------------------

### Authenticate Player and Sync Session Token (Unreal C++)

Source: https://docs.lootlocker.com/server/unreal-server/how-to/unreal-server-impersonation

This snippet demonstrates how to perform a guest login for a player using the LootLocker SDK and sync the received session token to the game server. It includes basic error handling and a placeholder for server synchronization logic. Ensure the LootLocker SDK is initialized before calling this function.

```cpp
ULootLockerSDKManager::GuestLogin(FLootLockerSessionResponse::CreateLambda([](const FLootLockerAuthenticationResponse& sessionResponse) {
    if (!sessionResponse.success)
    {
        // Handle the error case
        UE_LOG(<LogCategory>, Error, TEXT("Failed to login: %s"), *sessionResponse.ErrorData.Message);
        return;
    }

    // Replace with your way of syncing the session token to the server
    SyncPlayerTokenToGameServer(sessionResponse.session_token);
}));
```

--------------------------------

### Follow Player (Optimistic UI) - Unreal C++

Source: https://docs.lootlocker.com/players/friends-and-followers/how-to/use-followers-in-game

Demonstrates the optimistic 'Follow Player' UI pattern in Unreal Engine using C++. It immediately updates the UI to a 'following' state and includes logic to roll back if the SDK call fails. Requires a set of followed player IDs and UI elements for feedback.

```cpp
class FFollowAction
{
public:
	TSet<FString> FollowingIds;

	void Follow(const FString& TargetPublicUid)
	{
		if (TargetPublicUid.IsEmpty()) return;
		if (FollowingIds.Contains(TargetPublicUid))
		{
			UPlayerProfileWidget::ShowToast(TEXT("Already following"));
			return;
		}

		// Optimistic state
		UPlayerProfileWidget::SetFollowButtonState(EFollowState::Loading);
		UPlayerProfileWidget::SetFollowButtonState(EFollowState::Following); // Immediately show success state
		FollowingIds.Add(TargetPublicUid);

		ULootLockerSDKManager::FollowPlayer(TargetPublicUid,
			FLootLockerFollowActionResponseDelegate::CreateLambda([PublicUID=TargetPublicUid, &](const FLootLockerFollowActionResponse& Response) {
                
                if (!Response.success)
                {
                    // Rollback: attempt to remove. We would have needed to store which target we just added if multiple calls can be concurrent.
                    // For simplicity, assume only one in-flight follow at a time.
                    FollowingIds.Remove(PublicUID);
                    UPlayerProfileWidget::SetFollowButtonState(EFollowState::Follow);
                    UPlayerProfileWidget::ShowToast(FString::Printf(TEXT("Follow failed: %s"), *Response.Error));
                    return;
                }

                UPlayerProfileWidget::ShowToast(TEXT("Now following"));
                UPlayerProfileHeaderWidget::IncrementFollowingCount(1); // Optional
            }));
	}
}
```

--------------------------------

### Start Session with Timezone Support (Unity)

Source: https://docs.lootlocker.com/players/broadcasts/how-to/list-broadcasts-in-game

Initiates a player session with optional timezone information to ensure accurate filtering and scheduling of broadcast messages. This example uses Guest Login and requires the LootLocker SDK.

```csharp
using LootLocker.Requests;
using System;

public void StartSessionWithTimezone()
{
    // Create session optionals to include timezone
    LootLockerSessionOptionals optionals = new LootLockerSessionOptionals();
    
    // For Windows, convert the system timezone to IANA format, read more in the section below
    optionals.timezone = LootLockerTimezoneConverter.ConvertWindowsToIanaTzString(TimeZoneInfo.Local.StandardName);
    
    // Start a guest session with timezone
    LootLockerSDKManager.StartGuestSession((response) =>
    {
        if (response.success)
        {
            Debug.Log("Session started successfully with timezone: " + options.timezone);
            // Proceed to retrieve broadcasts
        }
        else
        {
            Debug.LogError("Failed to start session: " + response.errorData.message);
        }
    }, optionals);
}
```

--------------------------------

### Get Other Players Public Storage

Source: https://docs.lootlocker.com/legacy/storage

Retrieves public storage data for another player using their public UID. This is supported in Unity and via REST API. An Unreal Engine blueprint example is also available.

```csharp
LootLockerSDKManager.GetOtherPlayersPublicKeyValuePairs("92AR9254", (response) =>
{
    if (response.success)
    {
        Debug.Log("Successfully retrieved storage for other player " + response.payload.Length);
    }
    else
    {
        Debug.Log("Error retrieving storage for other player");
    }
});
```

```bash
curl -X GET "https://api.lootlocker.io/game/v1/player/A1B2C3D4/storage" \
  -H "x-session-token: your_token_here"
```

--------------------------------

### Connect Provider Account

Source: https://docs.lootlocker.com/players/unified-player-accounts/how-to/transition-guest-player

This endpoint connects a player's account to a new provider (e.g., Apple, Google) using a token obtained from the provider's authentication. This is the first step in transitioning from a guest account.

```APIDOC
## POST /game/v1/connected-accounts

### Description
Connects a player's account to a new provider using an authorization token.

### Method
PUT

### Endpoint
`/game/v1/connected-accounts`

### Parameters
#### Query Parameters
None

#### Request Body
- **authorization_code** (string) - Required - The token obtained from authenticating with the new provider.

### Request Example
```json
{
  "authorization_code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.0.xxxxx.xxxxxxxx-xxxxxxxxxxxxx"
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the account connection was successful.

#### Response Example
```json
{
  "success": true
}
```
```

--------------------------------

### Get Progression Data (C#)

Source: https://docs.lootlocker.com/the-basics/support

This C# code snippet demonstrates how to retrieve progression data using the LootLocker SDK. It includes a callback function to handle the response, logging any errors to the console. Ensure the LootLocker SDK is integrated into your project.

```csharp
LootLockerSDKManager.GetProgression("SomeKey", (response) => 
{
  if(!response.success)
    {
      Debug.Log(response.text);
    }
});
```

--------------------------------

### Implement Unity IAP and LootLocker Integration

Source: https://docs.lootlocker.com/commerce/real-money-purchases/how-to/apple-store-purchasing

This Unity C# script demonstrates how to initialize Unity's In-App Purchasing (IAP) system, add products, initiate purchases, and process them by redeeming them with LootLocker. It requires the Unity Services package and the Unity Purchasing package. The script handles initialization, product definition, purchase initiation, and purchase processing, including error handling for initialization failures.

```csharp
using Unity.Services.Core;
using Unity.Services.Core.Environments;
using UnityEngine;
using UnityEngine.Purchasing;
using UnityEngine.Purchasing.Extension;

public class IAPManager : MonoBehaviour, IDetailedStoreListener
{

    public IStoreController controller;
    private IExtensionProvider extensions;

    public async void Awake()
    {
        try
        {
            var options = new InitializationOptions()
                .SetEnvironmentName("production");

            await UnityServices.InitializeAsync(options);
        }
        catch (Exception exception)
        {
            Debug.Log(exception);
        }
        //Specifically creates IAP for Google Play Store, using ifdefs to determine which platform is being run is preferable.
        var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance(AppStore.AppleAppStore));

        builder.AddProduct("<replace_with_product_id>", ProductType.Consumable);

        StandardPurchasingModule.Instance().useFakeStoreAlways = true;

        UnityPurchasing.Initialize(this, builder);
    }

    public void OnPurchaseClicked(string productId)
    {
        controller.InitiatePurchase(productId);
    }

    public void Purchase()
    {
        var product = controller.products.WithID("<replace_with_product_id>");

        if (product is { availableToPurchase: true })
        {
            controller.InitiatePurchase(product);
        }
    }

    /// <summary>
    /// Called when Unity IAP is ready to make purchases.
    /// </summary>
    public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
    {
        this.controller = controller;
        this.extensions = extensions;
    }

    /// <summary>
    /// Called when Unity IAP encounters an unrecoverable initialization error.
    ///
    /// Note that this will not be called if Internet is unavailable; Unity IAP
    /// will attempt initialization until it becomes available.
    /// </summary>
    public void OnInitializeFailed(InitializationFailureReason error)
    {
    }

    /// <summary>
    /// Called when a purchase completes.
    ///
    /// May be called at any time after OnInitialized().
    /// </summary>
    public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs e)
    {
        LootLockerIAPManager.RedeemPurchase(e.purchasedProduct);
        return PurchaseProcessingResult.Complete;
    }

    /// <summary>
    /// Called when a purchase fails.
    /// </summary>
    public void OnPurchaseFailed(Product i, PurchaseFailureReason p)
    {
    }

    public void OnPurchaseFailed(Product product, PurchaseFailureDescription failureDescription)
    {

    }

    public void OnInitializeFailed(InitializationFailureReason error, string message)
    {
        Debug.Log("Error: " + message);
    }
}
```

--------------------------------

### Get UTC Offset as Iana Timezone in Unreal Engine (C++)

Source: https://docs.lootlocker.com/players/broadcasts/how-to/list-broadcasts-in-game

Calculates the current UTC offset and formats it as an Iana timezone string. This method is used to send the user's Iana timezone to LootLocker when starting a session.

```cpp
FString YourClass::GetCurrentUTCOffsetAsIanaTimezone()
{
	FDateTime Now = FDateTime::Now();
	FDateTime UTCNow = FDateTime::UtcNow();
	FTimespan Offset = Now - UTCNow;
	int offsetHours = Offset.GetHours();
	FString tz = FString::Printf(TEXT("ETC/GMT%s%d"), offsetHours < 0 ? TEXT("-") : TEXT("+"), FMath::Abs(offsetHours));
	return tz.IsEmpty() ? TEXT("N/A") : tz;
}
```

--------------------------------

### Connect Player Account to Apple Provider

Source: https://docs.lootlocker.com/players/unified-player-accounts/how-to/transition-guest-player

This snippet demonstrates how to connect a player's account to Apple. It requires a token obtained from authenticating with Apple locally. The response indicates success or failure of the connection.

```csharp
string token = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.0.xxxxx.xxxxxxxx-xxxxxxxxxxxxx";
LootLockerSDKManager.ConnectAppleAccount(token, (response) =>
{
    if(!response.success)
    {
        Debug.Log("Error connecting Apple");
        return;
    }

    Debug.Log("Successfully connected Apple");
});
```

```bash
curl -X PUT "https://api.lootlocker.io/game/v1/connected-accounts" \
    -H "x-session-token: your_token_here" \
    -H "Content-Type: application/json" \
    -d '{"authorization_code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.0.xxxxx.xxxxxxxx-xxxxxxxxxxxxx"}'
```

--------------------------------

### Displaying Counts with Pagination in Unreal Engine

Source: https://docs.lootlocker.com/players/friends-and-followers/how-to/use-followers-in-game

Illustrates how to fetch and display follower and following counts in Unreal Engine using C++. It infers counts from the first page of results and the presence of a cursor, updating UI labels. Handles potential fetch errors and provides placeholders.

```cpp
class FFollowerCountsHelper
{
public:
	// Optional cached values; unset (-1) until fetched
	int32 FollowersFirstPageCount = -1;
	int32 FollowingFirstPageCount = -1;
	int32 FollowersFirstTotalCount = -1;
	int32 FollowingFirstTotalCount = -1;

	void FetchFollowersFirstPage()
	{
		ULootLockerSDKManager::ListFollowers(
			FLootLockerListFollowersResponseDelegate::CreateRaw(this, &FFollowerCountsHelper::OnFollowersPage));
	}

	void FetchFollowingFirstPage()
	{
		ULootLockerSDKManager::ListFollowing(
			FLootLootLockerListFollowersResponseDelegate::CreateRaw(this, &FFollowerCountsHelper::OnFollowingPage));
	}

private:
	void OnFollowersPage(const FLootLockerListFollowersResponse& Response)
	{
		if (!Response.success)
		{
			UE_LOG(LogTemp, Warning, TEXT("Followers count fetch failed: %s"), *Response.Error);
			FollowersFirstPageCount = 0; FollowersFirstTotalCount = 0; UpdateFollowersLabel();
			return;
		}
		FollowersFirstPageCount = Response.Followers.Num();
		FollowersFirstTotalCount = Response.Pagination.Total;
		UpdateFollowersLabel();
	}

	void OnFollowingPage(const FLootLootLockerListFollowersResponse& Response)
	{
		if (!Response.success)
		{
			UE_LOG(LogTemp, Warning, TEXT("Following count fetch failed: %s"), *Response.Error);
			FollowingFirstPageCount = 0; FollowingFirstTotalCount = 0; UpdateFollowingLabel();
			return;
		}
		FollowingFirstPageCount = Response.Followers.Num();
		FollowingFirstTotalCount = Response.Pagination.Total;
		UpdateFollowingLabel();
	}

	void UpdateFollowersLabel()
	{
		if (FollowersFirstPageCount < 0) return; // not ready
		UProfileHeaderWidget::SetFollowersCount(FString::Printf(TEXT("%d/%d"), FollowersFirstPageCount, FollowersFirstTotalCount));
	}

	void UpdateFollowingLabel()
	{
		if (FollowingFirstPageCount < 0) return;
		UProfileHeaderWidget::SetFollowingCount(FString::Printf(TEXT("%d/%d"), FollowingFirstPageCount, FollowingFirstTotalCount));
	}
};
```

--------------------------------

### REST API Response for Apple Game Center Session

Source: https://docs.lootlocker.com/players/authentication/how-to/apple-game-center

Example JSON response from the LootLocker REST API after successfully starting an Apple Game Center session. It includes session token, player details, and refresh token for subsequent operations.

```json
{
  "session_token": "eb13a7bf17efg36cb8481a8ds18809c7e85686e6",
  "player_id": 9358,
  "public_uid": "J72YP6MS",
  "player_name": null,
  "player_created_at": "2023-02-21T15:33:25+00:00",
  "check_grant_notifications": false,
  "check_deactivation_notifications": false,
  "seen_before": false,
  "refresh_token": "eyJh............................."
}
```

--------------------------------

### Get Player ULID for Request Execution (Unity, Unreal C++)

Source: https://docs.lootlocker.com/players/multi-user/troubleshooting

Checks which player's ULID a specific LootLocker API request was executed for. This is crucial for debugging and verifying user context, especially in multi-user environments. Examples provided for Unity and Unreal Engine C++.

```Unity
var progression_key = "replace_with_your_key";
var executeRequestForPlayerWithUlid = "replace_with_your_player_ulid";
LootLockerSDKManager.GetProgression(progression_key, response =>
{
    if (!response.success)
    {
        Debug.LogWarning($"Getting progression data for {progression_key} failed: {response.errorData}"
            + $"\n request was executed for player with ulid {response.requestContext.player_ulid}"
            + $" and was expected to be executed for player with ulid {executeRequestForPlayerWithUlid}");
    }
}, executeRequestForPlayerWithUlid);
```

```Unreal C++
FString progression_key = "replace_with_your_key";
FString executeRequestForPlayerWithUlid = "replace_with_your_player_ulid";
ULootLockerSDKManager::GetProgression(progression_key, FLootLockerProgressionResponseDelegate::CreateLambda([=](const FLootLockerProgressionResponse& response)
{
    if (!response.success)
    {
        UE_LOG(LogWorkingProject, Warning, TEXT("Getting progression data for %s failed: %s"), *progression_key, *response.errorData);
        UE_LOG(LogWorkingProject, Warning, TEXT("Request was executed for player with ulid %s"), *response.requestContext.player_ulid);
        UE_LOG(LogWorkingProject, Warning, TEXT("And was expected to be executed for player with ulid %s"), *executeRequestForPlayerWithUlid);
    }
}), executeRequestForPlayerWithUlid);
```

--------------------------------

### Load and Paginate Followers - C++

Source: https://docs.lootlocker.com/players/friends-and-followers/how-to/use-followers-in-game

Handles loading the first page of followers and subsequent pages with pagination. It interacts with LootLocker SDK functions and updates UI widgets. Assumes UI functions like SetFollowersLoading, ReplaceFollowers, AppendFollowers, and ShowFollowersEndOfList are defined elsewhere.

```cpp
#include "LootLockerManager.h"
#include "LootLockerSDK/LLFollowers.h"

class FFollowsExample
{
public:
	TArray<FLootLockerFollower> Followers;
	TArray<FLootLockerFollower> Following;

	FString FollowersNextCursor;
	FString FollowingNextCursor;

	static constexpr int32 PageSize = 25;

	void LoadFirstFollowersPage()
	{
		Followers.Empty();
		FollowersNextCursor.Empty();
		UFollowersWidget::SetFollowersLoading(true);

		ULootLockerSDKManager::ListFollowers(
			FLootLockerListFollowersResponseDelegate::CreateRaw(this, &FFollowsExample::OnFollowersFirstPage));
	}

	void LoadMoreFollowers()
	{
		if (FollowersNextCursor.IsEmpty()) return;
		UFollowersWidget::SetFollowersLoading(true);

		ULootLockerSDKManager::ListFollowersPaginated(FollowersNextCursor, PageSize,
			FLootLockerListFollowersResponseDelegate::CreateRaw(this, &FFollowsExample::OnFollowersNextPage));
	}

private:
	void OnFollowersFirstPage(const FLootLockerListFollowersResponse& Response)
	{
		UFollowersWidget::SetFollowersLoading(false);
		if (!Response.success)
		{
			UE_LOG(LogTemp, Warning, TEXT("Followers first page failed: %s"), *Response.Error);
			return;
		}

		Followers = Response.Followers;
		UFollowersWidget::ReplaceFollowers(Followers);

		FollowersNextCursor = Response.Pagination.Next_Cursor;
		if (FollowersNextCursor.IsEmpty())
		{
			UFollowersWidget::ShowFollowersEndOfList();
		}
	}

	void OnFollowersNextPage(const FLootLockerListFollowersResponse& Response)
	{
		UFollowersWidget::SetFollowersLoading(false);
		if (!Response.success)
		{
			UE_LOG(LogTemp, Warning, TEXT("Followers next page failed: %s"), *Response.Error);
			return;
		}

		if (Response.Followers.Num() > 0)
		{
			Followers.Append(Response.Followers);
			UFollowersWidget::AppendFollowers(Response.Followers);
		}

		FollowersNextCursor = Response.Pagination.Next_Cursor;
		if (FollowersNextCursor.IsEmpty())
		{
			UFollowersWidget::ShowFollowersEndOfList();
		}
	}

public:
	void LoadFirstFollowingPage()
	{
		Following.Empty();
		FollowingNextCursor.Empty();
		UFollowingWidget::SetFollowingLoading(true);

		ULootLockerSDKManager::ListFollowing(
			FLootLockerListFollowersResponseDelegate::CreateRaw(this, &FFollowsExample::OnFollowingFirstPage));
	}

	void LoadMoreFollowing()
	{
		if (FollowingNextCursor.IsEmpty()) return;
		UFollowingWidget::SetFollowingLoading(true);
		ULootLockerSDKManager::ListFollowingPaginated(FollowingNextCursor, PageSize,
			FLootLockerListFollowersResponseDelegate::CreateRaw(this, &FFollowsExample::OnFollowingNextPage));
	}

private:
	void OnFollowingFirstPage(const FLootLockerListFollowersResponse& Response)
	{
		UFollowingWidget::SetFollowingLoading(false);
		if (!Response.success)
		{
			UE_LOG(LogTemp, Warning, TEXT("Following first page failed: %s"), *Response.Error);
			return;
		}

		Following = Response.Followers;
		UFollowingWidget::ReplaceFollowing(Following);
		FollowingNextCursor = Response.Pagination.Next_Cursor;
		if (FollowingNextCursor.IsEmpty())
		{
			UFollowingWidget::ShowFollowingEndOfList();
		}
	}

	void OnFollowingNextPage(const FLootLockerListFollowersResponse& Response)
	{
		UFollowingWidget::SetFollowingLoading(false);
		if (!Response.success)
		{
			UE_LOG(LogTemp, Warning, TEXT("Following next page failed: %s"), *Response.Error);
			return;
		}

		if (Response.Followers.Num() > 0)
		{
			Following.Append(Response.Followers);
			UFollowingWidget::AppendFollowing(Response.Followers);
		}

		FollowingNextCursor = Response.Pagination.Next_Cursor;
		if (FollowingNextCursor.IsEmpty())
		{
			UFollowingWidget::ShowFollowingEndOfList();
		}
	}
};

```

--------------------------------

### Fetch Single Metadata using REST API

Source: https://docs.lootlocker.com/shared-systems/metadata/how-to/fetch-a-single-metadata-in-game

Demonstrates how to fetch a single metadata entry using the LootLocker REST API. This example uses a cURL command to make a GET request to the metadata endpoint, requiring an authentication token. Prerequisites include a LootLocker account, a game, a feature with metadata, and an active game session.

```bash
curl -X GET 'https://api.lootlocker.io/game/metadata/source/catalog_item/id/{ulid}?key={value}&ignore_files={bool}' \
    -H 'x-session-token: your_token_here' \

```
Tokens:
Raw