Dans ce tutoriel, je vais vous guider tout au long du processus de création d'uncontrat intelligent de jeu de désà l'aide de Sui Move.

Ce contrat permet aux joueurs de parier surle résultat d'un lancer de dés, un administrateur gérant la cagnotte. À la fin, vous aurez un contrat pleinement fonctionnel et une solide compréhension de plusieurs concepts clés de Sui Move.

Présentation

Le contrat de jeu de dés que nous allons créer permet les fonctionnalités suivantes :

• Initialisation : le créateur du contrat configure le jeu.
• Gestion administrative : un administrateur peut déposer des jetons dans la cagnotte et les retirer si nécessaire.
• Interaction avec les joueurs : les joueurs participent en devinant le résultat du lancer de dés et en plaçant des paris.

Ce didacticiel part du principe que vous avez une compréhension de base de Sui Move et se concentre sur l'introduction de nouveaux concepts par le biais d'une mise en œuvre pratique. Avant de plonger dans le code, explorons les concepts clés que vous allez rencontrer :

1.1 Ajouter des dépendances :

Pour utiliser les jetons d'un autre contrat (par exemple, un contrat de jeton de robinet), vous devez l'ajouter en tant que dépendance dans votre projet. Cela se fait en mettant à jour le Move.tomldossier de votre contrat :

[dependencies]
coin_duck = { local = "../coin_duck"”}

Ici, coin_duck est le contrat de jeton du robinet situé sur le chemin spécifié. Le contrat dépendant doit également spécifier son champ published-at dans son propre Move.toml avec l'ID de package obtenu lors de la publication, comme suit : rouille

published-at = "packageId_from_publication"

1.2 Utiliser des assertions

Les assertions garantissent que certaines conditions sont remplies lors de l'exécution du contrat. La assert!macro vérifie une condition et, en cas d'échec, renvoie une erreur et interrompt l'exécution. Cela est utile pour éviter les états non valides, tels que le fait de miser plus que le solde d'un joueur.

1.3 Génération de nombres aléatoires

L'équité dans le jeu de dés repose sur la génération de nombres aléatoires. Sui Move fournit le randommodule à cette fin. Vous allez créer un RandomGeneratorobjet et l'utiliser pour générer un nombre aléatoire compris entre 1 et 6, simulant un lancer de dés.

1.4 Travailler avec Coin and Balance

Dans Sui Move, lesjetonssont gérés à l'aide des modules de pièces et de solde :

• Pièce : enveloppe autour de Balance, utilisée pour transférer des jetons.

• Solde : représente le montant réel du jeton, permettant des opérations telles que le fractionnement et la fusion.

Les principales méthodes sont les suivantes :

• coin : :value (in_coin) : renvoie la valeur totale d'un objet Coin.
• coin : :take (&mut balance, amount, ctx) : extrait un montant spécifié d'un solde pour créer une pièce.
• in_coin.balance_mut () .split (amount) : divise un montant spécifié du solde d'une pièce.
• balance.join (balance) : fusionne un solde avec un autre.

Ces opérations seront utilisées pour gérer la cagnotte du jeu et les paris des joueurs.

Le contrat du jeu de dés

Voici le code complet du contrat du jeu de dés, suivi d'explications détaillées :

/// Game: Dice rolling. Players bet and guess the number. If correct, they win an amount equal to their bet; if incorrect, the bet goes to the game pool.

module game_duck:game_duck;

use sui::balance::{Self, Balance};
use sui::coin::{Self, Coin};
use sui::random::{Random, new_generator, generate_u8_in_range};
use coin_duck::duckfaucet::DUCKFAUCET;

const ErrorUserInsufficient: u64 = 0x101;
const ErrorGameInsufficient: u64 = 0x102;

public struct Game has key {
    id: UID,
    pool_amount: Balance<DUCKFAUCET>,
}

public struct Admin has key {
    id: UID,
}

fun init(ctx: &mut TxContext) {
    let game = Game {
        id: object::new(ctx),
        pool_amount: balance::zero()
    };
    transfer::share_object(game);

    let admin = Admin { id: object::new(ctx) };
    transfer::transfer(admin, ctx.sender());
}

public entry fun addCoinToGamePool(game: &mut Game, in_coin: &mut Coin<DUCKFAUCET>, amount: u64, _: &mut TxContext) {
    let value = coin::value(in_coin);
    assert!(amount <= value, ErrorUserInsufficient);
    let coin_balance = in_coin.balance_mut().split(amount);
    game.pool_amount.join(coin_balance);
}

public entry fun removeCoinFromGamePool(_: &Admin, game: &mut Game, amount: u64, ctx: &mut TxContext) {
    assert!(game.pool_amount.value() >= amount, ErrorGameInsufficient);
    let coin = coin::take(&mut game.pool_amount, amount, ctx);
    transfer::public_transfer(coin, ctx.sender());
}

entry fun play(game: &mut Game, random: &Random, guess_num: u8, in_coin: &mut Coin<DUCKFAUCET>, amount: u64, ctx: &mut TxContext) {
    assert!(game.pool_amount.value() >= (amount * 3), ErrorGameInsufficient);
    assert!(in_coin.balance().value() >= amount, ErrorUserInsufficient);

    let mut g = new_generator(random, ctx);
    let win_num = generate_u8_in_range(&mut g, 1, 6);

    if (win_num == guess_num) {
        let reward_coin = coin::take(&mut game.pool_amount, amount, ctx);
        in_coin.join(reward_coin);
    } else {
        addCoinToGamePool(game, in_coin, amount, ctx);
    }
}

Structure de répartition du code

• Jeu : un objet partagé avec un identifiant unique et un pool_amount (Balance) pour stocker la cagnotte.
• Admin : objet clé appartenant à l'administrateur pour l'initialisation (init) gérant le pool.

Initialisation (init) :

• Crée un objet de jeu avec une cagnotte vide et le partage publiquement.
• Crée un objet Admin et le transfère au créateur du contrat.

Ajouter au pool (AddCoinToGamePool)

• Extrait un montant spécifié de l'in_coin de l'administrateur.
• Utilise assert ! pour s'assurer que la pièce a une valeur suffisante.
• Divise le montant du solde de in_coin et le fusionne dans le pool_amount du jeu.

Résultat :

• Victoire : si l'estimation correspond au résultat, une récompense égale à la mise est prélevée sur le pool et fusionnée dans l'in_coin du joueur.
• Perdre : si elle est incorrecte, la mise est déduite de in_coin et ajoutée au pool via AddCoinToGamePool.