NOVO: Experimente a API Parsed Events Scan
Games: como a Solana está mudando o cenário
Blog/Pesquisa

Games: como a Solana está mudando o cenário

Developer Experience Engineer0xIchigo no X0xIchigo no LinkedIn0xIchigo no GitHub
28 min de leitura
Índice

Sobre o que é este artigo?

Se as chaves não são suas, as criptomoedas também não são. Esse ditado, central para o espírito das criptomoedas, é igualmente relevante para os videogames. Integrar blockchains ao cenário dos games é mais do que uma simples inovação. É uma mudança de paradigma que permite a propriedade descentralizada de ativos e a autonomia. Na vanguarda dessa mudança está a Solana. Ela oferece a plataforma de contratos inteligentes mais rápida para aproveitar os benefícios da Web3. Com as altas velocidades, as taxas baixas e previsíveis e a baixa latência da Solana, os desenvolvedores podem criar experiências de jogo únicas que não seriam possíveis em nenhum outro lugar.

Este artigo explora o potencial da blockchain nos games, analisando os argumentos a favor dos jogos Web3 e por que os desenvolvedores de jogos deveriam considerar criar na Solana. O artigo também aborda a instalação, a configuração e o uso de frameworks e plataformas populares para criar jogos integrados à Solana.

Por que jogos Web3?

Para jogadores

Nenhum outro videogame chega perto dos itens colecionáveis de Counter-Strike. Dependendo da raridade e do float, algumas das skins mais raras de Counter Strike 2, ou seja, itens cosméticos de armas dentro do jogo, podem valer milhares de dólares. Neon, um trader conhecido na comunidade de Counter-Strike, tinha um inventário de skins avaliado em mais de US$ 100 mil. Em 13 de outubro de 2023, ele foi banido injustamente pelo sistema antitrapaça da Valve (VAC) após ativar o recurso Anti-Lag+ da AMD. Um banimento VAC impede a negociação do inventário do jogador, o que significa que o inventário de US$ 100 mil de Neon ficou permanentemente vinculado à conta dele. A Valve se pronunciou oficialmente sobre o problema e, por sorte, Neon conseguiu reverter o banimento. Counter-Strike 2 ainda enfrenta problemas com banimentos indevidos.

Em uma plataforma de jogos tradicional como a Steam, sempre existe o risco subjacente de perder o acesso a jogos ou itens colecionáveis comprados. Nada impede a Valve de retirar seus ativos. Isso parece improvável devido aos graves danos à reputação e à destruição de bases inteiras de jogadores. No entanto, a empresa poderia aumentar as taxas de drop de itens raros, reduzindo o valor deles. Foi exatamente isso que aconteceu com Team Fortress 2. Independentemente do valor, todos os jogos que você compra e todos os itens que coleta dentro deles são gerenciados por uma entidade centralizada. Os jogadores ficam à mercê das empresas de games. Até mesmo Ethereum foi criado por causa do patch 3.10 de World of Warcraft. Vitalik Buterin já falou bastante sobre os “horrores da centralização”, depois que a Blizzard enfraqueceu o feitiço Siphon Life do personagem dele e arruinou anos de jogo. Os jogadores estão cansados de ficar à mercê de entidades centralizadas. Os jogos Web3 oferecem uma saída.

Os jogos Web3 representam uma mudança de paradigma. Eles aproveitam a tecnologia blockchain para descentralizar a propriedade de ativos e os processos de tomada de decisão. Isso garante transparência e segurança, permitindo que os jogadores sejam os verdadeiros proprietários dos seus ativos dentro dos jogos em diferentes plataformas. O resultado são economias virtuais, como o mercado de skins de Counter-Strike, com os benefícios de transparência, segurança e composabilidade. Essas economias viabilizam novos modelos de jogos centrados no usuário, como o Play-to-earn (P2E), em que os jogadores recebem recompensas com valor no mundo real por jogar.

Isso está longe de ser um conceito de nicho. O potencial dos jogos Web3 para revolucionar o setor fica evidente em vários jogos influentes e bem-sucedidos. Por exemplo, o Decentraland oferece um mundo virtual onde os jogadores podem comprar, vender e desenvolver imóveis como NFTs. A Tokens.com pagou mais de US$ 2 milhões por imóveis no centro de Decentraland. Isso demonstra as possibilidades das economias virtuais, das experiências digitais e dos espaços pessoais no ecossistema Web3. Da mesma forma, jogos Play-to-earn como Axie Infinity e aplicativos de estilo de vida como STEPN, uma plataforma move-to-earn, atraíram atenção internacional ao demonstrar como os jogadores podem gerar renda jogando. Jogos como Star Atlas e Aurory tiveram sucesso semelhante na Solana. Esses não são exemplos isolados. Eles fazem parte de uma tendência mais ampla em que os games transcendem o entretenimento e se integram a sistemas econômicos e sociais do mundo real.

Para desenvolvedores

O surgimento dos jogos Web3 abre novas oportunidades para os desenvolvedores, que vão muito além dos limites do paradigma atual dos games:

  • Mercados mais profundos e garantias de confiança: os jogos Web3 criam mercados mais profundos e robustos. Os desenvolvedores podem alcançar um público global no qual os participantes interagem com um nível maior de confiança. Toda propriedade e todas as transações dentro do jogo são verificáveis e imutáveis. Isso é possível graças à transparência e à segurança inerentes às blockchains.
  • Aproveitamento de programas on-chain existentes: os desenvolvedores podem integrar facilmente programas existentes e os respectivos ativos aos jogos. Isso reduz o tempo de lançamento no mercado e permite que os desenvolvedores se concentrem em criatividade e inovação por meio da colaboração no ecossistema
  • Inovações econômicas e de jogabilidade: os desenvolvedores podem criar ciclos complexos de jogabilidade e economia que aproveitam outros aplicativos ou experiências on-chain. Essa interconexão permite criar mundos de jogo ricos e dinâmicos, onde as ações em um jogo podem causar efeitos em outro
  • Incentivo a mods: a abertura da blockchain permite que os desenvolvedores criem jogos concebidos para promover mods. Essa abertura pode gerar inovação impulsionada pela comunidade, com jogadores contribuindo para a evolução do jogo. É uma transição de um ambiente de código fechado para um modelo de desenvolvimento colaborativo e centrado na comunidade

As blockchains oferecem mais do que apenas uma plataforma para criar jogos. Elas são meios para desenvolver novas formas de experiências digitais interativas. As blockchains abrem caminho para um ecossistema de games mais dinâmico e participativo.

Por que criar na Solana?

Taxas de transação baixas e previsíveis são essenciais para jogos Web3. Os jogadores não querem pagar taxas exorbitantes para jogar. A Solana tem taxas de transação baixas, frequentemente inferiores a US$ 0,001, e a taxa média de transações sem voto fica em torno de 0,000005 a 0,00007 SOL. Essas taxas também são previsíveis graças aos mercados de taxas localizados. Eles isolam o congestionamento e garantem que apenas as transações que tentam acessar áreas do estado com alta demanda tenham taxas maiores. Isso é diferente de redes baseadas em gas, como Ethereum, onde as taxas de transação são imprevisíveis e podem ultrapassar cem dólares por uma transação simples durante períodos de congestionamento intenso.

A arquitetura da Solana oferece uma composabilidade incomparável. Para os jogadores, isso significa uma experiência de usuário simplificada com uma única carteira. Eles não precisam se preocupar com a complexidade de usar bridges para acessar diferentes plataformas. Tudo é acessível e interconectado dentro do ecossistema da Solana. Para os desenvolvedores de jogos, a composabilidade oferece inúmeras oportunidades. Eles podem integrar e aproveitar facilmente programas on-chain existentes, como na parceria entre The Remnants e Magic Eden. Isso garante que a liquidez dos ativos dos jogos não fique fragmentada entre outras L2s ou shards. A Solana promove um ecossistema com composabilidade, facilitando a colaboração integrada entre jogos, comunidades e outros aplicativos na rede.

Altas velocidades e baixa latência são essenciais para os games. Transações lentas podem dificultar atualizações do estado do jogo, causar atrasos insuportáveis e gerar longos tempos de espera. Isso proporcionaria uma experiência pior do que a dos jogos tradicionais. A Solana foi projetada para oferecer alto throughput de transações. Ela processa, em média, 400 transações geradas por usuários por segundo (TPS), chegando a mais de 2.000 TPS durante períodos de alta demanda. Com inovações como o Firedancer a caminho, a Solana tem potencial para escalar e oferecer suporte a qualquer aplicativo tradicional voltado ao consumidor. A Solana também tem como meta um tempo de slot de 400 milissegundos, ou seja, o tempo necessário para cada ledger processar transações e produzir um bloco. Esse tempo pode variar entre 500 e 600 milissegundos conforme a demanda da rede, o que faz dela a blockchain mais rápida disponível. Isso a torna um banco de dados em tempo real perfeito para gêneros como jogos de estratégia, jogos por turnos, construção de cidades e jogos idle.

Os Forever Games são jogos totalmente on-chain. Esse é o caso mais extremo de integração com blockchain, no qual o estado e a lógica de um jogo são executados integralmente na blockchain. O resultado é um jogo persistente conectado a um sistema rico de protocolos, dApps e programas, com uma barreira de entrada baixa. Alguns exemplos na Solana incluem:

Para um jogador, um tempo de resposta de 400 milissegundos parece péssimo em jogos de corrida ou tiro em tempo real. No entanto, nem tudo precisa ser colocado diretamente on-chain. Integrações menores, como usar NFTs para representar itens do jogo, tokens para compras dentro do aplicativo e a carteira do jogador para autenticação, podem ser implementadas rapidamente. Hoje, há uma grande variedade de ferramentas disponíveis para você começar a integrar com a Solana.

Ferramentas para criar jogos na Solana

Este artigo analisa vários frameworks e plataformas populares para criar jogos integrados à Solana. Para manter a concisão, não abordamos algumas ferramentas, mas incluímos links para elas abaixo, na seção de recursos adicionais. Entre elas estão o Godot Solana SDK e o template inicial do Phaser 3 com TypeScript. Neste artigo, veremos como instalar, configurar e usar as seguintes ferramentas:

Anchor

Desenvolver um jogo on-chain fica muito mais fácil com frameworks como o Anchor. O Anchor é um framework robusto usado para criar programas seguros com rapidez. Ele simplifica o processo de desenvolvimento ao reduzir código boilerplate, executar várias verificações de segurança, automatizar a geração de bibliotecas cliente e oferecer uma configuração abrangente de testes. A maneira mais fácil de desenvolver um jogo totalmente on-chain é armazenar a lógica e o estado dele em um programa Anchor. O Anchor abstrai a complexidade do modelo de programação de baixo nível da Solana. Assim, os desenvolvedores podem se concentrar mais na criação do jogo e menos em lidar com a SVM.

Instalação

Rust é necessário para usar o Anchor. Você pode instalá-lo aqui ou com o seguinte comando:

Código
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

O Anchor também recomenda que iniciantes em Rust leiam os nove primeiros capítulos do livro de Rust. Eles abrangem os fundamentos, já que, na maioria das vezes, não é necessário ter conhecimentos avançados de Rust para escrever programas Anchor.

O Anchor também exige o conjunto de ferramentas da Solana:

Código
# macOS and Linux
sh -c "$(curl -sSfL https://release.solana.com/v1.17.7/install)"

# Windows
cmd /c "curl https://release.solana.com/v1.17.7/solana-install-init-x86_64-pc-windows-msvc.exe --output C:\solana-install-tmp\solana-install-init.exe --create-dirs"

Você pode confirmar que a versão desejada do solana está instalada executando o comando solana --version.

Yarn também é necessário e pode ser instalado usando o gerenciador de pacotes npm: npm install --global yarn.

É recomendável instalar o Anchor usando o gerenciador de versões do Anchor (avm). Ele pode ser instalado com cargo: cargo install --git <https://github.com/coral-xyz/anchor> avm --locked --force. Em seguida, podemos instalar e usar a versão mais recente:

Código
avm install latest
avm use latest

# Verify the installation
avm --version

A documentação do Anchor também oferece um guia detalhado de instalação.

Uso e exemplos

O SolanaCiv foi desenvolvido totalmente on-chain com o Anchor. O gerenciamento de recursos, o recrutamento de unidades, a pesquisa de novas tecnologias, as batalhas contra bárbaros e as negociações acontecem on-chain. Além disso, ele é open source! Isso significa que pode ser usado como referência para analisar a lógica e o estado do jogo e entender como tudo é armazenado on-chain.

O Clockwork é um mecanismo de automação open source para a Solana. Ele é especialmente útil no desenvolvimento de jogos porque facilita o agendamento de transações e a criação de programas automatizados e orientados a eventos. Pode ser instalado com o comando cargo install -f --locked clockwork-cli e integra-se muito bem ao Anchor. Uma lista de exemplos de uso do Clockwork está disponível aqui.

O Solana Playground é um ambiente de desenvolvimento de código baseado no navegador para testar e implantar programas. Seu ambiente de desenvolvimento integrado (IDE) é ideal para quem está começando a usar o Anchor e quer aprender a desenvolver jogos na Solana. Ele tem vários tutoriais do Anchor relevantes para jogos on-chain. Por exemplo, o Tiny Adventure é um tutorial de jogo on-chain voltado para iniciantes. O tutorial ensina a usar o Anchor para mover um personagem para a esquerda e para a direita e a usar um Program Derived Address (PDA) para salvar dados do jogo. Ele também mostra como configurar um front-end em Next.js usando o adaptador de carteira da Solana. O código final está disponível aqui.

Para criar rapidamente um programa Anchor com um cliente TypeScript, use o comando npx create-solana-game seguido do nome do seu jogo. Esse comando simplifica o processo de desenvolvimento com Anchor e TypeScript e estrutura um projeto totalmente novo. A ferramenta foi desenvolvida por Jonas Hahn e Beeman e está disponível no repositório solana-developers no GitHub.

Turbo

O Turbo é um mecanismo e marketplace de jogos 2D de última geração criado para capacitar desenvolvedores independentes. Ele inclui vários recursos inovadores:

  • Os jogos fazem hot reload sempre que o código, os shaders ou os sprites são modificados
  • Os jogos são executados sem interface gráfica para que você possa verificar o estado deles em servidores remotos
  • O mecanismo é executado em WebAssembly e WebGPU, permitindo que funcione em qualquer plataforma
  • As APIs integradas do mecanismo são acessíveis para iniciantes

O Turbo está sendo desenvolvido por Jozanza em Rust. Como ele é desenvolvido em Rust, os desenvolvedores podem reutilizar facilmente structs do Anchor nos programas sem precisar de SDKs ou plugins. O projeto ainda está em fase inicial de desenvolvimento. No entanto, o site contém vários exemplos que podem ser executados no navegador e demonstram o poder do Turbo e sua experiência intuitiva para desenvolvedores. Além disso, um passo a passo de “Olá, mundo!” está disponível aqui.

Instalação

Para começar a usar o Turbo, primeiro precisamos instalar todas as dependências relevantes do Rust:

Código
# Download and run the rust installer
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add wasm targets
rustup target add wasm32-unknown-unknown wasm32-wasi

# Install cargo-watch
cargo install cargo-watch

Depois, precisamos baixar e executar o instalador da interface de linha de comando (CLI) do Turbo:

Código
sh -c "$(curl -sSfL https://turbo.computer/install.sh)"

Quando a instalação for concluída, podemos usar o comando turbo-cli -h para verificar se a CLI do Turbo foi instalada corretamente. Com esse comando, você verá as informações de uso do Turbo:

Código
Run Turbo games natively on desktop

Usage: turbo-cli

Commands:
  init  Initializes a new Turbo project in Rust
  run   Runs a Rust Turbo project
  help  Print this message or the help of the given subcommand(s)

Options:
  -v, --version  Print version
  -h, --help     Print help
  -V, --version  Print version

Processo de desenvolvimento

O Turbo tem várias macros para simplificar o processo de desenvolvimento. Vale lembrar que as macros do Rust são ferramentas avançadas de metaprogramação para gerar código, ou seja, código que escreve outro código. Elas ajudam a reduzir boilerplate e possibilitam padrões de código mais expressivos.

A macro println é uma implementação personalizada da macro padrão println. Ela formata uma string e a envia ao sistema de logs do mecanismo de jogos:

Código
macro_rules! println {
    ($fmt:expr $(, $($arg:tt)*)?) => {
        $crate::sys::log(&format!($fmt, $($($arg)*)?))
    };
}

A macro cfg é usada para configuração. Ela expõe a função config, que retorna um inteiro de 64 bits combinando um ponteiro para uma string de configuração e o tamanho dela. Isso é útil para transferir dados de configuração do Rust para outro ambiente, como WebAssembly:

Código
macro_rules! cfg {
    ($toml:expr) => {
        #[no_mangle]
        pub unsafe extern "C" fn config() -> u64 {
            let ptr = $toml.as_ptr() as u64;
            let len = $toml.len() as u64;
            (len << 32 | ptr)
        }
    };
}

A macro init é útil para gerenciar o estado do jogo. Ela define uma struct e fornece métodos para carregar e salvar seu estado. Ela implementa os métodos load e save para a struct e usa Borsh para persistir o estado:

Código
macro_rules! init {
    (struct $StructName:ident { $($fields:tt)* } = $default:expr) => {
        ...
    };
}

A macro go é usada para definir a lógica principal de um jogo. Ela encapsula um bloco de código em uma função que pode ser chamada por um ambiente externo, como WebAssembly. Ela também define um ponto de entrada para a lógica do jogo e uma função run_snapshot para executar o jogo com um snapshot do seu estado:

Código
macro_rules! go {
    ($($body:tt)*) => {
        use $crate::prelude::*;

        #[no_mangle]
        #[allow(overflowing_literals, non_upper_case_globals)]
        pub unsafe extern "C" fn run() {
            use std::f32::consts::PI;
            $($body)*
        }
        pub fn run_snapshot(snapshot_data: &[u8]) -> Vec {
            $crate::run_snapshot(snapshot_data, || unsafe { run() })
        }
    };
}

O Turbo também usa a macro strike do crate struckstruck para aprimorar os recursos de definição de structs do Rust. Normalmente, structs aninhadas precisam ser definidas separadamente. A macro strike permite definir uma struct com suas structs aninhadas inline. Esse recurso simplifica o código e torna estruturas de dados complexas mais legíveis e concisas. Ele também aplica automaticamente a serialização Borsch a toda a estrutura. Além disso, propaga a macro derive da struct de nível superior para todas as structs aninhadas.

Assim, o fluxo de trabalho completo de desenvolvimento de um projeto Turbo é o seguinte:

Código
// Defne the game configuration using the turbo::cfg! macro
turbo::cfg! {r#"
    name = "Grand Theft Auto VI"
    version = "1.0.0"
    author = "Ichigo"
    description = "Vice City but pixelated"
    [settings]
    resolution = [256, 144]
    tile_size = [32, 32]
"#}

// Define the game state initialization using the turbo::init! macro
turbo::init! {
	...
}

// Implement the game loop using the turbo::go! macro
turbo::go! {
	// Load the game state
	let mut state = GameState::load();
	...
}

Suporte à Solana

O Turbo se diferencia de outros mecanismos de desenvolvimento de jogos baseados em Rust porque terá suporte completo à Solana. Por exemplo, ele consegue buscar dados de uma conta em um RPC e decodificá-los com apenas duas linhas de código. Ele também assina automaticamente as atualizações da conta por WebSockets, garantindo que seus dados estejam sempre atualizados:

Código
// Get the Solana account data
let response = solana::get_account("pubkey");

// Decode the account data
let decoded = response.decode_anchor::();

// And now we can work with on-chain data!
if let Ok(data) = decoded {
	...
}

Magicblock

O Magicblock é um framework open source versátil para criar jogos on-chain. Ele permite que qualquer pessoa crie e jogue na Solana ou na SVM. Ele oferece um conjunto completo de ferramentas que permite aos desenvolvedores criar jogos totalmente on-chain ou integrar a Solana a jogos existentes. Ele inclui os seguintes recursos:

Com todos esses recursos, o Magicblock busca abstrair a complexidade para que os desenvolvedores possam se concentrar em criar a melhor experiência de usuário possível. O framework, licenciado sob a licença MIT, é mantido pela Magicblock Labs, ou seja, Andrea e Peak.

Solana Unity SDK

O Solana Unity SDK é um pacote open source com ferramentas que permitem aos desenvolvedores integrar NFTs, tokens e programas on-chain baseados na Solana aos seus jogos no Unity. O SDK aproveita o Solana Unity Core, um framework compatível com o padrão .NET 2.0 que integra a Solana ao ecossistema .NET. Ele contém muitos recursos, como cobertura completa da API JSON RPC, descompilação de instruções, suporte ao Solana Mobile Stack e operações nativas em DEXs.

Uma lista de exemplos de jogos criados no Unity com o Solana Unity SDK está disponível aqui.

Instalação, configuração e uso

Para criar com o Unity, baixe o Unity Hub aqui. O Unity Hub gerencia várias instalações do Unity Editor, permitindo que você trabalhe e crie novos projetos em diferentes versões. Antes de prosseguir, confirme se o sistema atende aos seguintes requisitos:

  • SO: Windows 7 SP1+, 8 e 10, somente versões de 64 bits; Mac OS X 10.13+; Ubuntu 16.04 e 18.04; e CentOS 7
  • GPU: uma placa de vídeo compatível com DX10 (shader model 4.0)

Com o Unity instalado, agora podemos criar e abrir um novo projeto.

Com o novo projeto aberto, abra a janela do Package Manager. Ela pode ser acessada no menu superior do Unity em Window > Package Manager.

Com a janela aberta, clique no botão de adição (+) na barra de status. As opções para adicionar pacotes serão exibidas. Em seguida, selecione “Add package from git URL” no menu.

Insira a URL do Git https://github.com/magicblock-labs/Solana.Unity-SDK.git na caixa de texto e clique em “Add”. Você pode instalar uma versão específica do pacote inserindo https://github.com/magicblock-labs/Solana.Unity-SDK.git#X.Y.Z e substituindo X.Y.Z pela versão desejada. Todas as versões disponíveis estão listadas aqui.

Com o Solana Unity SDK instalado, importe Samples usando o inspetor do Package Manager. Isso inclui uma cena de exemplo que você pode consultar ou modificar para integrar ao seu projeto do Unity. Essa cena fica na pasta Scenes e contém um exemplo de autenticação de carteira e swap de tokens pela Orca. A pasta Scripts contém diferentes exemplos de scripts, incluindo o script de swaps da Orca. O script Web3.cs pode ser anexado a qualquer objeto do projeto. Esse script é o principal ponto de entrada do Solana Unity SDK. Ele é um singleton que gerencia a conexão com a Solana, facilitando logins com carteiras, assinaturas de transações e muito mais. A pasta Prefabs contém templates que armazenam configurações de objetos. Eles podem ser usados para criar instâncias do mesmo ativo e reutilizá-las em todo o projeto.

O canal do Magicblock no YouTube contém tutoriais sobre como conectar carteiras da Solana ao Unity, obter a chave pública e o saldo de uma carteira, realizar testes com carteiras dentro do jogo e criar um mecanismo de xadrez on-chain.

O repositório do Solana Unity SDK no GitHub também contém vários scripts de exemplo, desde decodificação de instruções até criação de transações.

Exemplo de implementação do Jupiter

Além da Orca, o Jupiter tem suporte nativo no Solana Unity SDK. O SDK oferece métodos utilitários para facilitar cotações de swaps e criar e enviar transações de swap.

Para realizar um swap, primeiro precisamos criar uma instância de IDexAggregator e fornecer uma conta padrão. Essa instância será usada para interagir com o Jupiter:

Código
IDexAggregator dex = new JupiterDexAg(Web3.Account);

Em seguida, definimos os tokens que queremos trocar. Neste exemplo, trocaremos SOL por BONK:

Código
TokenData tokenA = await dex.GetTokenBySymbol("SOL");
TokenData tokenB = await dex.GetTokenBySymbol("BONK");

Depois, obtemos uma cotação para o swap. Esta é a aparência da cotação para trocar 1 SOL:

Código
SwapQuoteAg swapQuote = await dex.GetSwapQuote(
    tokenA.MintAddress,
    tokenB.MintAddress,
    DecimalUtil.ToUlong(1, tokenA.Decimals)
);

var quote = DecimalUtil.FromBigInteger(swapQuote.OutputAmount, tokenB.Decimals);

// Logs the expected amount of BONK
Debug.Log(quote);

Também podemos exibir a rota do swap para oferecer mais transparência:

Código
Debug.Log(string.Join(" -> ", swapQuote.RoutePlan.Select(p => p.SwapInfo.Label)));

Agora podemos gerar a transação de swap, assiná-la com nossa carteira e enviá-la:

Código
Transaction tx = await dex.Swap(swapQuote);
await Web3.Wallet.SignAndSendTransaction(tx);

Portabilidade de um programa para o Unity

Os desenvolvedores podem usar o pacote Solana Unity Anchor para integrar programas Anchor ao Unity. Esse pacote contém um conversor de IDL para C#. O conversor simplifica a conversão de IDLs do Anchor, ou seja, representações JSON de programas da Solana, em código C# para projetos do Unity. O processo de integração segue duas etapas principais:

  • Instalação: o comando dotnet tool install -g Solana.Unity.Anchor.Tool é usado para instalar a ferramenta Solana Unity Anchor. A flag -g garante que o pacote seja instalado globalmente, eliminando a necessidade de instalar essa ferramenta a cada novo projeto
  • Geração de código: o comando dotnet anchorgen -i idl/file.json -o src/ProgramCode.cs é usado para gerar a representação do programa em C#. Esse comando converte a IDL especificada em um arquivo C# pronto para ser usado no Unity.

Seguindo essas etapas, os desenvolvedores podem portar programas da Solana para o ambiente Unity com eficiência. Um vídeo com o passo a passo desse processo, criado por Jonas Hahn, está disponível aqui.

SOAR

O Solana On-Chain Achievement and Ranking (SOAR) é um programa criado para oferecer uma solução integrada para gerenciar placares, conquistas, perfis de jogadores e distribuição automática de recompensas na Solana. Ele oferece vários recursos, incluindo:

  • Criação de placares
  • Gerenciamento de conquistas
  • Suporte a clientes TypeScript
  • Interação com o programa SOAR por meio de chamadas de Cross-Program Invocation (CPI)

O suporte ao Solana Unity SDK está em desenvolvimento e deve ser disponibilizado em breve.

O SOAR pode ser facilmente integrado a um projeto usando poucas linhas de código. Por exemplo:

Código
import { SoarProgram, GameType, Genre } from "@magicblock-labs/soar-sdk";

const provider = anchor.AnchorProvider.env();
anchor.setProvider(provider);

const client = SoarProgram.get(provider);

let game = Keypair.generate();
let title = "Game1";
let description = "Description";
let genre = Genre.Action;
let gameType = GameType.Web;
let nftMeta = Keypair.generate().publicKey;
let _auths = auths.map((keypair) => keypair.publicKey);

// Retrieve the bundled transaction.
let { newGame, transaction } = await client.initializeNewGame(game.publicKey, title, description, genre, gameType, nftMeta, _auths);

// Send and confirm the transaction with the game keypair as signer.
await client.sendAndConfirmTransaction(transaction, [game]);

O código acima foi extraído diretamente da documentação da Magicblocks sobre o SOAR. O trecho começa importando os módulos necessários de @magicblock-labs/soar-sdk, incluindo SoarProgram, GameType e Genre.

A classe SoarProgram dá ao cliente acesso a todas as instruções do programa on-chain SOAR. Ela também inclui funcionalidades para derivar PDAs e buscar várias contas.

Em seguida, o código inicializa um provedor Anchor (anchor.AnchorProvider.env()) e o define como o provedor padrão para as operações seguintes (anchor.setProvider(provider)). Depois, um cliente SoarProgram é criado com o provedor definido anteriormente.

O trecho começa a inicializar um novo jogo. Um novo par de chaves do jogo é gerado, e detalhes essenciais, como título, descrição, gênero (por exemplo, Genre.Action) e tipo de jogo (por exemplo, GameType.Web), são definidos. Um par de chaves de metadados de NFT também é gerado para o jogo. Em seguida, uma lista de autorizações (_auths) é preparada para definir o controle de acesso dentro do jogo.

O método initializeNewGame é chamado no cliente SOAR, recebendo a chave pública, o título, a descrição, o gênero, o tipo, os metadados de NFT e as autorizações do jogo. Esse método retorna um objeto newGame e prepara a transação do novo jogo para envio. A transação é enviada e confirmada usando o método sendAndConfirmTransaction disponível no cliente SOAR. O par de chaves do jogo é usado como signatário da transação, garantindo que ela seja autorizada pelo criador do jogo.

Inicializar um cliente e configurar um novo jogo on-chain com o SOAR é fácil. Agora podemos usar o GameClient para registrar nosso jogo, criar um placar e acessar o estado do jogo. As possibilidades são infinitas.

O endereço do programa SOAR é SoarNNzwQHMwcfdkdLc6kvbkoMSxcHy89gTHrjhJYkk, e a documentação de TypeScript está disponível aqui.

Solana Unreal SDK

O Solana Unreal SDK é um plugin e kit de ferramentas que permite aos desenvolvedores criar jogos em blockchain na Solana com a Unreal Engine 5. O kit contém modelos iniciais para jogos multijogador massivos online (MMO) integrados à Solana, incluindo um modelo para o servidor do jogo. Ele também inclui recursos como:

  • Todos os recursos do Solnet em C++ e Blueprint Visual Scripting
  • Um sistema de carteira dentro do jogo com proteção e criptografia de dados
  • Criação de NFTs da Metaplex
  • Processamento de pagamentos

O plugin aproveita o Solnet e o poder do runtime do .NET para que os desenvolvedores possam se comunicar diretamente com a Solana sem criar do zero uma biblioteca C++ completa. O LinkStream pode enviar mensagens de transações dos jogos para carteiras, como a Tranquility, por meio de servidores TCP e protocolos de cliente. A equipe do Star Atlas criou originalmente o SDK, e a Bifrost recentemente bifurcou e atualizou o código. Para nossos objetivos, usaremos como referência a versão da equipe do Star Atlas na próxima seção sobre instalação. O processo é o mesmo para a Bifrost.

Instalação

Primeiro, precisamos instalar o Epic Games Launcher para usar a Unreal Engine. Depois, precisamos criar uma conta da Epic Games e fazer login. Após entrar, acesse a aba Unreal Engine e clique no botão Instalar para baixar a versão mais recente. Um passo a passo detalhado desse processo está disponível aqui. Confira os requisitos de sistema recomendados para a Unreal Engine 5:

  • Windows 10 de 64 bits, Intel ou AMD de quatro núcleos, 2,5 GHz ou mais rápido, 8 GB de RAM
  • macOS Big Sur, Intel de quatro núcleos, 2,5 GHz ou mais rápido, 8 GB de RAM
  • Linux Ubuntu 18.04, Intel ou AMD de quatro núcleos, 2,5 GHz ou mais rápido, 32 GB de RAM

Abra o Epic Games Launcher e inicie a versão instalada da Unreal:

Crie um novo projeto e selecione C++ como modelo do projeto:

Agora, feche o editor e abra a pasta Project Location definida durante a criação do projeto. Em seguida, crie uma nova pasta Plugins no diretório raiz:

Copie o plugin para o diretório Plugins. Clique com o botão direito no arquivo .uproject no diretório raiz e selecione Generate Visual Studio project files. Clique duas vezes no arquivo .sln e abra o projeto com seu IDE de C++. Depois, abra o arquivo em Source/<ProjectName>/<ProjectName>.build.cs. Adicione o nome do plugin a PublicDependencyModuleNames. No nosso caso, devemos inserir Foundation:

Adicione o nome do plugin ao nosso arquivo .uproject:

Feche seu IDE e gere novamente os arquivos do projeto. Depois, abra a solução do projeto, ou seja, o arquivo .sln, e o processo de instalação estará concluído.

Uso

Todo o conteúdo relacionado ao plugin está disponível em Plugins > Solana SDK no navegador de conteúdo. Um blueprint do LinkStream está disponível em Plugins > Solana SDK Content > Blueprints. Esse blueprint permite que os desenvolvedores se comuniquem com o Solnet. O mapa sandbox disponível na pasta Maps pode servir de referência para configurar corretamente o Solana SDK. Uma explicação sobre o uso geral, como personalizar seu wrapper do LinkStream e como interagir com a REST API para autenticação do servidor está disponível no GitHub do Solana Unreal SDK. Uma explicação mais detalhada sobre como interagir com a Solana usando o Unreal SDK está disponível aqui.

O foco da Unreal em otimizações e efeitos de pós-processamento 3D permite criar jogos fotorrealistas em comparação com outros editores, como o Unity. Um exemplo popular desse hiper-realismo é o Star Atlas. Star Atlas é um jogo imersivo de estratégia que leva você às profundezas do espaço. Ele está repleto de oportunidades, conquistas territoriais e intrigas políticas. Outros jogos, como o Yaku Corp, aproveitam o fotorrealismo da Unreal Engine para criar MMORPGs imersivos.

Honeycomb

O Honeycomb é um protocolo desenvolvido pela Tumi Labs para simplificar o processo de desenvolvimento de jogos Web3. Honeycomb é um conjunto de programas on-chain e ferramentas de compactação de estado que cuidam de funções essenciais do ciclo de vida dos jogos. Todos os programas foram desenvolvidos para serem interoperáveis e modulares. Eles também podem ser personalizados para atender às necessidades específicas de cada desenvolvedor. O kit de ferramentas de desenvolvimento de infraestrutura concentra-se nas seguintes funções principais:

  • Recompensas para jogadores inativos (staking)
  • Jornadas (missões)
  • Caixas de recompensas ou prêmios por RNG (sorteios)
  • Guildas / Grupos
  • Tokens de jogos (custodiais e não custodiais)
  • Ativos digitais mutáveis
  • Criação e gerenciamento de ativos digitais
  • Perfis de jogadores
  • Estruturas de taxas

As ferramentas podem ser divididas nas seguintes categorias:

  • Hive Control: o programa principal que gerencia todas as permissões e delegações das autoridades dos programas em todo o Honeycomb
  • Asset Hub: um conjunto de ferramentas para criar e gerenciar ativos dentro do jogo
  • Nectar Utility: um conjunto de ferramentas utilitárias criado para permitir que NFTs ofereçam recursos exclusivos aos jogos, como recompensas de tokens por inatividade (staking), jornadas e caixas de recompensas
  • Buzz Kit: um conjunto de ferramentas para facilitar a criação de guildas dentro do jogo. A Tumi Labs também planeja desenvolver programas de matchmaking e gerenciamento do estado dos jogos nesse conjunto de ferramentas

Instalação

Os desenvolvedores podem interagir com o Honeycomb usando seu SDK JavaScript e o @solana/web3.js:

Código
# Using npm
npm install @solana/web3.js @honeycomb-protocol/hive-control

# Using yarn
yarn add @solana/web3.js @honeycomb-protocol/hive-control

Exemplo de uso

Após a instalação, os desenvolvedores podem inicializar um objeto Honeycomb com um objeto Connection da Solana:

Código
import * as web3 from "@solana/web3.js";
import { Honeycomb } from "@honeycomb-protocol/hive-control";

const honeycomb = new Honeycomb(
  new web3.Connection("https://api.mainnet-beta.solana.com")
);

A partir daqui, as opções são infinitas. Por exemplo, os desenvolvedores podem interagir com o IdentityClient para gerenciar identidades e perfis de usuários. O guestIdentity é a identidade padrão usada como placeholder até que um par de chaves ou uma carteira seja registrado na instância do Honeycomb. Um par de chaves pode ser vinculado como identidade com o seguinte comando: honeycomb.use(keypairIdentity(<keypair>);. Da mesma forma, um objeto de carteira (Solana Wallet Adapter) pode ser registrado como identidade usando a função walletIdentity disponível na instância do Honeycomb. As identidades podem ser usadas para autenticação, como na assinatura de mensagens ou transações.

Outro exemplo interessante é o HttpClient. Esse módulo facilita solicitações HTTP usando Axios ou Fetch, oferecendo funcionalidades relacionadas a HTTP. Ele permite personalizar os cabeçalhos das solicitações e fornece métodos para realizar solicitações GET, POST, PUT e DELETE:

Código
// Make a GET request
honeycomb
  .http()
  .get("/users", { authToken: "myAuthToken" })
  .then((response) => {
    console.log("GET Response:", response);
  })
  .catch((error) => {
    console.error("GET Error:", error);
  });

// Make a POST request
const userData = { name: "John Doe", email: "john@example.com" };
honeycomb
  .http()
  .post("/users", { data: userData })
  .then((response) => {
    console.log("POST Response:", response);
  })
  .catch((error) => {
    console.error("POST Error:", error);
  });

Isso é particularmente interessante porque os desenvolvedores podem acessar APIs de terceiros, como a API Digital Asset Standard (DAS), para consultar outros ativos digitais on-chain fora do jogo.

Esses trechos de código foram adaptados da documentação do Honeycomb Protocol. A documentação do SDK está disponível aqui.

GameShift

O GameShift é uma plataforma lançada pela Solana Labs para que desenvolvedores de jogos integrem facilmente elementos Web3 por meio de uma única API. Seu objetivo é facilitar a criação de experiências Web2 intuitivas e, ao mesmo tempo, aproveitar os benefícios dos jogos na Solana. O GameShift oferece uma experiência de usuário simples no ecossistema Web3 ao cuidar de todas as taxas de gas, interações com a blockchain e carteiras. A API do GameShift tem quatro verticais:

  • Criação de ativos: criação de ativos de jogos com metadados estruturados
  • Negociação de ativos: compra e venda de ativos em USD em marketplaces personalizados, com lançamento previsto para breve
  • Pagamentos: pagamentos com cartão de crédito e integrações de processamento de pagamentos disponíveis em mais de 170 países, com 100% de proteção contra chargebacks
  • Autocustódia de ativos em carteira: permite que os jogadores mantenham e negociem seus ativos em carteiras não custodiais, ou seja, sem senhas ou frases-semente!

Para começar a usar o GameShift, os desenvolvedores podem criar uma conta no console do GameShift, configurar uma organização, adicionar desenvolvedores à organização, adicionar um jogo e gerenciar sua chave de API de desenvolvedor. Todo o processo está descrito aqui.

Uma conta de comerciante é necessária para transações em moeda fiduciária. A conta pode ser criada em duas etapas:

  • Know Your Business (KYB): exige que os desenvolvedores forneçam informações sobre sua empresa para cumprir as leis de transmissão de valores. Atualmente, o GameShift só permite liquidações em moeda fiduciária para contas bancárias domiciliadas nos EUA
  • Configuração de uma conta para liquidação em moeda fiduciária: quando estiverem prontos para habilitar pagamentos em moeda fiduciária em produção, os desenvolvedores deverão entrar em contato com o GameShift para receber um link para o formulário de onboarding de comerciantes. As informações de KYB são definidas por meio desse formulário. A validação pode levar alguns minutos, mas alguns casos podem exigir análise manual

Todas as atividades do GameShift são organizadas em organizações:

Onboarding de usuários

Depois que tudo estiver configurado, os desenvolvedores poderão interagir com a REST API. Eles podem registrar usuários para conceder acesso a recursos do marketplace, ativos on-chain e fluxos de pagamento. Para isso, é necessário fazer uma solicitação POST HTTP para https://api.gameshift.dev/users, usando a chave de API, o endereço de e-mail do usuário e um referenceId — um valor exclusivo, como um UUID — no corpo da solicitação:

Código
curl --request POST \
     --url https://api.gameshift.dev/users \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --header 'x-api-key: ' \
     --data '
{
  "referenceId": "exampleReferenceId",
  "email": "user@example.com"
}

Depois que um usuário é registrado, suas informações e seus ativos podem ser obtidos a qualquer momento. Para buscar essas informações e ativos, faça uma solicitação GET HTTP para https://api.gameshift.dev/users/{the-user-id-you-used-to-register}/assets:

Código
curl --request GET \
     --url https://api.gameshift.dev/users/exampleReferenceId/assets \
     --header 'accept: application/json' \
     --header 'x-api-key:

Se a solicitação for bem-sucedida, uma lista paginada dos ativos do usuário será retornada:

Código
{
  "data": [
    {
      "id": "dcde5bc8-b30b-46b6-b4da-0763953b2484",
      "collectionId": "36c97125-04a5-4dc3-b92a-029d74a42287",
      "attributes": [],
      "name": "Example Asset",
      "description": "Example Description",
      "imageUrl": "https://solana.com/src/img/branding/solanaLogoMark.png",
      "status": "Committed",
      "owner": {
        "address": "",
        "referenceId": "exampleReferenceId"
      }
    }
  ],
  "meta": {
    "page": 1,
    "perPage": 50,
    "totalPages": 1
  }
}

Todos os trechos de código do processo de onboarding estão disponíveis aqui.

Criação de um ativo

Por exemplo, os desenvolvedores podem criar ativos de jogos on-chain de forma programática fazendo uma solicitação POST HTTP para https://api.gameshift.dev/assets:

Código
curl --request POST \
     --url https://api.gameshift.dev/assets \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --header 'x-api-key: ' \
     --data '
{
  "details": {
    "description": "Example description",
    "imageUrl": "https://solana.com/src/img/branding/solanaLogoMark.png",
    "name": "Example Asset",
    "attributes": [
      {
        "displayType": "Formatted Attribute Name",
        "traitType": "attribute-name",
        "value": "attribute-value"
      }
    ]
  },
  "destinationUserReferenceId": "exampleUserId"
}
'

Os ativos exigem os seguintes detalhes:

  • description - uma string de 64 caracteres com informações sobre o ativo
  • name - uma string de 32 caracteres para identificar o ativo
  • imageUrl - um link direto para a imagem que representa o ativo
  • displayType - um título formatado opcional
  • traitType - um nome opcional para a característica
  • value - um campo opcional que representa o valor do atributo

A solicitação POST HTTP também exige o referenceId de um usuário, fornecido pelo campo destinationUserReferenceId. Uma explicação mais detalhada sobre como trabalhar com ativos de jogos está disponível aqui.

Conclusão

A integração da tecnologia blockchain aos jogos, especialmente por meio da Solana, representa um avanço significativo na forma como percebemos e interagimos com mundos digitais. Ferramentas como Anchor, Turbo, Magicblock e os SDKs Solana Unity e Unreal permitem que os desenvolvedores criem novas formas de jogar. Agora é mais fácil do que nunca para os jogadores desenvolverem economias virtuais e interagirem em estruturas sociais inéditas, de forma totalmente transparente e acessível. Plataformas como Honeycomb e GameShift reforçam ainda mais o potencial dos jogos Web3 ao simplificar o processo de desenvolvimento e aumentar o engajamento dos jogadores.

A Solana está na vanguarda dessa revolução nos jogos. A comunidade de jogos da Solana cresce continuamente, com hackathons dedicados e novos jogos surgindo. A Solana Labs e a Solana Foundation lideram iniciativas e criam tutoriais, ferramentas e plataformas para ajudar essa comunidade emergente a crescer. Ao desenvolver sobre a blockchain mais rápida disponível, as possibilidades para o futuro dos jogos são infinitas.

Se você chegou até aqui, anon, agradecemos! Insira seu endereço de e-mail abaixo para nunca perder uma atualização sobre as novidades da Solana. Quer se aprofundar? Entre no nosso Discord e comece hoje mesmo a construir o futuro dos jogos na blockchain de maior desempenho.

Recursos adicionais / Leitura complementar

Artigos relacionados

Assine a Helius

Acompanhe as novidades mais recentes do desenvolvimento Solana e receba atualizações quando publicarmos

Imagem ampliada