Integre o SDK no lado do aplicativo
- Projete uma interface para o sistema de login, a loja do jogo e outras páginas para o seu aplicativo.
- 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.
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.
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
- Crie um script
RegistrationPage
herdado da classe base MonoBehaviour. - Declare variáveis para os elementos da interface da página e defina valores para eles no painel
Inspector . - Adicione a lógica ao processo clicando no botão de cadastro, como demonstrado no exemplo de script.
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.
- C#
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.
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
- Crie um script
ResendConfirmationEmail
herdado da classe base MonoBehaviour. - Declare variáveis para os elementos da interface da página e defina valores para eles no painel
Inspector . - 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:
- C#
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
- Crie um script
AutorizationPage
herdado da classe base MonoBehaviour. - Declare variáveis para os elementos da interface da página e defina valores para eles no painel
Inspector . - 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:
- C#
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
- Crie um script
ResetPasswordPage
herdado da classe base MonoBehaviour. - Declare variáveis para os elementos da interface da página e defina valores para eles no painel
Inspector . - 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:
- C#
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.
LinkSocialProvider
.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
- Crie um script
SocialAuthorizationPage
herdado da classe base MonoBehaviour. - Declare as variáveis para os elementos da interface da página de login do aplicativo e defina valores para eles no painel
Inspector . - Adicione a lógica ao processo clicando no botão de login, como demonstrado no exemplo de script.
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
.
- C#
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:
- Configure itens virtuais e grupos de itens virtuais.
- Configure pacotes de moedas virtuais.
- 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.
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
- Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel
Hierarchy para um painelProject . - Selecione um prefab criado e clique em
Open Prefab no painelInspector . - 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
- Crie um script
VirtualItemWidget
herdado da classe base MonoBehaviour. - 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:
- C#
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
- Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - 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
- Crie um script
VirtualItemsPage
herdado da classe baseMonoBehaviour
. - Declare as seguintes variáveis:
WidgetsContainer
— contêiner de widgetsWidgetPrefab
— widget de item prefab
- Anexe um script a um objeto de jogo de página:
- Selecione um objeto no painel
Hierarchy . - No painel
Inspector , clique emAdd Component e selecione um scriptVirtualItemsPage
.
- Selecione um objeto no painel
- Defina os valores para as variáveis no painel
Inspector .
- Adicione a lógica de login e a lógica para obter a lista de itens, como demonstrado no exemplo de script.
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.
- C#
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
- Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel
Hierarchy para um painelProject . - Selecione um prefab criado e clique em
Open Prefab no painelInspector . - 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
- Crie um script
VirtualItemWidget
herdado da classe base MonoBehaviour. - 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:
- C#
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
- Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel
Hierarchy para um painelProject . - Selecione um prefab criado e clique em
Open Prefab no painelInspector . - 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
- Crie o script
VirtualItemGroupButton
herdado da classe baseMonoBehaviour
. - Declare as variáveis para o botão que abre o grupo de itens e defina valores para as variáveis no painel
Inspector . - Adicione um script para o objeto raiz de um prefab:
- Selecione um objeto no painel
Hierarchy . - No painel
Inspector , clique emAdd Component e selecione um scriptVirtualItemGroupButton
.
- Selecione um objeto no painel
Exemplo do script do widget:
- C#
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
- Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - 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
- Crie o script
VirtualItemsByGroupsPage
herdado da classe baseMonoBehaviour
. - Declare as seguintes variáveis:
GroupButtonsContainer
— contêiner para botões de grupoGroupButtonPrefab
— botão de prefabItemWidgetsContainer
— contêiner para widgets de itemWidgetPrefab
— widget de item prefab
- Anexe um script a um objeto de jogo de página:
- Selecione um objeto no painel
Hierarchy . - No painel
Inspector , clique emAdd Component e selecione um scriptVirtualItemsByGroupsPage
.
- Selecione um objeto no painel
- Defina valores para as variáveis no painel
Inspector . - Adicione a lógica de login e a lógica para obter a lista de itens, conforme demonstrado no script de exemplo.
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.
- C#
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
- Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel
Hierarchy para um painelProject . - Selecione um prefab criado e clique em
Open Prefab no painelInspector . - 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
- Crie um script
BundleWidget
herdado da classe base MonoBehaviour. - 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:
- C#
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
- Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - 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
- Crie o script
BundlesPage
herdado da classe baseMonoBehaviour
. - Declare as seguintes variáveis:
WidgetsContainer
— contêiner de widgetsWidgetPrefab
— widget de pacotes prefab
- Anexe um script a um objeto de jogo de página:
- Selecione um objeto no painel
Hierarchy . - No painel
Inspector , clique emAdd Component e selecione um scriptBundlesPage
script.
- Selecione um objeto no painel
- Defina valores para as variáveis no painel
Inspector . - Adicione a lógica de login e a lógica para obter a lista de itens, conforme demonstrado no script de exemplo.
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.
- C#
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
- Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel
Hierarchy para um painelProject . - Selecione um prefab criado e clique em
Open Prefab no painelInspector . - 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
- Crie um script
VirtualCurrencyPackageWidget
herdado da classe base MonoBehaviour. - 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:
- C#
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
- Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - 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
- Crie o script
VirtualCurrencyPackagesPage
herdado da classe baseMonoBehaviour
. - Declare as seguintes variáveis:
WidgetsContainer
— contêiner de widgetsWidgetPrefab
— prefab do pacote de moedas virtuais
- Anexe um script a um objeto de jogo de página:
- Selecione um objeto no painel
Hierarchy . - No painel
Inspector , clique emAdd Component e selecione um scriptVirtualCurrencyPackagesPage
.
- Selecione um objeto no painel
- Defina valores para as variáveis no painel
Inspector . - 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.
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.
- C#
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
- Abra o script
VirtualItemWidget
. - Declare as variáveis para o botão de compra e defina valores para elas no painel
Inspector .
Exemplo do script do widget:
- C#
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
- Abra o script
VirtualItemsPage
. - Adicione a lógica para processamento clicando no botão de compra do item virtual, conforme demonstrado no script de exemplo.
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
- C#
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
- Abra o script
VirtualItemWidget
. - Declare as variáveis para o botão de compra e defina valores para elas no painel
Inspector .
Exemplo do script do widget:
- C#
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
- Abra o script
VirtualItemsPage
. - Adicione a lógica para processamento clicando no botão de compra do item virtual, conforme demonstrado no script de exemplo.
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.
- C#
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
- Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel
Hierarchy para um painelProject . - Selecione um prefab criado e clique em
Open Prefab no painelInspector . - 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
- Crie um script
VirtualCurrencyWidget
herdado da classe base MonoBehaviour. - 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:
- C#
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
- Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - 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
- Crie um script
VirtualCurrenciesPage
herdado da classe baseMonoBehaviour
. - Declare as seguintes variáveis:
WidgetsContainer
— contêiner de widgetsWidgetPrefab
— widget prefab de exibição de saldo
- Anexe um script a um objeto de jogo de página:
- Selecione um objeto no painel
Hierarchy . - No painel
Inspector , clique emAdd Component e selecione um scriptVirtualCurrenciesPage
.
- Selecione um objeto no painel
- Defina valores para as variáveis no painel
Inspector . - Adicione a lógica de login e a lógica para obter a lista de moedas virtuais, conforme demonstrado no script de exemplo.
xsolla
, senha: xsolla
).- C#
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
- Crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - Converta o objeto de jogo criado em um prefab arrastando um objeto de jogo de um painel
Hierarchy para um painelProject . - Selecione um prefab criado e clique em
Open Prefab no painelInspector . - 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
- Crie um script
InventoryItemWidget
herdado da classe base MonoBehaviour. - 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:
- C#
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
- Na cena, crie um objeto de jogo vazio. Para fazer isso, vá para o menu principal e selecione
GameObject > Create Empty . - 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
- Crie um script
InventoryItemsPage
herdado da classe baseMonoBehaviour
. - Declare as seguintes variáveis:
WidgetsContainer
— contêiner de widgets de itemWidgetPrefab
— widget de item prefab
- Anexe um script a um objeto de jogo de página:
- Selecione um objeto no painel
Hierarchy . - No painel
Inspector , clique emAdd Component e selecione um scriptInventoryItemsPage
.
- Selecione um objeto no painel
- Defina valores para as variáveis no painel
Inspector . - Adicione a lógica de login e a lógica para obter a lista de itens no inventário.
xsolla
, senha: xsolla
).- C#
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.
Links úteis
Encontrou um erro de texto ou digitação? Selecione o texto e pressione Ctrl+Enter.