This content originally appeared on DEV Community and was authored by pulkitgovrani
This blog, is a continuation of part1 where I explained the basic flow. Now, Let us dive into the main code :)
Declaring Constants & Structs
module tictactoe::game {
use std::error;
use std::signer;
use std::string::{String, utf8};
use std::vector;
use aptos_framework::event;
use aptos_framework::timestamp;
const EINVALID_MOVE: u64 = 1;
const EINVALID_PLAYER: u64 = 2;
const EINVALID_INDEX: u64 = 3;
const EGAME_OVER: u64 = 4;
const PLAYER_X: u8 = 1;
const PLAYER_O: u8 = 2;
const EMPTY: u8 = 0;
struct Game has key {
board: vector<u8>,
current_turn: u8,
winner: u8,
}
Code Explanation
Constants: Error codes and player identifiers are defined. EINVALID_MOVE, EINVALID_PLAYER, EINVALID_INDEX, and EGAME_OVER are error codes for different invalid states. PLAYER_X and PLAYER_O represent the two players, and EMPTY represents an empty cell on the board.
Game Struct: The Game struct holds the game's state, including the board (a vector of 9 cells), the current turn, and the winner.
Creating Event Structs
#[event]
struct MoveEvent has drop, store {
player: u8,
position: u8,
}
#[event]
struct WinEvent has drop, store {
winner: u8,
}
#[event]
struct DrawEvent has drop, store {
}
Code Explanation
MoveEvent: Emitted when a player makes a move, containing the player and the position.
WinEvent: Emitted when a player wins, containing the winner.
DrawEvent: Emitted when the game is a draw.
Initializing a Game
public entry fun init_game(account: &signer) {
move_to(account, Game {
board: vector::from_elem(EMPTY, 9),
current_turn: PLAYER_X,
winner: EMPTY,
});
}
Making a Move
public entry fun make_move(account: &signer, position: u8) acquires Game {
let game = borrow_global_mut<Game>(signer::address_of(account));
assert!(game.winner == EMPTY, EGAME_OVER);
assert!(position < 9, EINVALID_INDEX);
if (game.board[position] != EMPTY) {
abort EINVALID_MOVE;
}
game.board[position] = game.current_turn;
event::emit(MoveEvent { player: game.current_turn, position });
if (check_winner(&game.board, game.current_turn)) {
game.winner = game.current_turn;
event::emit(WinEvent { winner: game.current_turn });
} else if (is_draw(&game.board)) {
event::emit(DrawEvent {});
} else {
game.current_turn = if (game.current_turn == PLAYER_X) { PLAYER_O } else { PLAYER_X };
}
}
Code Explanation
It first checks if the game is over and if the position is valid.
If the cell at the given position is not empty, it aborts with EINVALID_MOVE.
It updates the board with the current player's move and emits a MoveEvent.
It checks if the current player has won using the check_winner function. If so, it sets the winner and emits a WinEvent.
If the board is full and there is no winner, it emits a DrawEvent.
If the game is still ongoing, it switches the turn to the other player.
Resetting the Game
public entry fun reset_game(account: &signer) acquires Game {
let game = borrow_global_mut<Game>(signer::address_of(account));
game.board = vector::from_elem(EMPTY, 9);
game.current_turn = PLAYER_X;
game.winner = EMPTY;
}
Creating View Functions to Access Information related to the Game Copy
#[view]
public fun get_board(): vector<u8> acquires Game {
let game = borrow_global<Game>(signer::address_of(account));
game.board
}
#[view]
public fun get_current_turn(): u8 acquires Game {
let game = borrow_global<Game>(signer::address_of(account));
game.current_turn
}
#[view]
public fun get_winner(): u8 acquires Game {
let game = borrow_global<Game>(signer::address_of(account));
game.winner
}
Checking the Winner of the Game
inline fun check_winner(board: &vector<u8>, player: u8): bool {
let win_positions = vector::vector([
vector::vector([0, 1, 2]),
vector::vector([3, 4, 5]),
vector::vector([6, 7, 8]),
vector::vector([0, 3, 6]),
vector::vector([1, 4, 7]),
vector::vector([2, 5, 8]),
vector::vector([0, 4, 8]),
vector::vector([2, 4, 6])
]);
vector::any(&win_positions, move |positions| {
vector::all(positions, move |&pos| board[pos] == player)
})
}
Code Explanation
win_positions: Defines all possible winning positions on the board.
vector::any: Checks if any of the winning positions are fully occupied by the current player.
vector::all: Checks if all positions in a winning line are occupied by the current player.
This function returns true if the current player has a winning combination, and false otherwise.
Checking for the Draw
inline fun is_draw(board: &vector<u8>): bool {
!vector::any(board, move |&cell| cell == EMPTY)
}
Conclusion
In this blog, we've explored a comprehensive implementation of a Tic Tac Toe game using the Move language on the Aptos blockchain platform. We covered the entire code, explaining each part in detail, from initializing the game, making moves, checking for winners, emitting events, resetting the game, and viewing the game state.
Building decentralized applications with Move and Aptos offers a secure and efficient way to develop robust blockchain-based games and other applications. By understanding the code structure and logic presented here, you can extend and customize this Tic Tac Toe game or create your own dApps on the Aptos platform.
This content originally appeared on DEV Community and was authored by pulkitgovrani
pulkitgovrani | Sciencx (2024-09-09T20:25:49+00:00) Building a Tic Tac Toe Game on Aptos with Move Language-Part2. Retrieved from https://www.scien.cx/2024/09/09/building-a-tic-tac-toe-game-on-aptos-with-move-language-part2/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.