SDKs de nível empresarial para Unity / Integre o SDK no lado do aplicativo
  Voltar aos Documentos

SDKs de nível empresarial para Unity

Integre o SDK no lado do aplicativo

  1. Projete uma interface para o sistema de login, a loja do jogo e outras páginas para o seu aplicativo.
  2. Implemente na lógica do seu aplicativo a autenticação de usuários, a exibição da loja, compras e muito mais usando os métodos SDK.
Observação
Você pode criar sua própria solução seguindo as instruções Unity, ou usar a cena de demonstração como um modelo. Para adaptar a interface da cena de demonstração ao seu aplicativo, use o UI Builder.
Para começar a usar os recursos básicos do SDK, siga esses tutoriais passo a passo:Você pode encontrar os scripts utilizados no diretório Assets/Xsolla/Samples do SDK.

Login de usuário via nome de usuário/e-mail e senha

Esta instrução mostra como usar métodos SDK para implementar:

  • cadastro de usuários
  • reenvio de solicitações de e-mails de confirmação de cadastro
  • login de usuários
  • redefinição de senha de usuários

Você pode autenticar usuários com seu nome de usuário ou endereço de e-mail. Nos exemplos a seguir, autenticamos os usuários com seu nome de usuário, enquanto o endereço de e-mail é usado para confirmar o cadastro e redefinir a senha.

Observação
Se você usar o widget de Login em seu site (em uma loja da web, por exemplo), certifique-se de ter implementado os mesmos métodos de autenticação de usuário no seu site e aplicativo. O widget usa o endereço de e-mail para autenticação por padrão. Para configurar o login do usuário via nome de usuário, entre em contato com seu Gerente de Sucesso do Cliente ou envie um e-mail para csm@xsolla.com.
As lógicas e a interface nos exemplos são menos complicadas do que serão em seu aplicativo. Pode-se encontrar uma possível opção para implementar o sistema de autenticação no projeto de demonstração.

Implemente o cadastro de usuários

Esse tutorial descreve a implementação da seguinte lógica:

Crie uma interface de página

Crie uma cena para uma página de cadastro e adicione os seguintes elementos nela:

  • campo de nome do usuário
  • campo de endereço de e-mail do usuário
  • campo de senha do usuário
  • botão para cadastrar

A imagem a seguir mostra o exemplo de uma estrutura de página.

Crie um controlador de página

  1. Crie um script RegistrationPage herdado da classe base MonoBehaviour.
  2. Declare variáveis para os elementos da interface da página e defina valores para eles no painel Inspector.
  3. Adicione a lógica ao processo clicando no botão de cadastro, como demonstrado no exemplo de script.
Observação

Nos exemplos do script, os métodos OnSuccess e OnError chamam o método padrão Debug.Log. Em caso de erro, o código de erro e a descrição são passados no parâmetro error.

Você pode adicionar outras ações, como abrir uma página com uma solicitação de reenvio para um e-mail de cadastro ou abrir uma página de login se o cadastro for bem-sucedido.

Exemplo de um script para uma página de cadastro:
Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
	public class RegistrationPage : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public InputField UsernameInput;
		public InputField EmailInputField;
		public InputField PasswordInputField;
		public Button RegisterButton;

		private void Start()
		{
			// Handling the button click
			RegisterButton.onClick.AddListener(() =>
			{
				// Get the username, email and password from input fields
				var username = UsernameInput.text;
				var email = EmailInputField.text;
				var password = PasswordInputField.text;

				// Call the user registration method
				// Pass credentials and callback functions for success and error cases
				XsollaAuth.Register(username, password, email, OnSuccess, OnError);
			});
		}

		private void OnSuccess(LoginLink loginLink)
		{
			Debug.Log("Registration successful");
			// Add actions taken in case of success
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Registration failed. Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

Configure o email de confirmação de cadastro

Após o cadastro bem-sucedido, um usuário recebe um e-mail de confirmação de cadastro no endereço especificado. Você pode personalizar os e-mails enviados aos usuários na Conta de Distribuidor.

Se você estiver desenvolvendo um aplicativo Android, configure links profundos para retornar um usuário a um aplicativo depois que ele confirmar o cadastro.

Observação
Você pode desativar a confirmação de cadastro por meio de um endereço de e-mail se seus padrões de segurança permitirem que você faça isso. Entre em contato com seu Gerente de Sucesso do Cliente para desativá-lo ou entre em contato conosco em csm@xsolla.com.

Implemente a solicitação de reenvio de e-mail de confirmação de cadastro

Esse tutorial descreve a implementação da seguinte lógica:

Crie uma interface de página

Crie uma cena para uma página com uma solicitação para reenviar um e-mail de confirmação e adicione os seguintes elementos a ela:

  • campo de nome de usuário/e-mail
  • botão para reenviar o e-mail

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie um script ResendConfirmationEmail herdado da classe base MonoBehaviour.
  2. Declare variáveis para os elementos da interface da página e defina valores para eles no painel Inspector.
  3. Adicione a lógica ao processo clicando no botão de reenvio de e-mail, como demonstrado no exemplo de script.

Exemplo de um script para uma página de reenvio de e-mail:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
	public class ResendConfirmationEmailPage : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public InputField UsernameInput;
		public Button ResendEmailButton;

		private void Start()
		{
			// Handling the button click
			ResendEmailButton.onClick.AddListener(() =>
			{
				// Get the username from the input field
				var username = UsernameInput.text;

				// Call the resend confirmation email method
				// Pass the username and callback functions for success and error cases
				XsollaAuth.ResendConfirmationLink(username, OnSuccess, OnError);
			});
		}

		private void OnSuccess()
		{
			Debug.Log("Resend confirmation email successful");
			// Add actions taken in case of success
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Resend confirmation email failed. Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

Se a solicitação for bem-sucedida, o usuário receberá um e-mail de confirmação de cadastro no endereço de e-mail especificado durante o cadastro.

Implemente o login do usuário

Esse tutorial descreve a implementação da seguinte lógica:

Crie uma interface de página

Crie uma cena para uma página de login e adicione os seguintes elementos a ela:

  • campo de nome de usuário
  • campo de senha
  • caixa de seleção para lembrar dedos
  • botão de login

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie um script AutorizationPage herdado da classe base MonoBehaviour.
  2. Declare variáveis para os elementos da interface da página e defina valores para eles no painel Inspector.
  3. Adicione a lógica ao processo clicando no botão de login, como demonstrado no exemplo de script.

Exemplo de script para uma página de login:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
	public class AuthorizationPage : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public InputField UsernameInput;
		public InputField PasswordInputField;
		public Button SignInButton;

		private void Start()
		{
			// Handling the button click
			SignInButton.onClick.AddListener(() =>
			{
				// Get the username and password from input fields
				var username = UsernameInput.text;
				var password = PasswordInputField.text;

				// Call the user authorization method
				// Pass credentials and callback functions for success and error cases
				XsollaAuth.SignIn(username, password, OnSuccess, OnError);
			});
		}

		private void OnSuccess()
		{
			Debug.Log("Authorization successful");
			// Add actions taken in case of success
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Authorization failed. Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

Implemente um sistema de redefinição de senha

Esse tutorial descreve a implementação da seguinte lógica:

Crie uma interface de página

Crie uma cena para uma página de redefinição de senha e adicione os seguintes elementos a uma página:

  • campo de nome do usuário/e-mail
  • botão para redefinir a senha

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie um script ResetPasswordPage herdado da classe base MonoBehaviour.
  2. Declare variáveis para os elementos da interface da página e defina valores para eles no painel Inspector.
  3. Adicione a lógica ao processo clicando no botão de redefinição de senha, como demonstrado no exemplo de script.

Exemplo de um script para uma página de redefinição de senha:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
	public class ResetPasswordPage : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public InputField UsernameInput;
		public Button ResetPasswordButton;

		private void Start()
		{
			// Handling the button click
			ResetPasswordButton.onClick.AddListener(() =>
			{
				// Get the username from the input field
				var username = UsernameInput.text;

				// Call the password reset method
				// Pass the username and callback functions for success and error cases
				XsollaAuth.ResetPassword(username, OnSuccess, OnError);
			});
		}

		private void OnSuccess()
		{
			Debug.Log("Password reset successful");
			// Add actions taken in case of success
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Password reset failed. Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

Após uma solicitação de redefinição de senha bem-sucedida, o usuário recebe um e-mail com um link de redefinição de senha. Na Conta de Distribuidor > seu projeto de login > Security > OAuth 2.0 > OAuth 2.0 redirect URIs, você pode configurar um endereço URL ou um caminho para o qual o usuário é redirecionado após a autenticação bem-sucedida, confirmação de email ou redefinição de senha.

Login social

Esse guia mostra como você pode usar métodos SDK para implementar o cadastro e o login do usuário por meio de contas de redes sociais.

Diferentemente da autenticação de usuário via nome de usuário/endereço de e-mail e senha, você não precisa implementar lógicas separadas para o cadastro do usuário. Se o primeiro login do usuário for por meio de uma rede social, uma nova conta será criada automaticamente.

Se você tiver implementado o login social em seu aplicativo como um método de autenticação alternativo, a conta da rede social será vinculada automaticamente a uma conta de usuário existente se as seguintes condições forem atendidas:

  • Um usuário que se cadastrou com nome de usuário/endereço de e-mail e senha acessou seu aplicativo por meio de uma conta de rede social.
  • Uma rede social retorna um endereço de e-mail.
  • O endereço de e-mail do usuário em uma rede social é o mesmo que o endereço de e-mail usado para se cadastrar em seu aplicativo.
Observação
Você pode implementar a vinculação manual de uma conta de rede social. Adicione a página ao seu aplicativo onde os usuários podem vincular uma conta de rede social à conta deles. No controlador de página, use o método SDK LinkSocialProvider.
Esse tutorial descreve a implementação da seguinte lógica:

Os exemplos mostram como configurar o login do usuário por meio de uma conta do Facebook. Você pode configurar todas as redes sociais da mesma maneira.

As lógicas e a interface nos exemplos são menos complicadas do que serão em seu aplicativo. Pode-se encontrar uma possível opção para implementar o sistema de autenticação no projeto de demonstração.

Crie uma interface de página

Crie uma cena para uma página de login e adicione o botão de login social a ela. A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie um script SocialAuthorizationPage herdado da classe base MonoBehaviour.
  2. Declare as variáveis para os elementos da interface da página de login do aplicativo e defina valores para eles no painel Inspector.
  3. Adicione a lógica ao processo clicando no botão de login, como demonstrado no exemplo de script.
Observação

Nos exemplos do script, os métodos OnSuccess e OnError chamam o método padrão Debug.Log. Você pode adicionar outras ações.

Em caso de erro, o código de erro e a descrição são passados no parâmetro error.

Exemplo de script para uma página de login:
Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
	public class SocialAuthorizationPage : MonoBehaviour
	{
		// Declaration of variables for SocialProvider and signIn button
		public SocialProvider SocialProvider = SocialProvider.Facebook;
		public Button SignInButton;

		private void Start()
		{
			// Handling the button click
			SignInButton.onClick.AddListener(() =>
			{
				// Call the social authorization method
				// Pass the social network provider and callback functions for success, error and cancel cases
				XsollaAuth.AuthViaSocialNetwork(SocialProvider, OnSuccess, OnError, OnCancel);
			});
		}

		private void OnSuccess()
		{
			Debug.Log("Social authorization successful");
			// Add actions taken in case of success
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Social authorization failed. Error: {error.errorMessage}");
			// Add actions taken in case of error
		}

		private void OnCancel()
		{
			Debug.Log("Social authorization cancelled by user.");
			// Add actions taken in case the user canceles authorization
		}
	}
}

Exibição do catálogo de itens

Este tutorial mostra como usar os métodos SDK para exibir os seguintes itens em uma loja no jogo:

  • itens virtuais
  • grupos de itens virtuais
  • conjuntos
  • pacotes de moedas virtuais

Antes de começar, configure itens na Conta de Distribuidor:

  1. Configure itens virtuais e grupos de itens virtuais.
  2. Configure pacotes de moedas virtuais.
  3. Configurar pacotes.

Esse tutorial descreve a implementação da seguinte lógica:

As lógicas e a interface nos exemplos são menos complicadas do que serão em seu aplicativo. Um possível catálogo de itens em uma opção de implementação na loja do jogo é descrita no projeto de demonstração.

Observação

O exemplo de cada item em um catálogo mostra:

  • nome do item
  • descrição do item
  • preço do item
  • imagem

Você também pode mostrar outras informações sobre o item se essas informações estiverem armazenadas em uma loja do jogo.

Implemente a exibição de itens virtuais

Crie um widget de item

  1. Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel Hierarchy para um painel Project.
  3. Selecione um prefab criado e clique em Open Prefab no painel Inspector.
  4. Adicione os seguintes elementos da interface como objetos filho prefab e configure os visuais deles:
    • imagem de plano de fundo do item
    • nome do item
    • descrição do item
    • preço do item
    • imagem do item

A imagem a seguir mostra um exemplo da estrutura do widget.

Crie o script do widget de item

  1. Crie um script VirtualItemWidget herdado da classe base MonoBehaviour.
  2. Declare as variáveis para os elementos da interface do item widget e defina valores para eles no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text DescriptionText;
		public Text PriceText;
		public Image IconImage;
	}
}

Crie uma página para exibir a lista de itens

  1. Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Adicione os seguintes elementos de interface como objetos filhos prefab e configure os visuais deles:
    • imagem de plano de fundo da página
    • área de exibição de widgets de item

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie um script VirtualItemsPage herdado da classe base MonoBehaviour.
  2. Declare as seguintes variáveis:
    • WidgetsContainer — contêiner de widgets
    • WidgetPrefab — widget de item prefab

  1. Anexe um script a um objeto de jogo de página:
    1. Selecione um objeto no painel Hierarchy.
    2. No painel Inspector, clique em Add Component e selecione um script VirtualItemsPage.
  2. Defina os valores para as variáveis no painel Inspector.

  1. Adicione a lógica de login e a lógica para obter a lista de itens, como demonstrado no exemplo de script.
Observação

No exemplo de script para fazer login, usamos as credenciais de uma conta demonstrativa (nome de usuário: xsolla, senha: xsolla).

O exemplo de script não contém a implementação da exibição “página por página” de itens no catálogo (paginação). Use os parâmetros offset e limit do método SDK GetCatalog para implementar a paginação. O limite é de 50 itens por página. Se o catálogo tiver mais de 50 itens, a paginação será necessária.

Exemplo de um script de controlador de página:
Copy
Full screen
Small screen
using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
	public class VirtualItemsPage : MonoBehaviour
	{
		// Declaration of variables for widget's container and prefab
		public Transform WidgetsContainer;
		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// Starting the items request from the store after successful authentication
			XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
		}

		private void OnItemsRequestSuccess(StoreItems storeItems)
		{
			// Iterating the items collection
			foreach (var storeItem in storeItems.items)
			{
				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualItemWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = storeItem.name;
				widget.DescriptionText.text = storeItem.description;

				// The item can be purchased for real money or virtual currency
				// Checking the price type and assigning the values for appropriate UI elements
				if (storeItem.price != null)
				{
					var realMoneyPrice = storeItem.price;
					widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
				}
				else if (storeItem.virtual_prices != null)
				{
					var virtualCurrencyPrice = storeItem.virtual_prices.First(x => x.is_default);
					widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
				}

				// Loading the item image and assigning it to the UI element
				ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

A imagem a seguir mostra o resultado do trabalho do script.

Implemente a exibição de grupos de itens virtuais

Crie um widget de item

  1. Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel Hierarchy para um painel Project.
  3. Selecione um prefab criado e clique em Open Prefab no painel Inspector.
  4. Adicione os seguintes elementos da interface como objetos filho prefab e configure os visuais deles:
    • imagem de plano de fundo do item
    • nome do item
    • descrição do item
    • preço do item
    • imagem do item

A imagem a seguir mostra um exemplo da estrutura do widget.

Crie o script do widget de item

  1. Crie um script VirtualItemWidget herdado da classe base MonoBehaviour.
  2. Declare as variáveis para os elementos da interface do item widget e defina valores para eles no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text DescriptionText;
		public Text PriceText;
		public Image IconImage;
	}
}

Crie um widget para o botão que abre grupos de itens

  1. Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel Hierarchy para um painel Project.
  3. Selecione um prefab criado e clique em Open Prefab no painel Inspector.
  4. Adicione o botão que permite a exibição do grupo de itens como um objeto filho para um prefab e configure seus visuais.

A imagem a seguir mostra um exemplo da estrutura do widget.

Crie um script para o botão que abre grupos de itens

  1. Crie o script VirtualItemGroupButton herdado da classe base MonoBehaviour.
  2. Declare as variáveis para o botão que abre o grupo de itens e defina valores para as variáveis no painel Inspector.
  3. Adicione um script para o objeto raiz de um prefab:
    1. Selecione um objeto no painel Hierarchy.
    2. No painel Inspector, clique em Add Component e selecione um script VirtualItemGroupButton.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
	public class VirtualItemGroupButton : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Button Button;
	}
}

Crie uma página para exibir a lista de itens

  1. Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Adicione os seguintes elementos de interface como objetos filhos prefab e configure os visuais deles:
    • área de exibição de botões de grupos
    • imagem de plano de fundo da página
    • área de exibição de widgets de itens

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie o script VirtualItemsByGroupsPage herdado da classe base MonoBehaviour.
  2. Declare as seguintes variáveis:
    • GroupButtonsContainer — contêiner para botões de grupo
    • GroupButtonPrefab — botão de prefab
    • ItemWidgetsContainer — contêiner para widgets de item
    • WidgetPrefab — widget de item prefab

  1. Anexe um script a um objeto de jogo de página:
    1. Selecione um objeto no painel Hierarchy.
    2. No painel Inspector, clique em Add Component e selecione um script VirtualItemsByGroupsPage.
  2. Defina valores para as variáveis no painel Inspector.
  3. Adicione a lógica de login e a lógica para obter a lista de itens, conforme demonstrado no script de exemplo.
Observação

No exemplo de script para fazer login, usamos as credenciais de uma conta demonstrativa (nome de usuário: xsolla, senha: xsolla).

O exemplo de script não contém a implementação da exibição “página por página” de itens no catálogo (paginação). Use os parâmetros offset e limit do método SDK GetCatalog para implementar a paginação. O limite é de 50 itens por página. Se o catálogo tiver mais de 50 itens, a paginação será necessária.

Exemplo de um script de controlador de página:
Copy
Full screen
Small screen
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
	public class VirtualItemsByGroupsPage : MonoBehaviour
	{
		// Declaration of variables for widget's container and prefab
		public Transform GroupButtonsContainer;
		public GameObject GroupButtonPrefab;
		public Transform ItemWidgetsContainer;
		public GameObject ItemWidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// Starting the items request from the store after successful authentication
			// Pass the callback functions for success and error cases
			XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
		}

		private void OnItemsRequestSuccess(StoreItems storeItems)
		{
			// Selecting the group’s name from items and order them alphabetically
			var groupNames = storeItems.items
				.SelectMany(x => x.groups)
				.GroupBy(x => x.name)
				.Select(x => x.First())
				.OrderBy(x => x.name)
				.Select(x => x.name)
				.ToList();

			// Add group name for catalog category with all items regardless of group affiliation
			groupNames.Insert(0, "All");

			// Iterating the group names collection
			foreach (var groupName in groupNames)
			{
				// Instantiating the button prefab as child of the container
				var buttonGo = Instantiate(GroupButtonPrefab, GroupButtonsContainer, false);
				var groupButton = buttonGo.GetComponent<VirtualItemGroupButton>();

				// Assigning the values for UI elements
				groupButton.NameText.text = groupName;

				// Adding listener for button click event
				groupButton.Button.onClick.AddListener(() => OnGroupSelected(groupName, storeItems));
			}

			// Calling method for redraw page
			OnGroupSelected("All", storeItems);
		}

		private void OnGroupSelected(string groupName, StoreItems storeItems)
		{
			// Clear container
			DeleteAllChildren(ItemWidgetsContainer);

			// Declaring variable for items to be displayed on the page
			IEnumerable<StoreItem> itemsForDisplay;
			if (groupName == "All")
			{
				itemsForDisplay = storeItems.items;
			}
			else
			{
				itemsForDisplay = storeItems.items.Where(item => item.groups.Any(group => group.name == groupName));
			}

			// Iterating the items collection and assigning values for appropriate UI elements
			foreach (var storeItem in itemsForDisplay)
			{
				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(ItemWidgetPrefab, ItemWidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualItemWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = storeItem.name;
				widget.DescriptionText.text = storeItem.description;

				// The item can be purchased for real money or virtual currency
				// Checking the price type and assigning the appropriate value for price text
				if (storeItem.price != null)
				{
					var realMoneyPrice = storeItem.price;
					widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
				}
				else if (storeItem.virtual_prices != null)
				{
					var virtualCurrencyPrice = storeItem.virtual_prices.First(x => x.is_default);
					widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
				}

				// Loading the image for item icon and assigning it to the UI element
				ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			//  Add actions taken in case of error
		}

		// Utility method to delete all children of a container
		private static void DeleteAllChildren(Transform parent)
		{
			var childList = parent.Cast<Transform>().ToList();
			foreach (var childTransform in childList)
			{
				Destroy(childTransform.gameObject);
			}
		}
	}
}

A imagem a seguir mostra o resultado do trabalho do script.

Implemente a exibição de pacotes

Crie um widget de pacote

  1. Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel Hierarchy para um painel Project.
  3. Selecione um prefab criado e clique em Open Prefab no painel Inspector.
  4. Adicione os seguintes elementos da interface como objetos filhos prefab e configure os visuais deles:

    • imagem de plano de fundo de widget
    • nome do pacote
    • descrição do pacote
    • preço do pacote
    • descrição do conteúdo do pacote (itens e suas quantidades)
    • imagem do pacote

A imagem a seguir mostra um exemplo da estrutura do widget.

Crie o script do widget

  1. Crie um script BundleWidget herdado da classe base MonoBehaviour.
  2. Declare as variáveis para os elementos da interface do item widget e defina valores para eles no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
	public class BundleWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text DescriptionText;
		public Text PriceText;
		public Text ContentText;
		public Image IconImage;
	}
}

Crie uma página para mostrar pacotes

  1. Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Adicione os seguintes elementos de interface como objetos filhos prefab e configure os visuais deles:
    • imagem de plano de fundo da página
    • área de exibição de widgets de pacote

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie o script BundlesPage herdado da classe base MonoBehaviour.
  2. Declare as seguintes variáveis:
    • WidgetsContainer — contêiner de widgets
    • WidgetPrefab — widget de pacotes prefab

  1. Anexe um script a um objeto de jogo de página:
    1. Selecione um objeto no painel Hierarchy.
    2. No painel Inspector, clique em Add Component e selecione um script BundlesPage script.

  1. Defina valores para as variáveis no painel Inspector.
  2. Adicione a lógica de login e a lógica para obter a lista de itens, conforme demonstrado no script de exemplo.
Observação

No exemplo de script para fazer login, usamos as credenciais de uma conta demonstrativa (nome de usuário: xsolla, senha: xsolla).

O exemplo de script não contém a implementação da exibição “página por página” de itens no catálogo (paginação). Use os parâmetros offset e limit do método SDK GetCatalog para implementar a paginação. O limite é de 50 itens por página. Se o catálogo tiver mais de 50 itens, a paginação será necessária.

Exemplo de um script de controlador de página:
Copy
Full screen
Small screen
using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
	public class BundlesPage : MonoBehaviour
	{
		// Declaration of variables for widget's container and prefab
		public Transform WidgetsContainer;
		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// Starting the bundle request from the store after successful authentication
			// Pass the callback functions for success and error cases
			XsollaCatalog.GetBundles(OnBundlesRequestSuccess, OnError);
		}

		private void OnBundlesRequestSuccess(BundleItems bundleItems)
		{
			// Iterating the bundles collection
			foreach (var bundleItem in bundleItems.items)
			{
				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<BundleWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = bundleItem.name;
				widget.DescriptionText.text = bundleItem.description;

				// Creating the string with bundle content and assigning it to the UI element
				var bundleContent = bundleItem.content.Select(x => $"{x.name} x {x.quantity}");
				widget.ContentText.text = string.Join("\n", bundleContent);

				// The bundle can be purchased for real money or virtual currency
				// Checking the price type and assigning the values for appropriate UI elements
				if (bundleItem.price != null)
				{
					var realMoneyPrice = bundleItem.price;
					widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
				}
				else if (bundleItem.virtual_prices != null)
				{
					var virtualCurrencyPrice = bundleItem.virtual_prices.First(x => x.is_default);
					widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
				}

				// Loading the bundle image and assigning it to the UI element
				ImageLoader.LoadSprite(bundleItem.image_url, sprite => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

A imagem a seguir mostra o resultado do trabalho do script.

Implemente a exibição de pacotes de moedas virtuais

Crie um widget para um pacote de moedas virtuais

  1. Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel Hierarchy para um painel Project.
  3. Selecione um prefab criado e clique em Open Prefab no painel Inspector.
  4. Adicione os seguintes elementos da interface como objetos filhos prefab e configure os visuais deles:

    • imagem de plano de fundo de widget
    • nome do pacote
    • descrição do pacote
    • preço do pacote
    • imagem do pacote

A imagem a seguir mostra um exemplo da estrutura do widget.

Crie o script do widget

  1. Crie um script VirtualCurrencyPackageWidget herdado da classe base MonoBehaviour.
  2. Declare as variáveis para os elementos da interface do item widget e defina valores para eles no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
	public class VirtualCurrencyPackageWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text DescriptionText;
		public Text PriceText;
		public Image IconImage;
	}
}

Crie uma página para mostrar a lista de pacotes de moedas virtuais

  1. Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Adicione os seguintes elementos de interface como objetos filhos prefab e configure os visuais deles:
    • imagem de plano de fundo da página
    • área de exibição de widgets de pacotes de moedas virtuais

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie o script VirtualCurrencyPackagesPage herdado da classe base MonoBehaviour.
  2. Declare as seguintes variáveis:
    • WidgetsContainer — contêiner de widgets
    • WidgetPrefab — prefab do pacote de moedas virtuais

  1. Anexe um script a um objeto de jogo de página:
    1. Selecione um objeto no painel Hierarchy.
    2. No painel Inspector, clique em Add Component e selecione um script VirtualCurrencyPackagesPage.
  2. Defina valores para as variáveis no painel Inspector.
  3. Adicione a lógica de login e a lógica para obter a lista de pacotes de moedas virtuais, conforme demonstrado no script de exemplo.
Observação

No exemplo de script para fazer login, usamos as credenciais de uma conta demonstrativa (nome de usuário: xsolla, senha: xsolla).

O exemplo de script não contém a implementação da exibição “página por página” de itens no catálogo (paginação). Use os parâmetros offset e limit do método SDK GetCatalog para implementar a paginação. O limite é de 50 itens por página. Se o catálogo tiver mais de 50 itens, a paginação será necessária.

Exemplo de um script de controlador de página:
Copy
Full screen
Small screen
using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
	public class VirtualCurrencyPackagesPage : MonoBehaviour
	{
		// Declaration of variables for widget's container and prefab
		public Transform WidgetsContainer;
		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// After successful authentication starting the request for packages from store
			// Pass the callback functions for success and error cases
			XsollaCatalog.GetVirtualCurrencyPackagesList(OnPackagesRequestSuccess, OnError);
		}

		private void OnPackagesRequestSuccess(VirtualCurrencyPackages packageItems)
		{
			// Iterating the virtual currency packages collection
			foreach (var packageItem in packageItems.items)
			{
				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualCurrencyPackageWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = packageItem.name;
				widget.DescriptionText.text = packageItem.description;

				// The package can be purchased for real money or virtual currency
				// Checking the price type and assigning the values for appropriate UI elements
				if (packageItem.price != null)
				{
					var realMoneyPrice = packageItem.price;
					widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
				}
				else if (packageItem.virtual_prices != null)
				{
					var virtualCurrencyPrice = packageItem.virtual_prices.First(x => x.is_default);
					widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
				}

				// Loading the package image and assigning it to the UI element
				ImageLoader.LoadSprite(packageItem.image_url, sprite => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

A imagem a seguir mostra o resultado do trabalho do script.

Venda itens virtuais por moedas reais

Essa seção explica como usar os métodos SDK para implementar a venda de itens com moedas reais usando itens virtuais.

Antes de começar, implemente uma exibição de itens virtuais em um catálogo. No exemplo a seguir, descrevemos como implementar a compra de itens virtuais. A configuração para outros tipos de item é semelhante.

Esse tutorial descreve a implementação da seguinte lógica:

A lógica e a interface nos exemplos são menos complicadas do que serão em seu aplicativo. Uma possível opção de implementação para vender itens por moedas reais e exibir um catálogo de itens é descrita no projeto de demonstração.

Complete o widget de item

Adicione um botão de compra ao widget de item e configure seus elementos visuais.

A imagem a seguir mostra um exemplo da estrutura do widget.

Complete o script do widget de item

  1. Abra o script VirtualItemWidget.
  2. Declare as variáveis para o botão de compra e defina valores para elas no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.SellForRealMoney
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text DescriptionText;
		public Text PriceText;
		public Image IconImage;
		public Button BuyButton;
	}
}

Complete o controlador de página para mostrar a lista de itens

  1. Abra o script VirtualItemsPage.
  2. Adicione a lógica para processamento clicando no botão de compra do item virtual, conforme demonstrado no script de exemplo.
Observação

No script de exemplo, chamamos o método base Debug.Log se a compra do item for bem-sucedida. Você pode adicionar outras ações, como a exibição de inventário, etc.

Por padrão, a página de pagamento é aberta em um navegador integrado. Para abri-la em um navegador externo, vá para Window > Xsolla > Edit Settings no menu principal do Unity Editor e desmarque a caixa Enable in-app browser? no painel Inspector. Se você usar o navegador externo para aplicativos Android, recomendamos configurar os links profundos para redirecionar o usuário para o aplicativo depois que ele fizer um pagamento.

Exemplo de script para uma página:
Copy
Full screen
Small screen
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.SellForRealMoney
{
	public class VirtualItemsPage : MonoBehaviour
	{
		// Declaration of variables for widget's container and prefab
		public Transform WidgetsContainer;
		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// Starting the items request from the store after successful authentication
			// Pass the callback functions for success and error cases
			XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
		}

		private void OnItemsRequestSuccess(StoreItems storeItems)
		{
			// Iterating the items collection
			foreach (var storeItem in storeItems.items)
			{
				// Skipping items without prices in real money
				if (storeItem.price == null)
					continue;

				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualItemWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = storeItem.name;
				widget.DescriptionText.text = storeItem.description;

				// Assigning the price and currency values for UI elements
				var price = storeItem.price;
				widget.PriceText.text = $"{price.amount} {price.currency}";

				// Loading the item image and assigning it to the UI element
				ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);

				// Assigning the click listener for the buy button
				widget.BuyButton.onClick.AddListener(() =>
				{
					// Starting the purchase process
					// Pass the item SKU and callback functions for success and error cases
					XsollaCatalog.Purchase(storeItem.sku, OnPurchaseSuccess, OnError);
				});
			}
		}

		private void OnPurchaseSuccess(OrderStatus status)
		{
			Debug.Log("Purchase successful");
			// Add actions taken in case of success
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

Venda itens virtuais por moedas virtuais

Essa seção explica como usar os métodos SDK para implementar a venda de itens com moedas virtuais usando itens virtuais.

Antes de começar, implemente uma exibição de itens virtuais em um catálogo. No exemplo a seguir, descrevemos como implementar a compra de itens virtuais. A configuração para outros tipos de item é semelhante.

Esse tutorial descreve a implementação da seguinte lógica:

A lógica e a interface nos exemplos são menos complicadas do que serão em seu aplicativo. Uma possível opção de implementação para vender itens por moedas virtuais e exibir um catálogo de itens é descrita no projeto de demonstração.

Complete o widget de item

Adicione um botão de compra ao widget de item e configure seus elementos visuais.

A imagem a seguir mostra um exemplo da estrutura do widget.

Complete o script do widget de item

  1. Abra o script VirtualItemWidget.
  2. Declare as variáveis para o botão de compra e defina valores para elas no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.SellForVirtualCurrency
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text DescriptionText;
		public Text PriceText;
		public Image IconImage;
		public Button BuyButton;
	}
}

Complete o controlador de página para mostrar a lista de itens

  1. Abra o script VirtualItemsPage.
  2. Adicione a lógica para processamento clicando no botão de compra do item virtual, conforme demonstrado no script de exemplo.
Observação

No script de exemplo, chamamos o método base Debug.Log se a compra do item for bem-sucedida. Você pode adicionar outras ações, como a exibição de inventário, alteração de saldo de moedas virtuais, etc.

A implementação da lógica para adicionar itens comprados ao inventário não é necessária — ela é feita automaticamente.

Exemplo de script para uma página:
Copy
Full screen
Small screen
using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.SellForVirtualCurrency
{
	public class VirtualItemsPage : MonoBehaviour
	{
		// Declaration of variables for containers and widget prefabs
		public Transform WidgetsContainer;
		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// After successful authentication starting the request for catalog from store
			// Pass the callback functions for success and error cases
			XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
		}

		private void OnItemsRequestSuccess(StoreItems storeItems)
		{
			// Iterating the items collection
			foreach (var storeItem in storeItems.items)
			{
				// Skipping items without prices in virtual currency
				if (storeItem.virtual_prices.Length == 0)
					continue;

				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualItemWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = storeItem.name;
				widget.DescriptionText.text = storeItem.description;

				// Assigning the price and currency values for UI elements
				// The first price is used for the sake of simplicity
				var price = storeItem.virtual_prices.First(x => x.is_default);
				widget.PriceText.text = $"{price.name}: {price.amount}";

				// Loading the item image and assigning it to the UI element
				ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);

				// Assigning the click listener for the buy button
				widget.BuyButton.onClick.AddListener(() =>
				{
					// Starting the purchase process
					// Pass the item SKU, the price virtual currency SKU and callback functions for success and error cases
					XsollaCatalog.PurchaseForVirtualCurrency(storeItem.sku, price.sku, OnPurchaseSuccess, OnError);
				});
			}
		}

		private void OnPurchaseSuccess(OrderStatus status)
		{
			Debug.Log("Purchase successful");
			// Add actions taken in case of success
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

Exibição do saldo de moedas virtuais

Esse tutorial mostra como usar os métodos SDK para exibir o saldo da moeda virtual em seu aplicativo.

As lógicas e a interface nos exemplos são menos complicadas do que serão em seu aplicativo. Um possível catálogo de itens em uma opção de implementação na loja do jogo é descrita no projeto de demonstração.

Crie o widget para exibição de saldo

  1. Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel Hierarchy para um painel Project.
  3. Selecione um prefab criado e clique em Open Prefab no painel Inspector.
  4. Adicione os seguintes elementos da interface como objetos filho prefab e configure os visuais deles:
    • imagem de plano de fundo ddo widget
    • nome da moeda virtual
    • quantia da moeda virtual
    • imagem da moeda virtual

A imagem a seguir mostra um exemplo da estrutura do widget.

Crie o script do widget para exibir o saldo

  1. Crie um script VirtualCurrencyWidget herdado da classe base MonoBehaviour.
  2. Declare as variáveis para os elementos da interface do item widget e defina valores para eles no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayVirtualCurrencyBalance
{
	public class VirtualCurrencyWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text AmountText;
		public Image IconImage;
	}
}

Crie uma página com uma lista de moedas virtuais

  1. Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Adicione os seguintes elementos de interface como objetos filhos prefab e configure os visuais deles:
    • imagem de plano de fundo da página
    • área de exibição de widgets

A imagem a seguir mostra um exemplo da estrutura da página.

Crie o controlador para a página com a lista de moedas virtuais

  1. Crie um script VirtualCurrenciesPage herdado da classe base MonoBehaviour.
  2. Declare as seguintes variáveis:
    • WidgetsContainer — contêiner de widgets
    • WidgetPrefab — widget prefab de exibição de saldo

  1. Anexe um script a um objeto de jogo de página:
    1. Selecione um objeto no painel Hierarchy.
    2. No painel Inspector, clique em Add Component e selecione um script VirtualCurrenciesPage.

  1. Defina valores para as variáveis no painel Inspector.
  2. Adicione a lógica de login e a lógica para obter a lista de moedas virtuais, conforme demonstrado no script de exemplo.
Observação
No exemplo de script para fazer login, usamos as credenciais de uma conta demonstrativa (nome de usuário: xsolla, senha: xsolla).
Exemplo de um script de controlador de página:
Copy
Full screen
Small screen
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Core;
using Xsolla.Inventory;

namespace Xsolla.Samples.DisplayVirtualCurrencyBalance
{
	public class VirtualCurrenciesPage : MonoBehaviour
	{
		// Declaration of variables for widget's container and prefab
		public Transform WidgetsContainer;
		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// Starting the virtual currencies request from the store after successful authentication
			// Pass the callback functions for success and error cases
			XsollaInventory.GetVirtualCurrencyBalance(OnBalanceRequestSuccess, OnError);
		}

		private void OnBalanceRequestSuccess(VirtualCurrencyBalances balance)
		{
			// Iterating the virtual currency balances collection
			foreach (var balanceItem in balance.items)
			{
				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualCurrencyWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = balanceItem.name;
				widget.AmountText.text = balanceItem.amount.ToString();

				ImageLoader.LoadSprite(balanceItem.image_url, sprite => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

A imagem a seguir mostra o resultado do trabalho do script.

Exibição de itens no inventário

Esse tutorial mostra como usar os métodos SDK para exibir itens no inventário do usuário.

As lógicas e a interface nos exemplos são menos complicadas do que serão em seu aplicativo. Pode-se encontrar uma possível opção para implementar o inventário no projeto de demonstração.

Crie um widget de item

  1. Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel Hierarchy para um painel Project.
  3. Selecione um prefab criado e clique em Open Prefab no painel Inspector.
  4. Adicione os seguintes elementos da interface como objetos filho prefab e configure os visuais deles:
    • imagem de plano de fundo do item
    • nome do item
    • descrição do item
    • quantidade do item
    • imagem do item

A imagem a seguir mostra um exemplo da estrutura do widget.

Crie o script do widget de item

  1. Crie um script InventoryItemWidget herdado da classe base MonoBehaviour.
  2. Declare as variáveis para os elementos da interface do item widget e defina valores para eles no painel Inspector.

Exemplo do script do widget:

Copy
Full screen
Small screen
using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayItemsInInventory
{
	public class InventoryItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;
		public Text DescriptionText;
		public Text QuantityText;
		public Image IconImage;
	}
}

Crie uma página para mostrar o inventário

  1. Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione GameObject > Create Empty.
  2. Adicione os seguintes elementos de interface como objetos filhos prefab e configure os visuais deles:
    • imagem de plano de fundo da página
    • área de exibição de widgets de item

A imagem a seguir mostra um exemplo da estrutura da página.

Crie um controlador de página

  1. Crie um script InventoryItemsPage herdado da classe base MonoBehaviour.
  2. Declare as seguintes variáveis:
    • WidgetsContainer — contêiner de widgets de item
    • WidgetPrefab — widget de item prefab

  1. Anexe um script a um objeto de jogo de página:
    1. Selecione um objeto no painel Hierarchy.
    2. No painel Inspector, clique em Add Component e selecione um script InventoryItemsPage.

  1. Defina valores para as variáveis no painel Inspector.
  2. Adicione a lógica de login e a lógica para obter a lista de itens no inventário.
Observação
No exemplo de script para fazer login, usamos as credenciais de uma conta demonstrativa (nome de usuário: xsolla, senha: xsolla).
Exemplo de um script de controlador de página:
Copy
Full screen
Small screen
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Core;
using Xsolla.Inventory;

namespace Xsolla.Samples.DisplayItemsInInventory
{
	public class InventoryItemsPage : MonoBehaviour
	{
		// Declaration of variables for widget's container and prefab
		public Transform WidgetsContainer;
		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			// Pass the credentials and callback functions for success and error cases
			// The credentials (username and password) are hard-coded for simplicity
			XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess()
		{
			// Starting the items request from the store after successful authentication
			// Pass the callback functions for success and error cases
			XsollaInventory.GetInventoryItems(OnItemsRequestSuccess, OnError);
		}

		private void OnItemsRequestSuccess(InventoryItems inventoryItems)
		{
			// Iterating the items collection
			foreach (var inventoryItem in inventoryItems.items)
			{
				// Skipping virtual currency items
				if (inventoryItem.VirtualItemType == VirtualItemType.VirtualCurrency)
					continue;

				// Instantiating the widget prefab as child of the container
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<InventoryItemWidget>();

				// Assigning the values for UI elements
				widget.NameText.text = inventoryItem.name;
				widget.DescriptionText.text = inventoryItem.description;
				widget.QuantityText.text = inventoryItem.quantity.ToString();

				// Loading the item image and assigning it to the UI element
				ImageLoader.LoadSprite(inventoryItem.image_url, sprite => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			Debug.LogError($"Error: {error.errorMessage}");
			// Add actions taken in case of error
		}
	}
}

A imagem a seguir mostra o resultado do trabalho do script.

Este artigo foi útil?
Obrigado!
Podemos melhorar alguma coisa? Mensagem
Que pena ouvir isso
Explique porque este artigo não foi útil para você. Mensagem
Obrigado pelo seu feedback!
Avaliaremos sua mensagem e a usaremos para melhorar sua experiência.

Links úteis

Última atualização: 10 de Outubro de 2023

Encontrou um erro de texto ou digitação? Selecione o texto e pressione Ctrl+Enter.

Relatar um problema
Nós sempre avaliamos nossos conteúdos. Seu feedback nos ajuda a melhorá-los.
Forneça um e-mail para que possamos responder
Obrigado pelo seu feedback!