Structure

PLAY SDK (former READYgg SDK) is divided into multiple modules. Every module has its own functionality. All modules depend on the RGNCore module.

In case you want to see our sample DEMO scene implementation you need to use our Sample package.

Import the sample package by pasting following into your manifest.json file:

After the package is imported, you can see it in Unity Package manager (Window->Package Manager):

After you import the Sample, you'll see a new folder in your Assets folder. You can open the DEMO scene from the Sample. Unity will ask you to import the TextMeshPro Essentials in case you have not done it already

The DEMO sample scene looks like this:

By default the user is logged in as a guest user. So, everything you'll do, will be stored in the cloud. At the start you can visit the Store Test and try to buy some items.

If you click on Virtual Items you can see similar UI:

The basics

Welcome to PLAY (former READYgg) documentation!

The Getting Started describes the project requirements you need to meet to use PLAY SDK. The Install Dependencies describes the PLAY SDK dependencies and how to install them.

To quickly become proficient with the PLAY SDK, follow the integration steps in sequence. They will guide you through setting up and utilizing various features available on PLAY.

To review the supported features by the PLAY SDK, you can move to the modules section.

Developers have access to two different environments:

1. Staging: Use this environment while developing and testing. This environment will use the testing blockchain backend.

2. Production: Use this environment for the releases, live versions available to users.

Example.

1. John started integrating the PLAY SDK in his application by setting the Staging environment.

2. He completed and tested feature Implementation in the Staging environment.

3. After that, he is ready to update the version in Stores, So he set Production and created new builds for store submission. He did a smoke test and updated in Stores.

4. After submitting to the stores, he switched back to the Staging environment to work on new features for their upcoming release.

Environment Setup

After setting up the above configuration data, you can switch Staging/Production environment from the Unity menu:

ReadyGamesNetwork->Set Staging

ReadyGamesNetwork->Set Production

Package Dependencies

In case you use an older version of Unity you need to add the Newtonsoft Json package. You can install it by pasting following into your manifest.json file:

"com.unity.nuget.newtonsoft-json": "3.2.1",

In the new Unity versions the Newtonsoft Json is build in to Unity. No need to install the package.

Dependencies Installation:

1. Git package repository link. The easiest way to add the READYgg SDK into your project is to use PLAY package distribution. You need simply put the package git repository links into manifest.json file. See instructions below.

Troubleshooting : if you have error messages in Unity saying that it cannot find the git repository, make sure you have Git installed on your machine. Unity Hub needs it to import packages from Github.

"io.getready.rgn.achievement": "https://github.com/readyio/RGNAchievement.git#0.11.1",
"io.getready.rgn.analytics": "https://github.com/readyio/RGNAnalytics.git#0.11.1",
"io.getready.rgn.core": "https://github.com/readyio/RGNCore.git#0.11.1",
"io.getready.rgn.currency": "https://github.com/readyio/RGNCurrency.git#0.11.1",
"io.getready.rgn.gamepass": "https://github.com/readyio/RGNGamePass.git#0.11.1",
"io.getready.rgn.gameprogress": "https://github.com/readyio/RGNGameProgress.git#0.11.1",
"io.getready.rgn.inventory": "https://github.com/readyio/RGNInventory.git#0.11.1",
"io.getready.rgn.leaderboard": "https://github.com/readyio/RGNLeaderboard.git#0.11.1",
"io.getready.rgn.marketplace": "https://github.com/readyio/RGNMarketplace.git#0.11.1",
"io.getready.rgn.matchmaking": "https://github.com/readyio/RGNMatchmaking.git#0.11.1",
"io.getready.rgn.signin.email": "https://github.com/readyio/RGNSignInEmail.git#0.11.1",
"io.getready.rgn.signin.guest": "https://github.com/readyio/RGNSignInGuest.git#0.11.1",
"io.getready.rgn.store": "https://github.com/readyio/RGNStore.git#0.11.1",
"io.getready.rgn.userprofile": "https://github.com/readyio/RGNUserProfile.git#0.11.1",
"io.getready.rgn.virtualitems": "https://github.com/readyio/RGNVirtualItems.git#0.11.1",
"io.getready.rgn.wallets": "https://github.com/readyio/RGNWallets.git#0.11.1",

https://github.com/readyio/RGNAchievement.git#0.11.1
https://github.com/readyio/RGNAnalytics.git#0.11.1
https://github.com/readyio/RGNCore.git#0.11.1
https://github.com/readyio/RGNCurrency.git#0.11.1
https://github.com/readyio/RGNGamePass.git#0.11.1
https://github.com/readyio/RGNGameProgress.git#0.11.1
https://github.com/readyio/RGNInventory.git#0.11.1
https://github.com/readyio/RGNLeaderboard.git#0.11.1
https://github.com/readyio/RGNMarketplace.git#0.11.1
https://github.com/readyio/RGNMatchmaking.git#0.11.1
https://github.com/readyio/RGNSignInEmail.git#0.11.1
https://github.com/readyio/RGNSignInGuest.git#0.11.1
https://github.com/readyio/RGNStore.git#0.11.1
https://github.com/readyio/RGNUserProfile.git#0.11.1
https://github.com/readyio/RGNVirtualItems.git#0.11.1
https://github.com/readyio/RGNWallets.git#0.11.1

PLAY SDK requires the following software:

• Unity 2020 LTS or later. Installation instructions.

  • It is always recommended to use a late version of Unity for bug fixes and up-to-date compatibility.

Prerequisites

Setup your bundle identifier in the project setting:

1. Open project settings Unity window: Edit->Project Settings...

2. Select Player and open the Other Settings section

3. For iOS tab change the Bundle Identifier

4. For Android tab change the Package Name

Android

Choose Minimum API Level 21 in Project Settings->Player->Other Settings

For Android you can also change the Scripting Backend from Mono to IL2CPP. Since Unity Android Mono backend does not support arm64 which is required on Android Play Market. But to keep the development iterations faster, you can also keep Mono and only later jump to IL2CPP.

For Android, Target API Level should be 33 or higher for Google Play Store compliance.

Integration Support

If you are unable to find a solution in our documentation you can reach out to us directly by:

• Creating a GitHub issue here

• Dropping a message in our Discord dev-chat here

1. Go on the developer dashboard and select your project.

1. Click on Download unity packages to download your project credentials.

Structure

PLAY SDK is divided into multiple modules. Every module has its own functionality. All modules depend on the RGNCore module. In the current version, the modules are distributed by using packages for .

Obligatory modules/packages

• RGNCore

• RGNSignInEmail

• RGNSignInGuest

PLAY Unity Initializer

We created an initialization script to automatically setup every module. This script can manage automatically the guest signIn and the modules initialization. To use it, simply create an empty GameObject in your starting scene and attach RGNUnityInitilizer.cs to it. With this script, you don't need to manually build the RGNCore and modules.

Access modules

To access modules you can use the "I" instance provider property:

For example:

Modules namespaces

The modules are located in the RGN.Modules.[module_name] namespaces. Here you can find a full list of modules with the namespaces:

Package Dependencies Installation:

1. Follow the link - https://github.com/readyio/rgn_unreal and clone it somewhere nearby the project directory.

2. Open the just pulled repository and copy the folder “Plugins” from it to the root of your project directory.

3. Open your project via Unreal Engine again and accept the offer to rebuild the modules.

PLAY SDK requires the following software:

• Unreal 5+

  • It is always recommended to use a late version of Unreal for bug fixes and up-to-date compatibility.

Integration Support

If you are unable to find a solution in our documentation you can reach out to us directly by:

• Creating a GitHub issue here

• Dropping a message in our Discord dev-chat here

1. Go on the developer dashboard and select/create your project.

1. Open the project settings and scroll down to the Plugins category and find the “ReadyGamesNetwork”, then fill the ProjectId and ApiKey fields by values from your console project.

Developers have access to two different environments:

1. Staging: Use this environment while developing and testing. This environment will use the testing blockchain backend.

2. Production: Use this environment for the releases, live versions available to users.

Example.

1. John started integrating the READYgg SDK in his application by setting the Staging environment.

2. He completed and tested feature Implementation in the Staging environment.

3. After that, he is ready to update the version in Stores, so he set Production and created new builds for store submission. He did a smoke test and updated in Stores.

4. After submitting to the stores, he switched back to the Staging environment to work on new features for their upcoming release.

Environment Setup

After setting up the above configuration data, you can switch Staging/Production environment from the Unreal plugin setting menu:

ReadyGamesNetwork->Environment Target->Staging

ReadyGamesNetwork->Environment Target->Production

1. Open your level blueprint.

1. All blueprints nodes for PLAY SDK you can find in special category named “ReadyGamesNetwork”.

1. Add two core nodes to start work with the SDK - Core /Initialize and Core /Update.

Introduction

To interact with the PLAY API, you will need to be authenticated. This will allow you to store and retrieve additional user data in the PLAY ecosystem.

Guest login

By default, the project is configured to automatically log into a guest account. This feature is enabled in the plugin settings.

If you require more control over this process, you can disable the checkbox and manually manage guest account logins.

Email login

Introduction

The user profile module is used to store user specific data related to his identity.

Get User Profile

Update UserName/Display Name

Update User Bio

Get User Currencies

"rgn-coin" Currency

Similar to other in-game currencies but it can only be obtained by making In-App Purchases - it cannot be earned or given as a reward to players. It is consumed to purchase NFT #virtual-items. For more details about the rgn-coin, please refer to the Currency module.

Introduction

To interact with the PLAY API, you will need to be authenticated. This will allow you to store and retrieve additional user data in the PLAY ecosystem.

Guest Login/Logout

If the Auto Guest Login option in RGNUnityInitilizer.cs is checked, logging out from email will automatically sign you back in as guest.

Subscribe Authentication Changed event

using RGN;
using RGN.Modules.SignIn;
using UnityEngine;

public class AuthenticationChangedController : MonoBehaviour
{
    private void OnEnable()
    {
        RGNCore.I.AuthenticationChanged += OnAuthenticationChangedAsync;
    }
    private void OnDisable()
    {
        RGNCore.I.AuthenticationChanged -= OnAuthenticationChangedAsync;
    }

    private async void OnAuthenticationChangedAsync(AuthState authState)
    {
        switch (authState.LoginState)
        {
            case EnumLoginState.Success:
                Debug.Log("User is logged in");
                // You can start retrieving some data here
                break;
            case EnumLoginState.NotLoggedIn:
                Debug.Log("User is not logged in");
                break;
            case EnumLoginState.Error:
                Debug.LogError("On Auth error: " + authState.LoginState +
                    ", error: " + authState.LoginResult);
                break;
            default:
                Debug.LogError("Unhandled Login State: " + authState.LoginState);
                break;
        }
    }
}

Email Login/Logout

using RGN.Modules.SignIn;

public class EmailLoginLogout : MonoBehaviour
{
    public void EmailSignIn()
    {
        // This call will open a web form
        // Handle the result in RGNCore.I.AuthenticationChanged event callback
        EmailSignInModule.I.TryToSignIn();
    }
    public void EmailSignOut()
    {
        EmailSignInModule.I.SignOut();
    }
}

Introduction

Virtual items are game items, that can be purchased using game currency or can be rewarded as completing an . The Virtual item can also be minted an turn into NFT through the.

For example, a virtual item can be:

• Racing Game: It can be different types of cars.

• Puzzle game: It can be a bunch of hints pack.

• Match-3 game: There can be different types of power-ups.

• Shooting Game: Different types of guns, ammo etc

Virtual Items can be added using the . In order to retrieve your list of virtual items you can use the following API.

Introduction

After the user purchases a Virtual Item, it is automatically added to the user's Inventory during the transaction process. It is possible also to add a virtual item to the user's inventory without going through the purchase process for non-NFT items.

Retrieving inventory items with Virtual Items data

The following method gets all inventory items for the currently logged in player.

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.Inventory;

public class InventoryExamples : MonoBehaviour
{
    private async void GetUserInventory()
    {
        List<InventoryItemData> inventory = await InventoryModule.I.GetWithVirtualItemsDataForCurrentAppAsync();
        foreach (var inventoryItem in inventory)
        {
            Debug.Log($"Virtual item id : {inventoryItem.virtualItemId}");
            Debug.Log($"Virtual item name : {inventoryItem.virtualItem.name}");
        }
    }
}

Add to inventory

Add to inventory can be use to add regular virtual items into the player inventory. NFT's cannot be added to the inventory with this function.

using UnityEngine;
using RGN.Modules.Inventory;

public class InventoryExamples : MonoBehaviour
{
    private async void AddToUserInventory()
    {
        string virtualItemId = "virtualItemToAdd";
        await InventoryModule.I.AddToInventoryAsync(virtualItemId);
    }
}

Set Properties

using UnityEngine;
using RGN.Modules.Inventory;

public struct MyCustomProperties
{
    public int BonusHealth;
    public float DamageMultiplier;
}

public class InventoryExamples : MonoBehaviour
{
    private async void SetPropertiesInInventory()
    {
        string inventoryItemId = "inventoryItemId";

        MyCustomProperties customProperties = new MyCustomProperties
        {
            BonusHealth = 50,
            DamageMultiplier = 1.5f
        };
        string jsonProperties = JsonUtility.ToJson(customProperties);

        await InventoryModule.I.SetPropertiesAsync(inventoryItemId, jsonProperties);
    }
}

Get properties

using UnityEngine;
using RGN.Modules.Inventory;

public struct MyCustomProperties
{
    public int BonusHealth;
    public float DamageMultiplier;
}

public class InventoryExamples : MonoBehaviour
{
    private async void GetPropertiesInInventory()
    {
        string inventoryItemId = "inventoryItemId";
        string jsonProperties = await InventoryModule.I.GetPropertiesAsync(inventoryItemId);
        MyCustomProperties customProperties = JsonUtility.FromJson<MyCustomProperties>(jsonProperties);
        Debug.Log($"Bonus health : {customProperties.BonusHealth} \n" +
            $"Damage multiplier : {customProperties.DamageMultiplier}");
    }
}

Introduction

Virtual items are game items, that can be purchased using game currency or can be rewarded as completing an Achievements. The Virtual item can also be minted an turn into NFT through the PLAY Dev Dashboard.

For example, a virtual item can be:

• Racing Game: It can be different types of cars.

• Puzzle game: It can be a bunch of hints pack.

• Match-3 game: There can be different types of power-ups.

• Shooting Game: Different types of guns, ammo etc

Virtual Items can be created using the PLAY Dev Dashboard.

Virtual item class methods

• IsNFT();

  • Return a bool to let you know if the virtual item is an NFT or not.

• GetRGNCoinPrice();

  • Return the price in rgn-coin if the item is an NFT.

• GetCustomCoinPrice(string currencyName);

  • Return the price based on your custom currency setup in the virtual item.

Get All Virtual Items for current app

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.VirtualItems;

public class VirtualItemExamples : MonoBehaviour
{
    public async void GetAllVirtualItem()
    {
        List<VirtualItem> virtualItems = await VirtualItemsModule.I.GetVirtualItemsAsync();
        foreach (var virtualItem in virtualItems)
        {
            Debug.Log($"Virtual item id : {virtualItem.id} \n" +
                $"virtual item name : {virtualItem.name}");
            // etc
        }
    }
}

Get with pagination

There is also a method overload for pagination requests. The pagination means you request not all items at once for the project. In this example every request contains 5 items. Each time you call the method, 5 more items will be loaded and added to the loaded item list.

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.VirtualItems;

public class VirtualItemExamples : MonoBehaviour
{
    private List<VirtualItem> allLoadedItems = new List<VirtualItem>();
    private VirtualItem lastLoadedItem = null;

    public async void GetVirtualItemsPaginationAsync()
    {
        List<VirtualItem> virtualItems = new List<VirtualItem>();
        if (allLoadedItems.Count > 0)
        {
            lastLoadedItem = allLoadedItems[allLoadedItems.Count - 1];
            virtualItems = await VirtualItemsModule.I.GetVirtualItemsAsync(5, lastLoadedItem.id); // Get 5 more items
        }
        else
        {
            virtualItems = await VirtualItemsModule.I.GetVirtualItemsAsync(5, ""); // Get 5 first items
        }
        allLoadedItems.AddRange(virtualItems);
        Debug.Log(allLoadedItems.Count);
    }
}

Different ways to retrieve virtual items :

Get by tags

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.VirtualItems;

public class VirtualItemExamples : MonoBehaviour
{
    public async void GetVirtualItemsAsync()
    {
        List<string> tags = new List<string> { "guns", "rifles" };
        List<VirtualItem> virtualItems = await VirtualItemsModule.I.GetByTagsAsync(tags);
    }
}

Get by ids

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.VirtualItems;

public class VirtualItemExamples : MonoBehaviour
{
    public async void GetByIdsAsync()
    {
        List<string> ids = new List<string> { "item_one_id", "item_two_id" };
        List<VirtualItem> virtualItems = await VirtualItemsModule.I.GetVirtualItemsByIdsAsync(ids);
    }
}

Updating Virtual Items data

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.VirtualItems;

public class VirtualItemExamples : MonoBehaviour
{
    public async void UpdateVirtualItemInfosAsync()
    {
        string virtualItemId = "some_virtual_item";
        await VirtualItemsModule.I.SetNameAsync(virtualItemId, "New Virtual Item Name");
        await VirtualItemsModule.I.SetDescriptionAsync(virtualItemId, "New Virtual Item Description");

        List<string> newTags = new List<string> { "tag01", "tag02" };
        await VirtualItemsModule.I.SetTagsAsync(virtualItemId, newTags);
    }
}

Storing and getting custom json data :

It is possible the store and retrieve custom properties json string associated with virtual item. The json string should be UTF8 formatted string not longer than 100k characters.

using UnityEngine;
using RGN.Modules.VirtualItems;

[System.Serializable]
public struct MyCustomVirtualItemData
{
    public int MyInt;
    public string MyString;
    public float MyFloat;
}

public class VirtualItemExamples : MonoBehaviour
{
    public async void UpdatePropertiesAsync()
    {
        string virtualItemId = "some_virtual_item";

        var myCustomData = new MyCustomVirtualItemData()
        {
            MyFloat = 42.78f,
            MyInt = 51,
            MyString = "Hello World"
        };
        string propertiesJson = JsonUtility.ToJson(myCustomData);
        await VirtualItemsModule.I.SetPropertiesAsync(virtualItemId, propertiesJson);
    }

    public async void GetPropertiesAsync()
    {
        string virtualItemId = "some_virtual_item";

        var jsonProperties = await VirtualItemsModule.I.GetPropertiesAsync(virtualItemId);
        MyCustomVirtualItemData myCustomData = JsonUtility.FromJson<MyCustomVirtualItemData>(jsonProperties);

        Debug.Log(myCustomData.MyString);
    }
}

Updating and downloading the virtual item image :

using UnityEngine;
using RGN.Modules.VirtualItems;

public class VirtualItemExamples : MonoBehaviour
{
    public async void UpdateVirtualItemImageAsync(string virtualItemId, Texture2D virtualItemImage)
    {
        byte[] bytes = virtualItemImage.EncodeToPNG();
        await VirtualItemsModule.I.UploadImageAsync(virtualItemId,bytes);
    }
}

To download virtual item image you can use following code:

using UnityEngine;
using RGN.Modules.VirtualItems;
using RGN.Model;
using System.Threading.Tasks;

public class VirtualItemExamples : MonoBehaviour
{
    public async Task<Texture2D> DownloadVirtualItemImageAsync(string virtualItemId)
    {
        byte[] bytes = await VirtualItemsModule.I.DownloadImageAsync(virtualItemId, ImageSize.Small);
        Texture2D resultTexture = new Texture2D(1, 1);
        resultTexture.LoadImage(bytes);
        resultTexture.Apply();
        return resultTexture;
    }
}

Buy virtual items

To buy virtual items, please refer to the Store Module.

Introduction

Virtual items are game items, that can be purchased using game currency or can be rewarded as completing an Achievements. The Virtual item can also be minted an turn into NFT through the PLAY Dev Dashboard.

For example, a virtual item can be:

• Racing Game: It can be different types of cars.

• Puzzle game: It can be a bunch of hints pack.

• Match-3 game: There can be different types of power-ups.

• Shooting Game: Different types of guns, ammo etc

Virtual Items can be created using the PLAY Dev Dashboard.

Get Virtual Items

Get Virtual Items with pagination

Get Virtual Items by tags

Get Virtual Items by ids

Set Virtual Item properties

Get Virtual Item properties

Download Virtual Item image

Introduction

After the user purchases a Virtual Item, it is automatically added to the user's Inventory during the transaction process. It is possible also to add a virtual item to the user's inventory without going through the purchase process for non-NFT items.

Get inventory items

Add to inventory

Add to inventory can be use to add regular virtual items into the player inventory. NFT's cannot be added to the inventory with this functionality.

Get inventory item properties

Set inventory item properties

Introduction

The users can buy Virtual Items either individually or in packs. After a virtual item is purchased it will be added to the user's inventory. You can use the to create new store offers and virtual items.

Each store offer can contain one or more virtual items to sell. Price info data is also part of the store offer. It is also possible to sell virtual items without creating store offers.

Get Store Offers

Buy Virtual Items and Store offers

Introduction

The users can buy Virtual Items either individually or in packs. After a virtual item is purchased it will be added to the user's inventory. You can use the to create new store offers and virtual items.

Each store offer can contain one or more virtual items to sell. Price info data is also part of the store offer. It is also possible to sell virtual items without creating store offers.

Buy Virtual Items and Store offers

In case the virtual item contains prices information

Purchase from store offer

Get store offer

Buy Virtual Items NFT

In order to purchase NFTs, there is some additional check you will need to do to make sure the user has all the requirements. Here's an example:

Introduction

The user profile module is used to store user specific data related to his identity.

UserProfileData class methods

• GetRGNCoinBalance();

  • Return the amount of rgn-coin for this user.

• GetCustomCoinBalance(string currencyName);

  • Return the amount of your custom currency for this user.

Load User Profile

Update UserName/Display Name

Update User Bio

Retrieve User Currencies

"rgn-coin" Currency

Coming soon

Introduction

Every project may have multiple custom currencies. For example "diamonds" and/or "cash". Aside from these typical game currencies, projects wishing to sell NFTs must integrate a specific currency. The internal name for this currency is "rgn-coin". When the "rgn-coin" is presented in the UI it can have any currency name, for example, "gems".

The "rgn-coin" can only be sold using in-app purchases. For more information, please refer to the Currency GDG.

Other typical currencies can be added and used in an expected manner - as rewards to the user's account, or sold for in-app purchases.

Purchase rgn-coin (IAP required)

Purchasing rgn-coin works a bit differently, it has its own API called PurchaseRGNCoinAsync(string iapUUID)

We recommend using the latest version of the Unity IAP plugin.

You will need to get the transactionId and receipt from the PurchaseEventArgs when the in app purchase is completed.

"uid": "4a13bcd3-ff64-43a4-8c13-e978d968f68c",
"priceInUSD": 0.99,
"quantity": 10

"uid": "0eeae85c-c9af-47f0-8df4-56a4442c23d7",
"priceInUSD": 1.99,
"quantity": 20

"uid": "9d2ed68b-2a6c-45d4-bc07-29f256799943",
"priceInUSD": 2.99,
"quantity": 30

"uid": "b7bcbbf6-753d-47dd-8bff-93b4539c825d",
"priceInUSD": 4.99,
"quantity": 50

"uid": "b81e8e95-59a6-4a77-b1bc-f5b7d6eacfa4",
"priceInUSD": 9.99,
"quantity": 110

"uid": "f35c4f83-cf22-4723-828a-66e8069614eb",
"priceInUSD": 24.99,
"quantity": 300

"uid": "3c814835-9f6f-4947-98f0-6e70964b887d",
"priceInUSD": 39.99,
"quantity": 500

"uid": "b65994dc-ecfd-4549-ab32-51e196947c8b",
"priceInUSD": 69.99,
"quantity": 1000

Add rgn-coin to user

using UnityEngine;
using RGN.Modules.Currency;
using UnityEngine.Purchasing;

public class CurrenciesExamples : MonoBehaviour
{
    public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs purchaseEvent)
    {
        bool validPurchase = true; // Presume valid for platforms with no R.V.

        if (validPurchase)
        {
            Debug.Log($"Product {purchaseEvent.purchasedProduct.definition.id} Purchased");
            string transactionId = purchaseEvent.purchasedProduct.transactionID;
            string receipt = purchaseEvent.purchasedProduct.receipt;
            
            PurchaseRGNCoinAsync(transactionId, receipt);
        }
        else
        {
            Debug.LogError($"Something happened when trying to purchase product {purchaseEvent.purchasedProduct.definition.id}");
        }

        return PurchaseProcessingResult.Complete;
    }

    public async void PurchaseRGNCoinAsync(string transactionId, string receipt)
    {
        string rgnProductId = "4a13bcd3-ff64-43a4-8c13-e978d968f68c"; // 10 rgn-coin
        await CurrencyModule.I.PurchaseRGNCoinAsync(rgnProductId, transactionId, receipt);
    }
}

Get user rgn-coin

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.Currency;

public class CurrenciesExamples : MonoBehaviour
{
    public async void GetRgnCoinCurrenciesAsync()
    {
        List<Currency> currencies = await CurrencyModule.I.GetUserCurrenciesAsync();
        Currency readyCurrency = currencies.Find(x => x.name.Equals("rgn-coin"));
        Debug.Log($"User has {readyCurrency.quantity} rgn-coin");
    }
}

Custom currencies

Add soft currencies to user

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.Currency;

public class CurrenciesExamples : MonoBehaviour
{
    public async void AddSoftCurrenciesAsync()
    {
        Currency goldCurrency = new Currency
        {
            name = "gold",
            quantity = 10
        };
        List<Currency> currenciesToAdd = new List<Currency> { goldCurrency };
        await CurrencyModule.I.AddUserCurrenciesAsync(currenciesToAdd);
    }
}

Get user soft currencies

using System.Collections.Generic;
using UnityEngine;
using RGN.Modules.Currency;

public class CurrenciesExamples : MonoBehaviour
{
    public async void GetSoftCurrenciesAsync()
    {
        List<Currency> currencies = await CurrencyModule.I.GetUserCurrenciesAsync();
        Currency goldCurrency = currencies.Find(x => x.name.Equals("gold"));
        Debug.Log($"User has {goldCurrency.quantity} gold");
    }
}

The AchievementsModule allows to give the user different rewards for making progress. The first things you'll need to decide are when you want to reward the user and what should be given as a reward.

Currently, the achievements support 3 types of user rewards:

1. Virtual Items rewards - the virtual items are added to the user's inventory

2. Currency Coins rewards - the currency coins are added to the user's data. It is not possible to give the "rgn-coin" as a currency reward here.

3. Progression rewards - If you want to track user progress. You can use custom progression data types and store those in the user's data. When the achievement is completed and the progression rewards are given, it will increment the user's progression values accordingly. The progression values should be numbers. To retrieve the progression data you need to use the GameProgressModule:GetUserProgressionDataAsync() method.

You can create new achievements by using the developer dashboard or by reaching out to the PLAY team.

Introduction

Achievements can be used to reward the player following some specific actions in your game. He can be rewarded with currencies, virtual items, progression or leaderboard score.

Get game achievements

using UnityEngine;
using RGN.Modules.Achievement;
using System.Collections.Generic;

public class AchievementExamples : MonoBehaviour
{
    private async void GetAllGameAchievements()
    {
        // Retrieves the 10 first achievements setup for my game
        List<AchievementData> achievements = await AchievementsModule.I.GetForCurrentAppAsync(10);
        foreach (var achievement in achievements)
        {
            Debug.Log($"Achievement name : {achievement.name} \n" +
                $"Description : {achievement.description}");
        }
    }
}

Get user achievements

This function returns the completed and on going achievements for the user.

using UnityEngine;
using RGN.Modules.Achievement;
using System.Collections.Generic;

public class AchievementExamples : MonoBehaviour
{
    private async void GetUserAchievementsAsync()
    {
        List<AchievementWithUserData> achievements = await AchievementsModule.I.GetForCurrentAppWithUserDataAsync(10);
        foreach (var achievement in achievements)
        {
            UserAchievement userAchievement = achievement.GetUserAchievement();
            Debug.Log($"Achievement name : {achievement.name} \n" +
                $"Achievement progression : {userAchievement.value}/{achievement.valueToReach}");
        }
    }
}

Trigger achievement by id

using UnityEngine;
using RGN.Modules.Achievement;

public class AchievementExamples : MonoBehaviour
{
    private async void CompleteAchievementAsync()
    {
        await AchievementsModule.I.TriggerByIdAsync("myAchievementId");
        // This will increase the achievement progression by 1
        // An additionnal parameter can be passed to increase the progress amount
    }
}

Trigger achievement by request name

The request name can be set in the developer dashboard when creating the achievement.

using UnityEngine;
using RGN.Modules.Achievement;

public class AchievementExamples : MonoBehaviour
{
    private async void CompleteAchievementAsync()
    {
        await AchievementsModule.I.TriggerByRequestNameAsync("myRequestName");
        // This will increase the achievement progression by 1
        // An additionnal parameter can be passed to increase the progress amount
    }
}

Claim achievement by id

If the achievement is not set to be automatically claimed when completed, you can claim it in game to show to the player the rewards he received.

using UnityEngine;
using RGN.Modules.Achievement;
using System.Collections.Generic;

public class AchievementExamples : MonoBehaviour
{
    private async void ClaimAchievementAsync()
    {
        var result = await AchievementsModule.I.ClaimByIdAsync("achievementId");
        List<AchievementReward> rewards = result.rewards;
        foreach (var reward in rewards)
        {
            Debug.Log($"Reward name : {reward.name} \n" +
                $"Reward type : {reward.type} \n" +
                $"Reward quantity : {reward.quantity}");
        }
    }
}

Claim achievement by request name

If the achievement is not set to be automatically claimed when completed, you can claim it in game to show to the player the rewards he received.

The request name can be set in the developer dashboard when creating the achievement.

using UnityEngine;
using RGN.Modules.Achievement;
using System.Collections.Generic;

public class AchievementExamples : MonoBehaviour
{
    private async void ClaimAchievementAsync()
    {
        var result = await AchievementsModule.I.ClaimByRequestNameAsync("myRequestName");
        List<AchievementReward> rewards = result.rewards;
        foreach (var reward in rewards)
        {
            Debug.Log($"Reward name : {reward.name} \n" +
                $"Reward type : {reward.type} \n" +
                $"Reward quantity : {reward.quantity}");
        }
    }
}

Coming soon

The LeaderboardModule is responsible for managing player scores and ranking players according to their scores. This module provides various functionalities such as setting player score, getting leaderboard data, fetching player entries on the leaderboard and more.

Introduction

Every project may have multiple custom currencies. For example "diamonds" and/or "cash". Aside from these typical game currencies, projects wishing to sell NFTs must integrate a specific currency. The internal name for this currency is "rgn-coin". When the "rgn-coin" is presented in the UI it can have any currency name, for example, "gems".

The "rgn-coin" can only be sold using in-app purchases. For more information, please refer to the Currency GDG.

Other typical currencies can be added and used in an expected manner - as rewards to the user's account, or sold for in-app purchases.

Purchase rgn-coin (IAP required)

Purchasing rgn-coin works a bit differently, it has its own API called PurchaseRGNCoinAsync(string iapUUID)

You will need to get the transactionId and receipt when the in app purchase is completed.

"uid": "4a13bcd3-ff64-43a4-8c13-e978d968f68c",
"priceInUSD": 0.99,
"quantity": 10

"uid": "0eeae85c-c9af-47f0-8df4-56a4442c23d7",
"priceInUSD": 1.99,
"quantity": 20

"uid": "9d2ed68b-2a6c-45d4-bc07-29f256799943",
"priceInUSD": 2.99,
"quantity": 30

"uid": "b7bcbbf6-753d-47dd-8bff-93b4539c825d",
"priceInUSD": 4.99,
"quantity": 50

"uid": "b81e8e95-59a6-4a77-b1bc-f5b7d6eacfa4",
"priceInUSD": 9.99,
"quantity": 110

"uid": "f35c4f83-cf22-4723-828a-66e8069614eb",
"priceInUSD": 24.99,
"quantity": 300

"uid": "3c814835-9f6f-4947-98f0-6e70964b887d",
"priceInUSD": 39.99,
"quantity": 500

"uid": "b65994dc-ecfd-4549-ab32-51e196947c8b",
"priceInUSD": 69.99,
"quantity": 1000

Get user rgn-coin quantity

Add rgn-coin to user

Custom currency

Get user custom currency quantity

Add custom currency to user

Introduction

In the Game Progress module, you will be able to store game specific data related to the user progression.

Set Custom User Data

Get Custom User Data

Introduction

In the Game Progress module, you will be able to store game specific data related to the user progression.

Set Custom User Data

You can store your custom serialized classes in our database:

Get Custom User Data

You can get your custom serialized classes in our database: