En este tutorial, te guiaré a través del proceso de creación de uncontrato inteligente para un juego de didoscon Sui Move.

Este contrato permite a los jugadores apostar alresultado de una tirada de dados, y un administrador gestiona la bolsa de premios. Al final, tendrás un contrato totalmente funcional y un conocimiento sólido de varios conceptos clave de Sui Move.

Introducción

El contrato de juego de dados que crearemos permite las siguientes funcionalidades:

• Inicialización: el creador del contrato configura el juego.
• Gestión administrativa: un administrador puede depositar fichas en la bolsa de premios y retirarlas según sea necesario.
• Interacción con los jugadores: los jugadores participan adivinando el resultado de la tirada de dados y haciendo apuestas.

Este tutorial asume que tienes un conocimiento básico de Sui Move y se centra en la introducción de nuevos conceptos a través de la implementación práctica. Antes de profundizar en el código, exploremos los conceptos clave que encontrarás:

1.1 Añadir dependencias:

Para usar los tokens de otro contrato (por ejemplo, un contrato de token de grifo), debes añadirlos como una dependencia en tu proyecto. Esto se hace actualizando el Move.tomlarchivo de tu contrato:

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

Aquí, coin_duck es el contrato de token del grifo ubicado en la ruta especificada. El contrato dependiente también debe especificar su campo published-at en su propio Move.toml con el ID del paquete obtenido en el momento de la publicación, de la siguiente manera: óxido

published-at = "packageId_from_publication"

1.2 Uso de aserciones

Las afirmaciones garantizan que se cumplan ciertas condiciones durante la ejecución del contrato. La assert!macro comprueba una condición y, si falla, arroja un error y detiene la ejecución. Esto es útil para evitar estados inválidos, como apostar más que el saldo de un jugador.

1.3 Generar números aleatorios

La equidad en el juego de dados se basa en la generación de números aleatorios. Sui Move proporciona el randommódulo para este propósito. Crearás un RandomGeneratorobjeto y lo usarás para generar un número aleatorio entre 1 y 6, simulando una tirada de dados.

1.4 Trabajando con monedas y balanzas

En Sui Move, lostokensse gestionan mediante los módulos de monedas y saldo:

• Moneda: forma que envuelve el saldo y que se usa para transferir fichas.

• Saldo: representa el importe real del token, lo que permite realizar operaciones como dividir y fusionar.

Los métodos clave incluyen:

• coin: :value (in_coin): devuelve el valor total de un objeto Coin.
• coin: :take (&mut balance, amount, ctx): extrae una cantidad específica de un saldo para crear una moneda.
• in_coin.balance_mut () .split (amount): divide una cantidad específica del saldo de una moneda.
• balance.join (balance): fusiona un saldo con otro.

Estas operaciones se utilizarán para gestionar la bolsa de premios del juego y las apuestas de los jugadores.

El contrato del juego de dados

Este es el código completo del contrato del juego de dados, seguido de explicaciones detalladas:

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

Estructura de desglose del código

• Juego: un objeto compartido con un identificador único y un pool_amount (saldo) para almacenar la bolsa de premios.
• Administrador: objeto clave que pertenece al administrador para que Initialization (init) gestione el pool.

Inicialización (init):

• Crea un objeto de juego con un bote de premios vacío y lo comparte públicamente.
• Crea un objeto de administrador y lo transfiere al creador del contrato.

Añadir al pool (AddCoinToGamePool)

• Toma una cantidad específica de la in_coin del administrador.
• Usa assert! para garantizar que la moneda tenga un valor suficiente.
• Divide el importe del saldo de in_coin y lo fusiona en el pool_amount del juego.

Resultado:

• Ganancia: si la apuesta coincide con la tirada, se saca del pozo una recompensa igual a la apuesta y se fusiona con el in_coin del jugador.
• Perder: si es incorrecta, la apuesta se deduce de in_coin y se añade a la bolsa a través de AddCoinToGamePool.