Trong hướng dẫn này, tôi sẽ hướng dẫn bạn quá trình tạohợp đồng thông minh trò chơi xúc xắcbằng cách sử dụng Sui Move.

Hợp đồng này cho phép người chơi đặt cược vàokết quả của một cú ném xúc xắc, với quản trị viên quản lý tổng giải thưởng. Cuối cùng, bạn sẽ có một hợp đồng đầy đủ chức năng và hiểu biết vững chắc về một số khái niệm chính của Sui Move.

Giới thiệu

Hợp đồng trò chơi xúc xắc mà chúng tôi sẽ xây dựng cho phép các chức năng sau:

• Khởi tạo: Người tạo hợp đồng thiết lập trò chơi.
• Quản lý quản trị viên: Quản trị viên có thể gửi mã thông báo vào tổng giải thưởng và rút chúng khi cần thiết.
• Tương tác người chơi: Người chơi tham gia bằng cách đoán kết quả tung xúc xắc và đặt cược.

Hướng dẫn này giả định bạn có hiểu biết cơ bản về Sui Move và tập trung vào việc giới thiệu các khái niệm mới thông qua việc thực hiện thực tế. Trước khi đi sâu vào mã, hãy khám phá các khái niệm chính mà bạn sẽ gặp:

1.1 Thêm phụ thuộc:

Để sử dụng mã thông báo từ một hợp đồng khác (ví dụ: hợp đồng mã thông báo vòi), bạn cần thêm nó làm phụ thuộc vào dự án của mình. Điều này được thực hiện bằng cách cập nhật Move.tomltệp hợp đồng của bạn:

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

Ở đây, coin_duck là hợp đồng mã thông báo vòi nằm ở đường dẫn được chỉ định. Hợp đồng phụ thuộc cũng phải chỉ định trường xuất bản tại của nó trong Move.toml của chính nó với ID gói thu được khi xuất bản, như sau: rỉ sét

published-at = "packageId_from_publication"

1.2 Sử dụng khẳng định

Khẳng định đảm bảo rằng một số điều kiện nhất định được đáp ứng trong quá trình thực hiện hợp đồng. assert!Macro kiểm tra một điều kiện và, nếu nó không thành công, sẽ đưa ra lỗi và dừng thực thi. Điều này rất hữu ích để ngăn chặn các trạng thái không hợp lệ, chẳng hạn như đặt cược nhiều hơn số dư của người chơi.

1.3 Tạo số ngẫu nhiên

Sự công bằng trong trò chơi xúc xắc dựa vào việc tạo số ngẫu nhiên. Sui Move cung cấp randommô-đun cho mục đích này. Bạn sẽ tạo một RandomGeneratorđối tượng và sử dụng nó để tạo ra một số ngẫu nhiên từ 1 đến 6, mô phỏng một cú ném xúc xắc.

1.4 Làm việc với Coin và Balance

Trong Sui Move,tokenđược quản lý bằng cách sử dụng các mô-đun coin và số dư:

• Coin: Bao bọc xung quanh Số dư, được sử dụng để chuyển mã thông báo.

• Số dư: Đại diện cho số lượng token thực tế, cho phép các hoạt động như tách và hợp nhất.

Các phương pháp chính bao gồm:

• coin: :value (in_coin): Trả về tổng giá trị của đối tượng Coin.
• coin: :take (&mut balance, amount, ctx): Trích một số tiền được chỉ định từ Số dư để tạo ra một đồng xu.
• in_coin.balance_mut () .split (amount): Chia một số tiền được chỉ định từ số dư của Coin.
• balance.join (balance): Hợp nhất số dư này vào số dư khác.

Các thao tác này sẽ được sử dụng để quản lý tổng giải thưởng của trò chơi và cược của người chơi.

Hợp đồng trò chơi xúc xắc

Dưới đây là mã hoàn chỉnh cho hợp đồng trò chơi xúc xắc, tiếp theo là giải thích chi tiết:

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

Cấu trúc phân tích mã

• Trò chơi: Một đối tượng được chia sẻ với một id duy nhất và pool_amount (Số dư) để lưu trữ tổng giải thưởng.
• Admin: Một đối tượng chính thuộc sở hữu của quản trị viên để Khởi tạo (init) quản lý nhóm.

Khởi tạo (init):

• Tạo một đối tượng Trò chơi với một tổng giải thưởng trống và chia sẻ nó công khai.
• Tạo một đối tượng Admin và chuyển nó cho người tạo hợp đồng.

Thêm vào hồ bơi (AddCoinToGamePool)

• Lấy một số tiền được chỉ định từ in_coin của quản trị viên.
• Sử dụng! để đảm bảo đồng tiền có đủ giá trị.
• Chia số tiền từ số dư của in_coin và hợp nhất nó vào pool_amount của trò chơi.

Kết quả:

• Thắng: Nếu đoán khớp với lượt tung, phần thưởng tương đương với cược sẽ được lấy từ pool và được hợp nhất vào in_coin của người chơi.
• Thua: Nếu không chính xác, cược sẽ được khấu trừ từ in_coin và được thêm vào pool thông qua AddCoinToGamePool.