Struct backgammon::rules::Board

pub struct Board { /* private fields */ }

Represents the Backgammon board

A Backgammon board consists of 24 fields, each of which can hold 0 or more checkers. In addition there is a bar to hold checkers that have been hit and an off area to hold checkers that have been removed from the board.

//        +12-11-10--9--8--7-------6--5--4--3--2--1-+
//        | X           O    |   | O              X | +-------+
//        | X           O    |   | O              X | | OFF O |
//        | X           O    |   | O                | +-------+
//        | X                |   | O                |
//        | X                |   | O                |
//        |                  |BAR|                  |
//        | O                |   | X                |
//        | O                |   | X                |
//        | O           X    |   | X                | +-------+
//        | O           X    |   | X              O | | OFF X |
//        | O           X    |   | X              O | +-------+
//        +13-14-15-16-17-18------19-20-21-22-23-24-+

Implementations

impl Board

pub fn new() -> Self

Create a new board

pub fn get(&self) -> BoardDisplay

Get the board for both players. Use for graphical representation of the board.

This method outputs a tuple with three values:

1. the board represented as an array of 24 fields, each of which can hold 0 or more checkers. Positive amounts represent checkers of player 0, negative amounts represent checkers of player 1.
2. the bar for both players
3. the off for both players

pub fn set( &mut self, player: Player, field: usize, amount: i8 ) -> Result<(), Error>

Set checkers for a player on a field

This method adds the amount of checkers for a player on a field. The field is numbered from 0 to 23, starting from the last field of each player in the home board, the most far away field for each player (where there are 2 checkers to start with) is number 23.

If the field is blocked for the player, an error is returned. If the field is not blocked, but there is already one checker from the other player on the field, that checker is hit and moved to the bar.

pub fn blocked(&self, player: Player, field: usize) -> Result<bool, Error>

Check if a field is blocked for a player

pub fn set_bar(&mut self, player: Player, amount: u8) -> Result<(), Error>

Set checkers for a player on the bar

pub fn set_off(&mut self, player: Player, amount: u8) -> Result<(), Error>

Set checkers for a player off the board

Trait Implementations

impl Clone for Board

fn clone(&self) -> Board

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Board

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

Formats the value using the given formatter.

impl Default for Board

fn default() -> Board

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Board

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<Board> for Board

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Board

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Board