Crie Loot Boxes de NFT no Jogo com Unity

Neste guia, mostraremos como usar o contrato Pack para permitir que os usuários abram NFTs selecionados aleatoriamente como ativos dentro do jogo. No final, você irá:

• Implantar uma Edição; uma coleção de NFTs representando seus itens dentro do jogo.
• Implantar o contrato Pack; uma coleção de NFTs de loot Boxes ( Caixas de Recompensa ) ERC1155.
• Agrupar os NFTs de itens dentro do jogo nas boxes/loot crates.
• Selecionar aleatoriamente um NFT para ser entregue ao usuário quando ele abrir uma box!

Aqui está uma prévia do que estaremos construindo:

💡 Os ativos que usamos neste guia são criados por Gabriel Aguiar Prod.

Você pode usar seus próprios ativos, ou comprar estes ativos por US$ 10.

Vamos começar!

Criando NFTs dentro do jogo

Primeiro, precisamos criar os NFTs que nossos jogadores podem receber quando eles abrem suas loot boxes! Vamos usar o contrato de Edição para conseguir isso.

Para começar, vá para a página de Contratos em seu Painel de Controle da web 3.0 e clique em "Implantar novo contrato" (Deploy new contract):

Você será levado para nossa página de Exploração - onde você pode navegar pelos contratos inteligentes construídos pelos principais protocolos da web3 e implantá-los em apenas alguns cliques!

Nota: Você também pode usar a CLI ( Interface de Linha de Comando ) da web3 para criar um ambiente de contrato inteligente executando o comando abaixo a partir de seu terminal:

npx thirdweb create contract

Isto o levará através de um fluxo de passos simples de seguir para que você possa criar seu contrato. Saiba mais sobre isso em nosso guia CLI.

Em caso contrário, vamos voltar para Explorar:

Aqui, selecione seu contrato inteligente preferido. Para este guia, vamos utilizar o contrato de Edição para criar nossa coleção NFT:

Preencha os metadados de seu contrato inteligente, assim:

Quando você estiver pronto, clique no botão Deploy Now para implantar seu contrato! Recomendamos o uso de uma rede de teste antes de implantar na rede principal.

Legal! Nosso contrato de edição será enviado para a blockchain! 🎉

Cunhagem de NFTs

Vá até a aba NFTs e clique no botão + Mint para criar seus itens dentro do jogo.

Ao cunhar seus NFTs, considere a raridade que você deseja que cada item tenha.

Por exemplo, eu criei dois NFTs em minha coleção:

1 . Gema Vermelha: Um item comum, com 400 itens disponíveis.
2 . Gema Púrpura: Um item raro, com 100 itens disponíveis.

Supondo que agrupamos todos os NFTs e lançamos 1 NFT por pacote, haverá 80% de chance de abrir uma gema vermelha, e 20% de chance de abrir uma gema púrpura com 500 loot boxes disponíveis.

💡 Cada pacote NFT pode conter mais de um token; pode armazenar também os tokens ERC721, ERC1155, e ERC20! Estamos apenas simplificando as coisas aqui.

Agora que nossos NFTs estão cunhados, é hora de juntá-los em algum pacote de NFTs!

Criando Loot Box NFTs

O contratoPack permite o agrupamento de tokenss ERC20, ERC721 e ERC1155 em novos ** NFTs ERC1155** que atuam como loot boxes aleatórios.

Os pacotes em si também são NFTs ERC1155, com um recurso adicional que permite "abri-los". Quando eles são abertos, o usuário recebe token(s) selecionado(s) aleatoriamente daqueles agrupados nos pacotes.

💡 Veja o Documento de Projeto de Pacotes para saber mais sobre os pacotes.

Implantar o Contrato de Pacote

Vá para a página Pack no painel de instrumentos e clique em Deploy Now.

Preencha assim os metadados para seu contrato inteligente:

Clique em Deploy Now, assegurando que você selecione a mesma rede que seu contrato de Edição.

Agrupamento de itens em pacotes

Para cunhar nosso pacote de NFTs, precisamos usar o SDK ( Kit de Desenvolvimento de Software ) para agrupar nosso item NFTs em pacotes NFTs recém-criados!

Para começar, clone nosso repositório de modelos, executando o seguinte comando:

npx thirdweb@latest create --template pack-creation-script

Isto lhe dará um roteiro e instruções sobre como agrupar seus NFTs em pacotes! Cobriremos rapidamente os elementos-chave deste guia.

Em primeiro lugar, configuramos nossos endereços de contrato inteligentes, rede e chave privada.

const EDITION_ADDRESS = "<your-edition-smart-contract-address>";
const PACK_ADDRESS = "<your-pack-smart-contract-address>";
const network: ChainOrRpc = "optimism-goerli";
const PRIVATE_KEY = process.env.PRIVATE_KEY!;
const lootBoxImageFileName = "lootbox.png";

Usamos estes valores para instanciar o SDK em nome de nossa carteira, e depois nos conectamos à edição e embalamos contratos inteligentes:

// Instancie o SDK com a nossa chave privada na rede
const sdk = ThirdwebSDK.fromPrivateKey(PRIVATE_KEY, network);
const storage = new ThirdwebStorage();
// Conecte-se aos contratos de edição e pacote
const edition = await sdk.getContract(EDITION_ADDRESS, "edition");
const pack = await sdk.getContract(PACK_ADDRESS, "pack");

Uma vez conectado, concedemos ao pacote do contrato inteligente a aprovação para agregar nossos NFTs a partir do contrato de edição:

// Defina a aprovação do contrato de pacote para transferir nossos NFTs de edição (itens)
await edition.setApprovalForAll(PACK_ADDRESS, true);

Em seguida, chamamos a função create em nosso contrato de pacote e especificamos como queremos agrupar nossos tokens em pacotes:

// Aguarde enquanto o pacote é criado
await pack.create({
packMetadata: {
name: "Loot Box",
description: "Abra isso para revelar um item no jogo!",
image: await storage.upload(
readFileSync(${__dirname}/${lootBoxImageFileName})
),
attributes: {
artista: "@GabrielAguiarProd",
},
},
erc1155Rewards: [
// Agrupe 400 NFTs Red Gem:
{
contractAddress: EDITION_ADDRESS,
tokenId: 0,
quantityPerReward: 1,
totalRewards: 400,
},
// Agrupe 100 NFTs Red Gem:
{
contractAddress: EDITION_ADDRESS,
tokenId: 1,
quantityPerReward: 1,
totalRewards: 100,
},
],
// Especificamos 1 recompensa por pacote, e há um total de 400+100 recompensas, então teremos 500 pacotes criados.
recompensasPorPacote: 1,
});

Finalmente, executamos o roteiro e criamos nossos pacotes executando o seguinte comando a partir de nosso terminal:

npx ts-node src/index.ts

Voilá! 🎉 Agora podemos ver no painel de bordo que nossos pacotes foram criados:

Abrindo os pacotes

Podemos abrir pacotes diretamente da aba Explorer usando a função openPack:

Mas vamos integrar este contrato na Unidade agora para torná-lo mais interessante!

Recomendamos seguir o guia abaixo para estabelecer-se com nosso Unity SDK antes de continuar:

https://blog.thirdweb.com/guides/get-started-with-thirdwebs-unity-sdk/

Primeiro, importamos Thirdweb em nosso roteiro para que possamos instanciar o SDK:

// Importe a biblioteca Thirdweb
using Thirdweb;
// ... outros imports
public class LootBox : MonoBehaviour
{
private ThirdwebSDK sdk;
csharp
Copy code
void Start() { // Instancie um novo SDK do Thirdweb, conectando à rede "optimism-goerli" sdk = new ThirdwebSDK("optimism-goerli"); animator = GetComponent<Animator>(); }
}

Agora nosso valor sdk é instanciado quando o jogo começa.

Vamos querer que os usuários conectem suas carteiras e mudem para a rede correta sempre que tentarem abrir um pacote. Vamos criar uma função simples para executar e aguardar os dois:

async Task<string> EnsureCorrectWalletState()
{
    string address = await sdk.wallet.Connect();
    await sdk.wallet.SwitchNetwork(420);
    return address;
}

Vamos nos conectar ao nosso contrato pack para que possamos abrir os pacotes:

async Task<Pack> GetPackContract()
{
    await EnsureCorrectWalletState();
    return sdk
        .GetContract("0xd8Bd34726814855fB9cFF58fe5372558e3B411Cb")
        .pack;
}

Finalmente, chame a função Open para abrir um pacote a partir da carteira conectada!

async Task<ERC1155Reward> OpenPack()
{
// Verifique se o usuário está conectado e na rede correta
await EnsureCorrectWalletState();
// Conecte-se ao contrato do pacote
Pack packContract = await GetPackContract();
// Abra 1 quantidade do pacote com ID 0
var result = await packContract.Open("0", "1");
// Retorne o NFT que abrimos do pacote!
return result.erc1155Rewards[0];
}

Quando o usuário clica, nós chamamos a função OpenPack e iniciamos a animação:

se (Input.GetMouseButtonDown(0))
{
var openedPack = await OpenPack();
// ... Inicie agora a animação de abertura do pacote!
}

Finalizando

Pronto! 🎉 Nossos pacotes estão prontos para serem abertos!

Neste guia, realizamos com sucesso:

1 . Criamos NFTs de itens de jogos
2 . Agrupamos eles em um conjunto de loot boxes de NFT
3 . Abrimos esses loot boxes de NFTs dentro de um jogo Unity em C#!

Se você tiver alguma dúvida, acesse nosso servidor do Discord para falar diretamente com nossa equipe.

Este artigo foi escrito por Jarrod Watts e traduzido para o português por Rafael Ojeda

Você pode ler o artigo original em inglês [aqui]Você pode ler o artigo original em inglês aqui