Struct Game

pub struct Game {
    pub boards: [[Board; 3]; 3],
    pub current_player: Player,
    pub last_move_cords: Option<(usize, usize)>,
}

Represents the 9x9 super Tic Tac Toe game. X starts

Example

let mut game = Game::new();
game.make_move(0, 0, 1, 1).unwrap();
game.make_move(1, 1, 0, 0).unwrap();
game.make_move(0, 0, 2, 2).unwrap();
game.make_move(2, 2, 0, 2).unwrap();
game.make_move(0, 2, 1, 0).unwrap();
match game.get_winner() {
    super_ttt::GameState::Winner(player) => {
        println!("Player {:?} wins!", player);
    }
    super_ttt::GameState::Tie => {
        println!("It's a tie!");
    }
    super_ttt::GameState::InProgress => {
        println!("The game is still in progress.");
    }
}

This is essentially just a game state with some relevant methods attached to it.

Fields

boards: [[Board; 3]; 3]

Self explanatory. Public to allow implementations of display methods

current_player: Player

The current player that will make the move when Game::make_move is called

last_move_cords: Option<(usize, usize)>

The coordinates of the last move made by a player.

Implementations

impl Game

pub fn new() -> Self

Create a new game. Default starting player is Player::X

pub fn make_move( &mut self, board_row: usize, board_col: usize, cell_row: usize, cell_col: usize, ) -> Result<Self, InvalidMoveError>

Make a move on the game. This method will also swap the Game::current_player

pub fn get_winner(&self) -> GameState

Get the winner of the game, if any

Trait Implementations

impl Clone for Game

fn clone(&self) -> Game

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Game

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Game

fn default() -> Self

Returns the “default value” for a type.

impl Display for Game

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Game

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Game

fn eq(&self, other: &Game) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Game

impl Eq for Game

impl StructuralPartialEq for Game