NOUVEAU : Essayez l'API Parsed Events Scan
Gaming : comment Solana change les règles du jeu
Blog/Recherche

Gaming : comment Solana change les règles du jeu

Developer Experience Engineer0xIchigo sur X0xIchigo sur LinkedIn0xIchigo sur GitHub
28 min de lecture
Sommaire

Quel est le sujet de cet article ?

Pas vos clés, pas vos cryptos. Cet adage, au cœur de l’éthique crypto, s’applique tout autant aux jeux vidéo. L’intégration des blockchains dans l’univers du gaming va au-delà d’une simple innovation. Il s’agit d’un changement de paradigme qui permet la propriété décentralisée des actifs et l’autonomie. Solana est à l’avant-garde de cette transformation. Elle offre la plateforme de smart contracts la plus rapide pour exploiter les avantages du Web3. Grâce à la vitesse élevée, aux frais faibles et prévisibles ainsi qu’à la faible latence de Solana, les développeurs peuvent créer des expériences de jeu uniques, impossibles à reproduire ailleurs.

Cet article explore le potentiel de la blockchain dans le gaming. Il examine les arguments en faveur du gaming Web3 et les raisons pour lesquelles les développeurs de jeux devraient envisager de créer sur Solana. Il aborde également l’installation, la configuration et l’utilisation de frameworks et de plateformes populaires pour créer des jeux intégrant Solana.

Pourquoi le gaming Web3 ?

Pour les joueurs

Aucun autre jeu vidéo ne propose des objets de collection comparables à ceux de Counter-Strike. Selon leur rareté et leur float, certains des skins les plus rares de Counter Strike 2, c’est-à-dire des apparences d’armes dans le jeu, peuvent valoir des milliers de dollars. Neon, un trader bien connu de la communauté Counter-Strike, possédait un inventaire de skins d’une valeur supérieure à 100 000 $. Le 13 octobre 2023, il a été banni à tort par le système anti-triche de Valve (VAC) après avoir activé la fonctionnalité Anti-lag+ d’AMD. Un bannissement VAC empêche tout échange de l’inventaire d’un joueur. L’inventaire de Neon, estimé à 100 000 $, s’est donc retrouvé définitivement lié à son compte. Valve a officiellement réagi au problème et, heureusement, Neon a pu faire lever son bannissement. Counter-Strike 2 rencontre toujours des problèmes de bannissements injustifiés.

Sur une plateforme de gaming traditionnelle comme Steam, il existe toujours un risque sous-jacent de perdre l’accès aux jeux ou aux objets de collection achetés. Rien n’empêche Valve de vous retirer vos actifs. Cela semble peu probable en raison des graves dommages que subirait sa réputation et de la destruction de communautés entières de joueurs. L’entreprise pourrait toutefois augmenter les taux d’obtention des objets rares et ainsi réduire leur valeur. C’est précisément ce qui s’est produit avec Team Fortress 2. Quelle que soit sa valeur, chaque jeu que vous achetez et chaque objet que vous obtenez en jeu sont gérés par une entité centralisée. Les joueurs sont à la merci des entreprises du secteur. Même Ethereum a été créé à cause du patch 3.10 de World of Warcraft. Vitalik Buterin a longuement évoqué les « horreurs de la centralisation », après que Blizzard a affaibli le sort Siphon de vie de son personnage, ruinant des années de jeu. Les joueurs en ont assez d’être à la merci d’entités centralisées. Le gaming Web3 leur offre une porte de sortie.

Le gaming Web3 représente un changement de paradigme. Il exploite la technologie blockchain pour décentraliser la propriété des actifs et les processus décisionnels. Il garantit transparence et sécurité, tout en permettant aux joueurs de véritablement posséder leurs actifs en jeu sur différentes plateformes. Il en résulte des économies virtuelles, comme le marché des skins de Counter-Strike, qui bénéficient de la transparence, de la sécurité et de la composabilité. Ces économies favorisent de nouveaux modèles de jeu centrés sur l’utilisateur, comme le Play-to-earn (P2E), dans lequel les joueurs reçoivent des récompenses ayant une valeur réelle grâce à leur activité en jeu.

Ce concept est loin d’être marginal. Plusieurs jeux populaires et influents démontrent clairement le potentiel du gaming Web3 à révolutionner le secteur. Par exemple, Decentraland propose un monde virtuel dans lequel les joueurs peuvent acheter, vendre et aménager des biens immobiliers sous forme de NFT. Tokens.com a déboursé plus de 2 millions de dollars pour un bien immobilier au cœur de Decentraland. Cela illustre les possibilités offertes par les économies virtuelles, les expériences numériques et les espaces personnels au sein de l’écosystème Web3. De même, des jeux Play-to-earn comme Axie Infinity et des applications de style de vie comme STEPN, une plateforme move-to-earn, ont attiré l’attention internationale en montrant comment les joueurs peuvent générer des revenus en jouant. Des jeux comme Star Atlas et Aurory ont connu un succès similaire sur Solana. Il ne s’agit pas d’exemples isolés. Ils s’inscrivent dans une tendance plus large où le gaming dépasse le simple divertissement et fusionne avec les systèmes économiques et sociaux du monde réel.

Pour les développeurs

L’avènement du gaming Web3 ouvre de nouvelles perspectives aux développeurs de jeux, bien au-delà des limites du paradigme actuel :

  • Des marchés plus profonds et des garanties de confiance : le gaming Web3 crée des marchés plus profonds et plus robustes. Les développeurs de jeux peuvent toucher une audience mondiale dont les participants bénéficient d’un niveau de confiance supérieur. Tous les droits de propriété et toutes les transactions en jeu sont vérifiables et immuables. Cela est possible grâce à la transparence et à la sécurité inhérentes aux blockchains.
  • Exploitation des programmes on-chain existants : les développeurs peuvent facilement intégrer à leur jeu des programmes existants et les actifs qui leur sont associés. Cela réduit le délai de mise sur le marché tout en leur permettant de se concentrer sur la créativité et l’innovation grâce à la collaboration au sein de l’écosystème
  • Innovations économiques et ludiques : les développeurs peuvent concevoir des boucles de jeu et des boucles économiques complexes qui exploitent d’autres applications ou expériences on-chain. Cette interconnexion permet de créer des univers riches et dynamiques, où les actions effectuées dans un jeu peuvent avoir des répercussions dans un autre
  • Modding encouragé : l’ouverture de la blockchain donne aux développeurs la possibilité de concevoir des jeux favorisant le modding. Cette ouverture peut stimuler une innovation portée par la communauté, dans laquelle les joueurs contribuent à l’évolution du jeu. On passe ainsi d’un environnement à code source fermé à un modèle de développement collaboratif centré sur la communauté

Les blockchains offrent bien plus qu’une simple plateforme de création de jeux. Elles permettent d’inventer de nouvelles formes d’expériences numériques interactives. Elles ouvrent la voie à un écosystème de gaming plus dynamique et participatif.

Pourquoi créer sur Solana ?

Des frais de transaction faibles et prévisibles sont essentiels au gaming Web3. Les joueurs ne veulent pas payer des frais exorbitants pour jouer. Les frais de transaction de Solana sont faibles et souvent inférieurs à 0,001 USD, tandis que les frais moyens hors vote se situent entre 0,000005 et 0,00007 SOL. Ces frais sont également prévisibles grâce aux marchés de frais localisés. Ceux-ci isolent la congestion afin que seules les transactions tentant d’accéder aux zones d’état très sollicitées subissent une hausse des frais. Cette approche diffère des réseaux basés sur le gas, comme Ethereum, où les frais de transaction sont imprévisibles et peuvent dépasser cent dollars pour une simple transaction en période de forte congestion.

L’architecture de Solana offre une composabilité sans équivalent. Pour les joueurs, cela signifie une expérience utilisateur fluide avec un seul wallet. Ils n’ont pas à se soucier de la complexité des bridges entre différentes plateformes. Tout est accessible et interconnecté au sein de l’écosystème Solana. Pour les développeurs de jeux, la composabilité offre une multitude de possibilités. Ils peuvent facilement intégrer et exploiter des programmes on-chain existants, comme le montre le partenariat entre The Remnants et Magic Eden. Cela évite que la liquidité des actifs de jeu soit fragmentée entre d’autres L2 ou shards. Solana favorise un écosystème composable et facilite la collaboration fluide entre les jeux, les communautés et les autres applications du réseau.

Une vitesse élevée et une faible latence sont indispensables au gaming. Des transactions lentes peuvent retarder la mise à jour de l’état du jeu, provoquer un lag insupportable et allonger les temps d’attente. L’expérience utilisateur serait alors moins bonne que dans le gaming traditionnel. Solana est conçue pour traiter un volume élevé de transactions. Elle traite en moyenne 400 transactions générées par les utilisateurs par seconde (TPS), et dépasse 2 000 TPS lors des pics de demande. Avec l’arrivée d’innovations comme Firedancer, Solana pourrait évoluer pour prendre en charge n’importe quelle application grand public traditionnelle. Solana vise également une durée de slot de 400 millisecondes, c’est-à-dire le temps nécessaire à chaque registre pour intégrer les transactions et produire un bloc. Cette durée peut varier entre 500 et 600 millisecondes selon la demande sur le réseau, ce qui en fait la blockchain disponible la plus rapide. Elle constitue donc une base de données en temps réel idéale pour les jeux de stratégie, les jeux au tour par tour, les jeux de construction de villes et les jeux idle.

Les Forever Games sont des jeux entièrement on-chain. Il s’agit du cas le plus poussé d’intégration de la blockchain : l’état et la logique d’un jeu s’exécutent intégralement sur la blockchain. Le résultat est un jeu persistant, connecté à un riche système de protocoles, de dApps et de programmes, avec une faible barrière à l’entrée. En voici quelques exemples sur Solana :

Pour un joueur, un temps de réponse de 400 millisecondes paraît rédhibitoire dans un jeu de course ou de tir en temps réel. Toutefois, tout n’a pas besoin d’être directement placé on-chain. De petites intégrations peuvent être réalisées rapidement, par exemple en utilisant des NFT pour représenter des objets en jeu, des tokens pour les achats intégrés et le wallet du joueur pour l’authentification. De nombreux outils sont disponibles pour commencer dès aujourd’hui à intégrer Solana.

Outils pour créer des jeux Solana

Cet article examine plusieurs frameworks et plateformes populaires permettant de créer des jeux intégrant Solana. Par souci de concision, nous n’abordons pas certains outils, mais vous trouverez des liens vers ceux-ci dans la section de ressources supplémentaires ci-dessous. Il s’agit notamment du Godot Solana SDK et du modèle de démarrage Phaser 3 TypeScript. Dans cet article, nous étudions comment installer, configurer et utiliser les outils suivants :

Anchor

Les frameworks comme Anchor facilitent considérablement le développement de jeux on-chain. Anchor est un framework robuste qui permet de créer rapidement des programmes sécurisés. Il simplifie le processus de développement en réduisant le code répétitif, en gérant divers contrôles de sécurité, en automatisant la génération des bibliothèques clientes et en offrant une configuration de test complète. La manière la plus simple de développer un jeu entièrement on-chain consiste à stocker sa logique et son état dans un programme Anchor. Anchor masque la complexité du modèle de programmation de bas niveau de Solana. Les développeurs peuvent ainsi se concentrer davantage sur la création du jeu que sur les difficultés liées à la SVM.

Installation

Rust est nécessaire pour utiliser Anchor. Vous pouvez l’installer ici ou avec la commande suivante :

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

Anchor recommande également aux personnes qui découvrent Rust de lire les neuf premiers chapitres du livre Rust. Ils couvrent les fondamentaux, car une connaissance avancée de Rust n’est généralement pas nécessaire pour écrire des programmes Anchor.

Anchor nécessite également la suite d’outils Solana :

Code
# 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"

Vous pouvez vérifier que la version souhaitée de solana est installée en exécutant la commande solana --version.

Yarn est également requis. Vous pouvez l’installer avec le gestionnaire de paquets npm : npm install --global yarn.

Il est recommandé d’installer Anchor à l’aide du gestionnaire de versions Anchor (avm). Vous pouvez l’installer avec cargo : cargo install --git <https://github.com/coral-xyz/anchor> avm --locked --force. Nous pouvons ensuite installer et utiliser la dernière version :

Code
avm install latest
avm use latest

# Verify the installation
avm --version

La documentation d’Anchor propose également un guide d’installation détaillé.

Utilisation et exemples

SolanaCiv est entièrement développé on-chain avec Anchor. La gestion des ressources, le recrutement d’unités, la recherche de nouvelles technologies, les combats contre les barbares et les échanges se déroulent tous on-chain. Le projet est également open source ! Vous pouvez donc vous en servir comme référence pour analyser la logique et l’état du jeu afin de comprendre comment tout est stocké on-chain.

Clockwork est un moteur d’automatisation open source pour Solana. Il est particulièrement utile pour le développement de jeux, car il facilite la planification des transactions et la création de programmes automatisés pilotés par des événements. Vous pouvez l’installer avec la commande suivante : cargo install -f --locked clockwork-cli. Il s’intègre parfaitement à Anchor. Vous trouverez ici une liste d’exemples d’utilisation de Clockwork.

Solana Playground est un environnement de développement dans le navigateur qui permet de tester et de déployer des programmes. Son environnement de développement intégré (IDE) en fait un excellent choix pour les développeurs qui découvrent Anchor et souhaitent apprendre à créer des jeux sur Solana. Il propose plusieurs tutoriels Anchor consacrés au gaming on-chain. Par exemple, Tiny Adventure est un tutoriel accessible aux débutants pour créer un jeu on-chain. Il explique comment utiliser Anchor pour déplacer un personnage vers la gauche et la droite, ainsi qu’une Program Derived Address (PDA) pour enregistrer les données du jeu. Il montre également comment configurer un front-end dans Next.js avec l’adaptateur de wallet Solana. Le code final est disponible ici.

Pour créer rapidement un programme Anchor avec un client TypeScript, utilisez la commande npx create-solana-game suivie du nom de votre jeu. Cette commande simplifie le développement avec Anchor et TypeScript en structurant un tout nouveau projet. L’outil a été développé par Jonas Hahn et Beeman. Il est disponible dans le dépôt GitHub solana-developers.

Turbo

Turbo est un moteur de jeu 2D nouvelle génération et une marketplace conçus pour donner plus de moyens aux développeurs indépendants. Il comprend plusieurs fonctionnalités innovantes :

  • Les jeux se rechargent à chaud dès que le code, les shaders ou les sprites sont modifiés
  • Les jeux s’exécutent en mode headless pour vous permettre de vérifier leur état sur des serveurs distants
  • Le moteur repose sur WebAssembly et WebGPU, ce qui lui permet de fonctionner sur n’importe quelle plateforme
  • Les API intégrées au moteur sont accessibles aux débutants

Turbo est développé en Rust par Jozanza. Comme il repose sur Rust, les développeurs peuvent facilement réutiliser les structs Anchor dans leurs programmes sans avoir besoin de SDK ni de plugins. Le projet en est encore à ses débuts. Son site web contient toutefois plusieurs exemples exécutables dans le navigateur, qui illustrent la puissance de Turbo et son expérience développeur intuitive. Un tutoriel « Hello, world! » est également disponible ici.

Installation

Pour commencer à utiliser Turbo, nous devons d’abord installer toutes les dépendances Rust nécessaires :

Code
# 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

Nous devons ensuite télécharger et exécuter le programme d’installation de l’interface en ligne de commande (CLI) de Turbo :

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

Une fois l’installation terminée, nous pouvons utiliser la commande turbo-cli -h pour vérifier que la CLI Turbo est correctement installée. Cette commande doit afficher les informations d’utilisation de Turbo :

Code
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

Processus de développement

Turbo dispose de plusieurs macros qui simplifient le processus de développement. Pour rappel, les macros Rust sont de puissants outils de métaprogrammation dédiés à la génération de code, c’est-à-dire du code qui écrit du code. Elles permettent de réduire le code répétitif et de créer des modèles de code plus expressifs.

La macro println est une implémentation personnalisée de la macro standard println. Elle formate une chaîne, puis la transmet au système de journalisation du moteur de jeu :

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

La macro cfg sert à la configuration. Elle expose la fonction config, qui renvoie un entier 64 bits combinant un pointeur vers une chaîne de configuration et la longueur de celle-ci. Cela permet de transmettre des données de configuration de Rust vers un autre environnement, comme WebAssembly :

Code
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)
        }
    };
}

La macro init facilite la gestion de l’état du jeu. Elle définit une struct et fournit des méthodes pour charger et enregistrer son état. Elle implémente les méthodes load et save pour la struct, en utilisant Borsh pour la persistance de l’état :

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

La macro go sert à définir la logique principale d’un jeu. Elle encapsule un bloc de code dans une fonction pouvant être appelée depuis un environnement externe, comme WebAssembly. Elle définit également un point d’entrée pour la logique du jeu et une fonction run_snapshot permettant d’exécuter le jeu à partir d’un instantané de son état :

Code
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() })
        }
    };
}

Turbo utilise également la macro strike de la crate struckstruck afin d’améliorer les capacités de définition des structs de Rust. En règle générale, les structs imbriquées doivent être définies séparément. La macro strike permet de définir une struct et ses structs imbriquées directement dans celle-ci. Cette fonctionnalité simplifie le code et rend les structures de données complexes plus lisibles et plus concises. Elle applique également automatiquement la sérialisation Borsch à l’ensemble de la structure. Enfin, elle propage la macro derive de la struct de niveau supérieur à toutes les structs imbriquées.

Le workflow de développement complet d’un projet Turbo est donc le suivant :

Code
// 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();
	...
}

Prise en charge de Solana

Turbo se distingue des autres moteurs de développement de jeux basés sur Rust, car il offrira une prise en charge complète de Solana. Par exemple, il peut récupérer les données d’un compte depuis un RPC et les décoder en seulement deux lignes de code. Il s’abonne également automatiquement aux mises à jour du compte via WebSockets, afin que vos données restent toujours à jour :

Code
// 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

Magicblock est un framework open source polyvalent pour créer des jeux on-chain. Il permet à chacun de créer des jeux et d’y jouer sur Solana ou la SVM. Sa riche suite d’outils permet aux développeurs de créer des jeux entièrement on-chain ou d’intégrer Solana à des jeux existants. Elle comprend les fonctionnalités suivantes :

Avec toutes ces fonctionnalités, Magicblock vise à masquer la complexité afin que les développeurs puissent se concentrer sur la création de la meilleure expérience utilisateur possible. Ce framework sous licence MIT est maintenu par Magicblock Labs, c’est-à-dire Andrea et Peak.

Solana Unity SDK

Le Solana Unity SDK est un package open source doté d’outils qui permettent aux développeurs de jeux d’intégrer à leurs jeux Unity des NFT, des tokens et des programmes on-chain basés sur Solana. Le SDK exploite Solana Unity Core, un framework compatible avec la norme .NET 2.0 qui intègre Solana à l’écosystème .NET. Il propose de nombreuses fonctionnalités, notamment une couverture complète de l’API JSON RPC, la décompilation des instructions, la prise en charge de Solana Mobile Stack et des opérations DEX natives.

Vous trouverez ici une liste d’exemples de jeux créés dans Unity avec le Solana Unity SDK.

Installation, configuration et utilisation

Pour créer avec Unity, téléchargez Unity Hub ici. Unity Hub gère plusieurs installations de l’éditeur Unity, ce qui vous permet de travailler sur des projets et d’en créer de nouveaux avec différentes versions. Avant de poursuivre, vérifiez que votre système respecte les exigences suivantes :

  • Système d’exploitation : Windows 7 SP1+, 8 ou 10, versions 64 bits uniquement ; Mac OS X 10.13+ ; Ubuntu 16.04, 18.04 et CentOS 7
  • GPU : une carte graphique compatible DX10 (shader model 4.0)

Une fois Unity installé, nous pouvons créer et ouvrir un nouveau projet.

Après avoir ouvert votre nouveau projet, ouvrez la fenêtre Package Manager. Elle est accessible depuis le menu supérieur de Unity, via Window > Package Manager.

Une fois la fenêtre ouverte, cliquez sur le bouton d’ajout (+) dans la barre d’état. Les options permettant d’ajouter les packages s’affichent. Sélectionnez ensuite « Add package from git URL » dans le menu.

Saisissez l’URL Git https://github.com/magicblock-labs/Solana.Unity-SDK.git dans la zone de texte, puis cliquez sur « Add ». Vous pouvez installer une version spécifique du package en saisissant https://github.com/magicblock-labs/Solana.Unity-SDK.git#X.Y.Z et en remplaçant X.Y.Z par la version souhaitée. Toutes les versions disponibles sont répertoriées ici.

Une fois le Solana Unity SDK installé, importez Samples à l’aide de l’inspecteur Package Manager. Celui-ci comprend un exemple de scène que vous pouvez consulter ou modifier pour l’intégrer à votre projet Unity. Cette scène, située dans le dossier Scenes, présente un exemple d’authentification par wallet et de swap de tokens via Orca. Le dossier Scripts contient différents exemples de scripts, notamment celui des swaps Orca. Le script Web3.cs peut être associé à n’importe quel objet de votre projet. Ce script constitue le principal point d’entrée du Solana Unity SDK. Il s’agit d’un singleton qui gère la connexion à Solana et facilite la connexion aux wallets, la signature des transactions et bien plus encore. Le dossier Prefabs contient des modèles qui stockent les configurations d’objets. Vous pouvez les utiliser pour créer des instances d’un même actif et les réutiliser dans l’ensemble de votre projet.

La chaîne YouTube de Magicblock propose des tutoriels expliquant comment connecter des wallets Solana à Unity, récupérer la clé publique et le solde d’un wallet, effectuer des tests avec des wallets intégrés au jeu et créer un moteur d’échecs on-chain.

Le dépôt GitHub du Solana Unity SDK contient également plusieurs exemples de scripts, allant du décodage d’instructions à la création de transactions.

Exemple d’implémentation de Jupiter

En plus d’Orca, Jupiter est nativement pris en charge par le Solana Unity SDK. Le SDK propose des méthodes utilitaires qui facilitent l’obtention de cotations de swap ainsi que la création et l’envoi de transactions de swap.

Pour effectuer un swap, nous devons d’abord créer une instance de IDexAggregator en fournissant un compte par défaut. Cette instance servira à interagir avec Jupiter :

Code
IDexAggregator dex = new JupiterDexAg(Web3.Account);

Nous définissons ensuite les tokens que nous souhaitons échanger. Dans cet exemple, nous échangeons des SOL contre des BONK :

Code
TokenData tokenA = await dex.GetTokenBySymbol("SOL");
TokenData tokenB = await dex.GetTokenBySymbol("BONK");

Nous obtenons ensuite une cotation pour le swap. Voici à quoi elle ressemblerait pour l’échange de 1 SOL :

Code
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);

Nous pouvons également afficher le chemin d’acheminement du swap pour plus de transparence :

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

Nous pouvons maintenant générer la transaction de swap, la signer avec notre wallet et l’envoyer :

Code
Transaction tx = await dex.Swap(swapQuote);
await Web3.Wallet.SignAndSendTransaction(tx);

Porter un programme vers Unity

Les développeurs peuvent utiliser le package Solana Unity Anchor pour intégrer des programmes Anchor dans Unity. Ce package contient un convertisseur d’IDL vers C#. Le convertisseur simplifie la conversion des IDL Anchor, c’est-à-dire les représentations JSON des programmes Solana, en code C# pour les projets Unity. Le processus d’intégration comporte deux étapes principales :

  • Installation : la commande dotnet tool install -g Solana.Unity.Anchor.Tool permet d’installer Solana Unity Anchor Tool. Le flag -g garantit l’installation globale du package, ce qui évite de devoir installer cet outil pour chaque nouveau projet
  • Génération de code : la commande dotnet anchorgen -i idl/file.json -o src/ProgramCode.cs permet de générer la représentation C# du programme. Cette commande convertit l’IDL indiqué en un fichier C# prêt à être utilisé dans Unity.

En suivant ces étapes, les développeurs peuvent porter efficacement des programmes Solana vers leur environnement Unity. Vous trouverez ici un tutoriel vidéo détaillé de ce processus réalisé par Jonas Hahn.

SOAR

Solana On-Chain Achievement and Ranking (SOAR) est un programme conçu pour offrir une solution fluide permettant de gérer les classements, les succès, les profils des joueurs et la distribution automatique des récompenses sur Solana. Il prend notamment en charge les fonctionnalités suivantes :

  • Création de classements
  • Gestion des succès
  • Prise en charge d’un client TypeScript
  • Interaction avec le programme SOAR au moyen d’appels Cross-Program Invocation (CPI)

La prise en charge du Solana Unity SDK est en cours de développement et devrait être bientôt disponible.

SOAR s’intègre facilement à un projet avec quelques lignes de code. Par exemple :

Code
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]);

Le code ci-dessus provient directement de la documentation de Magicblocks sur SOAR. L’extrait commence par importer les modules nécessaires depuis @magicblock-labs/soar-sdk, notamment SoarProgram, GameType et Genre.

La classe SoarProgram permet au client d’accéder à chaque instruction du programme SOAR sur la blockchain. Elle inclut également des fonctionnalités permettant de dériver des PDA et de récupérer plusieurs comptes.

Ensuite, le code initialise un fournisseur Anchor (anchor.AnchorProvider.env()) et le définit comme fournisseur par défaut pour les opérations suivantes (anchor.setProvider(provider)). Un client SoarProgram est ensuite créé avec le fournisseur précédemment défini.

L’extrait commence à initialiser un nouveau jeu. Une nouvelle paire de clés est générée, puis les informations essentielles du jeu sont définies, notamment son titre, sa description, son genre (par exemple, Genre.Action) et son type (par exemple, GameType.Web). Une paire de clés pour les métadonnées NFT du jeu est également générée. Une liste d’autorisations (_auths) est ensuite préparée afin de définir le contrôle d’accès au sein du jeu.

La méthode initializeNewGame est appelée sur le client SOAR avec la clé publique, le titre, la description, le genre, le type, les métadonnées NFT et les autorisations du jeu. Cette méthode renvoie un objet newGame et prépare l’envoi de la transaction du nouveau jeu. La transaction est envoyée et confirmée à l’aide de la méthode sendAndConfirmTransaction disponible sur le client SOAR. La paire de clés du jeu sert de signataire pour la transaction, garantissant ainsi que celle-ci est autorisée par le créateur du jeu.

Initialiser un client et configurer un nouveau jeu sur la blockchain avec SOAR est simple. Nous pouvons maintenant utiliser GameClient pour enregistrer notre jeu, créer un classement et accéder à l’état de notre jeu. Les possibilités sont infinies.

L’adresse du programme SOAR est SoarNNzwQHMwcfdkdLc6kvbkoMSxcHy89gTHrjhJYkk et sa documentation TypeScript est disponible ici.

Solana Unreal SDK

Le Solana Unreal SDK est un plugin et une boîte à outils qui permettent aux développeurs de créer des jeux blockchain sur Solana avec Unreal Engine 5. La boîte à outils contient des modèles de démarrage pour les jeux en ligne massivement multijoueurs (MMO) intégrant Solana, notamment un modèle de serveur de jeu. Elle comprend également des fonctionnalités telles que :

  • Toutes les fonctionnalités de Solnet en C++ et avec Blueprint Visual Scripting
  • Un système de portefeuille intégré au jeu avec protection et chiffrement des données
  • Création de NFT Metaplex
  • Traitement des paiements

Le plugin exploite Solnet et la puissance de l’environnement d’exécution .NET afin que les développeurs puissent communiquer directement avec Solana sans créer de zéro une bibliothèque C++ complète. LinkStream peut envoyer des messages de transaction depuis les jeux vers des portefeuilles tels que Tranquility, par l’intermédiaire de serveurs TCP et de protocoles clients. L’équipe de Star Atlas a initialement créé le SDK, et Bifrost a récemment créé un fork du code et l’a mis à jour. Pour la prochaine section consacrée à l’installation, nous nous appuierons sur la version de l’équipe Star Atlas. Le processus est identique pour Bifrost.

Installation

Nous devons d’abord installer l’Epic Games Launcher pour utiliser Unreal Engine. Nous devons ensuite créer un compte Epic Games et nous connecter. Une fois connecté, accédez à l’onglet Unreal Engine, puis cliquez sur le bouton Installer pour télécharger la version la plus récente. Un guide détaillé de ce processus est disponible ici. Notez la configuration système recommandée pour Unreal Engine 5 :

  • Windows 10 64 bits, processeur Intel ou AMD à quatre cœurs, 2,5 GHz ou plus, 8 Go de RAM
  • macOS Big Sur, processeur Intel à quatre cœurs, 2,5 GHz ou plus, 8 Go de RAM
  • Linux Ubuntu 18.04, processeur Intel ou AMD à quatre cœurs, 2,5 GHz ou plus, 32 Go de RAM

Ouvrez l’Epic Games Launcher et lancez la version installée d’Unreal :

Créez un nouveau projet et sélectionnez C++ comme modèle de projet :

Fermez maintenant l’éditeur et ouvrez le dossier Project Location défini lors de la création du projet. Créez ensuite un nouveau dossier Plugins dans le répertoire racine :

Copiez le plugin dans le répertoire Plugins. Faites un clic droit sur le fichier .uproject dans le répertoire racine, puis sélectionnez Generate Visual Studio project files. Double-cliquez sur le fichier .sln et ouvrez le projet avec votre IDE C++. Ouvrez ensuite le fichier situé sous Source/<ProjectName>/<ProjectName>.build.cs. Ajoutez le nom du plugin à PublicDependencyModuleNames. Dans notre cas, nous devons saisir Foundation :

Ajoutez le nom du plugin à notre fichier .uproject :

Fermez votre IDE et générez à nouveau les fichiers du projet. Ouvrez ensuite la solution de votre projet, c’est-à-dire le fichier .sln. Le processus d’installation est alors terminé.

Utilisation

Tout le contenu lié au plugin se trouve sous Plugins > Solana SDK dans le navigateur de contenu. Un blueprint LinkStream est disponible sous Plugins > Solana SDK Content > Blueprints. Ce blueprint permet aux développeurs de communiquer avec Solnet. La carte sandbox située dans le dossier Maps peut servir de référence pour configurer correctement le Solana SDK. Une présentation de l’utilisation générale, de la manière de personnaliser votre wrapper LinkStream et de la façon d’interagir avec l’API REST pour l’authentification du serveur est disponible sur le GitHub du Solana Unreal SDK. Une présentation plus détaillée des interactions avec Solana au moyen de l’Unreal SDK est disponible ici.

L’accent mis par Unreal sur les optimisations et les effets de post-traitement en 3D permet de créer des jeux photoréalistes, contrairement à d’autres éditeurs comme Unity. Star Atlas est un exemple populaire de cet hyperréalisme. Star Atlas est un jeu de stratégie immersif qui vous entraîne dans les profondeurs de l’espace. Il regorge d’opportunités, de conquêtes territoriales et d’intrigues politiques. D’autres jeux, comme Yaku Corp, exploitent le photoréalisme d’Unreal Engine pour créer des MMORPG immersifs.

Honeycomb

Honeycomb est un protocole développé par Tumi Labs qui vise à simplifier le processus de développement des jeux Web3. Honeycomb est une suite de programmes sur la blockchain et d’outils de compression d’état qui prennent en charge les fonctions essentielles du cycle de vie d’un jeu. Tous les programmes sont conçus pour être interopérables et modulaires. Ils peuvent également être personnalisés pour répondre aux besoins propres à chaque développeur. Leur boîte à outils de développement d’infrastructure se concentre sur les fonctions principales suivantes :

  • Récompenses des joueurs inactifs (staking)
  • Quêtes (missions)
  • Coffres à butin ou prix aléatoires par RNG (tirages au sort)
  • Guildes / groupes
  • Jetons de jeu (dépositaires et non dépositaires)
  • Actifs numériques modifiables
  • Création et gestion d’actifs numériques
  • Profils des joueurs
  • Structures tarifaires

Leurs outils se répartissent dans les catégories suivantes :

  • Hive Control : le programme principal qui gère toutes les autorisations et délégations des autorités des programmes dans Honeycomb
  • Asset Hub : une suite d’outils permettant de créer et de gérer des actifs en jeu
  • Nectar Utility : une suite d’outils utilitaires conçus pour permettre aux NFT d’offrir des fonctionnalités de jeu uniques, telles que les récompenses en jetons pour inactivité (staking), les quêtes et les coffres à butin
  • Buzz Kit : une suite d’outils facilitant la création de guildes en jeu. Tumi Labs prévoit également de développer, dans cette boîte à outils, des programmes de matchmaking et de gestion de l’état des jeux

Installation

Les développeurs peuvent interagir avec Honeycomb à l’aide de son SDK JavaScript et de @solana/web3.js :

Code
# Using npm
npm install @solana/web3.js @honeycomb-protocol/hive-control

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

Exemple d’utilisation

Une fois l’installation terminée, les développeurs peuvent initialiser un objet Honeycomb avec un objet Connection de Solana :

Code
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")
);

À partir de là, les possibilités sont infinies. Les développeurs peuvent, par exemple, interagir avec IdentityClient pour gérer les identités et les profils des utilisateurs. guestIdentity est l’identité par défaut utilisée comme espace réservé jusqu’à ce qu’une paire de clés ou un portefeuille soit enregistré auprès de l’instance Honeycomb. Une paire de clés peut être associée en tant qu’identité avec la commande suivante : honeycomb.use(keypairIdentity(<keypair>);. De même, un objet portefeuille (Solana Wallet Adapter) peut être enregistré en tant qu’identité à l’aide de la fonction walletIdentity disponible sur l’instance Honeycomb. Les identités peuvent servir à l’authentification, notamment pour signer des messages ou des transactions.

Autre exemple intéressant : HttpClient. Ce module facilite les requêtes HTTP avec Axios ou Fetch et fournit des fonctionnalités liées à HTTP. Il permet de personnaliser les en-têtes de requête et propose des méthodes pour effectuer des requêtes GET, POST, PUT et DELETE :

Code
// 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);
  });

Cette fonctionnalité est particulièrement intéressante, car les développeurs peuvent accéder à des API tierces, comme l’API Digital Asset Standard (DAS), afin d’interroger d’autres actifs numériques sur la blockchain qui se trouvent en dehors du jeu.

Ces extraits de code sont adaptés de la documentation de Honeycomb Protocol. La documentation du SDK est disponible ici.

GameShift

GameShift est une plateforme lancée par Solana Labs qui permet aux développeurs de jeux d’intégrer facilement des éléments Web3 au moyen d’une API unique. Elle vise à faciliter la création d’expériences Web2 conviviales tout en exploitant les avantages des jeux sur Solana. GameShift offre une expérience utilisateur fluide au sein de l’écosystème Web3 en prenant en charge tous les frais de gas, les interactions avec la blockchain et les portefeuilles. L’API GameShift comporte quatre axes :

  • Création d’actifs : création d’actifs de jeu avec des métadonnées structurées
  • Échange d’actifs : achat et vente d’actifs en USD sur des places de marché aux couleurs de la marque, dont le lancement est prévu prochainement
  • Paiements : paiements par carte bancaire et intégrations de traitement des paiements pris en charge dans plus de 170 pays, avec une protection à 100 % contre les rétrofacturations
  • Auto-garde des actifs du portefeuille : permet aux joueurs de détenir et d’échanger leurs actifs dans des portefeuilles non dépositaires, sans mots de passe ni phrases de récupération !

Pour commencer à utiliser GameShift, les développeurs peuvent créer un compte sur la console GameShift, configurer une organisation, y ajouter des développeurs, ajouter un jeu et gérer leur clé API de développeur. L’ensemble du processus est décrit ici.

Un compte marchand est requis pour les transactions en monnaie fiduciaire. Il peut être créé en deux étapes :

  • Know Your Business (KYB) : les développeurs doivent fournir des informations sur leur entreprise afin de respecter la législation relative aux transferts d’argent. Actuellement, GameShift ne prend en charge les règlements en monnaie fiduciaire que vers des comptes bancaires domiciliés aux États-Unis
  • Configuration d’un compte de règlement en monnaie fiduciaire : lorsqu’ils sont prêts à activer les paiements en monnaie fiduciaire en production, les développeurs doivent contacter GameShift pour obtenir un lien vers le formulaire d’intégration des marchands. Les informations KYB sont fournies au moyen de ce formulaire. La validation peut prendre quelques minutes, mais certains cas peuvent nécessiter une vérification manuelle

Toutes les activités GameShift sont structurées au sein d’organisations :

Intégration des utilisateurs

Une fois la configuration terminée, les développeurs peuvent interagir avec l’API REST. Ils peuvent enregistrer des utilisateurs afin de leur donner accès aux fonctionnalités de la place de marché, aux actifs sur la blockchain et aux flux de paiement. Pour ce faire, ils doivent envoyer une requête POST HTTP à https://api.gameshift.dev/users en incluant leur clé API, l’adresse e-mail de l’utilisateur et un referenceId (une valeur unique, comme un UUID) dans le corps de la requête :

Code
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"
}

Une fois l’utilisateur enregistré, ses informations et ses actifs peuvent être récupérés à tout moment. Pour les récupérer, une requête GET HTTP peut être envoyée à https://api.gameshift.dev/users/{the-user-id-you-used-to-register}/assets :

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

En cas de réussite, une liste paginée des actifs de l’utilisateur est renvoyée :

Code
{
  "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
  }
}

Tous les extraits de code du processus d’intégration sont disponibles ici.

Création d’un actif

Par exemple, les développeurs peuvent créer des actifs de jeu sur la blockchain par programmation en envoyant une requête POST HTTP à https://api.gameshift.dev/assets :

Code
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"
}
'

Les actifs nécessitent les informations suivantes :

  • description - une chaîne de 64 caractères fournissant des informations sur l’actif
  • name - une chaîne de 32 caractères permettant d’identifier l’actif
  • imageUrl - un lien direct vers l’image qui représente l’actif
  • displayType - un titre formaté facultatif
  • traitType - un nom facultatif pour la caractéristique
  • value - un champ facultatif représentant la valeur de l’attribut

La requête POST HTTP nécessite également le referenceId d’un utilisateur, fourni par le champ destinationUserReferenceId. Une présentation plus détaillée de l’utilisation des actifs de jeu est disponible ici.

Conclusion

L’intégration de la technologie blockchain dans les jeux, notamment au moyen de Solana, représente une avancée majeure dans notre façon de percevoir les mondes numériques et d’interagir avec eux. Des outils tels qu’Anchor, Turbo, Magicblock ainsi que les SDK Solana pour Unity et Unreal permettent aux développeurs de créer de nouvelles façons de jouer. Il est désormais plus facile que jamais pour les joueurs de développer des économies virtuelles et d’interagir dans des matrices sociales inédites, de manière totalement transparente et accessible. Des plateformes telles que Honeycomb et GameShift illustrent encore davantage le potentiel des jeux Web3 en simplifiant le processus de développement et en renforçant l’engagement des joueurs.

Solana est à l’avant-garde de cette révolution du jeu vidéo. Sa communauté de joueurs et de développeurs connaît une croissance régulière, portée par des hackathons dédiés et l’apparition de nouveaux jeux. Solana Labs et Solana Foundation pilotent des initiatives et créent des tutoriels, des outils et des plateformes pour soutenir le développement de cette communauté émergente. Les possibilités d’évolution du jeu vidéo sont infinies lorsqu’on s’appuie sur la blockchain la plus rapide disponible.

Si vous avez lu jusqu’ici, anon, merci ! Saisissez votre adresse e-mail ci-dessous pour ne manquer aucune actualité de Solana. Prêt à aller plus loin ? Rejoignez notre Discord pour commencer dès aujourd’hui à construire l’avenir du jeu vidéo sur la blockchain la plus performante.

Ressources supplémentaires / Pour aller plus loin

Articles associés

Abonnez-vous à Helius

Suivez les dernières actualités du développement sur Solana et recevez une notification à chaque publication

Image agrandie