Enum chess::Square

#[repr(u8)]
pub enum Square {
    A1,
    B1,
    C1,
    D1,
    E1,
    F1,
    G1,
    H1,
    A2,
    B2,
    C2,
    D2,
    E2,
    F2,
    G2,
    H2,
    A3,
    B3,
    C3,
    D3,
    E3,
    F3,
    G3,
    H3,
    A4,
    B4,
    C4,
    D4,
    E4,
    F4,
    G4,
    H4,
    A5,
    B5,
    C5,
    D5,
    E5,
    F5,
    G5,
    H5,
    A6,
    B6,
    C6,
    D6,
    E6,
    F6,
    G6,
    H6,
    A7,
    B7,
    C7,
    D7,
    E7,
    F7,
    G7,
    H7,
    A8,
    B8,
    C8,
    D8,
    E8,
    F8,
    G8,
    H8,
}

Represent a square on the chess board.

Variants

A1

B1

C1

D1

E1

F1

G1

H1

A2

B2

C2

D2

E2

F2

G2

H2

A3

B3

C3

D3

E3

F3

G3

H3

A4

B4

C4

D4

E4

F4

G4

H4

A5

B5

C5

D5

E5

F5

G5

H5

A6

B6

C6

D6

E6

F6

G6

H6

A7

B7

C7

D7

E7

F7

G7

H7

A8

B8

C8

D8

E8

F8

G8

H8

Implementations

impl Square

pub fn new(index: usize) -> Self

Create a new Square, from an index.

Panics

Panic if the index is not in the range 0..=63.

Examples

use chess::Square;

assert_eq!(Square::new(0), Square::A1);
assert_eq!(Square::new(63), Square::H8);

pub fn to_index(&self) -> usize

Convert this Square into a usize.

pub fn make_square(file: File, rank: Rank) -> Square

Make a square from File and Rank.

Examples

use chess::{File, Rank, Square};

// Make the A1 square
let square = Square::make_square(File::A, Rank::First);

pub fn from_screen(x: f32, y: f32) -> Square

Transform a screen coordinate into a Square.

Reciprocal: see Square::to_screen.

The result depend of:

• BOARD_SIZE
• BOARD_CELL_PX_SIZE

pub fn to_screen(&self) -> (f32, f32)

Transform a Square into a screen coordinate.

Reciprocal: see Square::from_screen.

The result depend of:

• BOARD_SIZE
• BOARD_CELL_PX_SIZE

pub fn file(&self) -> File

Return the File of this square.

Examples

use chess::{File, Rank, Square};

let square = Square::make_square(File::D, Rank::Seventh);

assert_eq!(square.file(), File::D);

pub fn file_for(&self, color: Color) -> File

Return the “relative” File of this square according the side.

Examples

use chess::{Color, File, Square};

assert_eq!(Square::A1.file_for(Color::White), File::A);
assert_eq!(Square::A1.file_for(Color::Black), File::H);

pub fn rank(&self) -> Rank

Return the Rank of this square.

Examples

use chess::{File, Rank, Square};

let square = Square::make_square(File::D, Rank::Seventh);

assert_eq!(square.rank(), Rank::Seventh);

pub fn rank_for(&self, color: Color) -> Rank

Return the “relative” Rank of this square according the side. (i.e. return ranks for black)

Examples

use chess::{Color, Rank, Square};

assert_eq!(Square::E1.rank_for(Color::White), Rank::First);
assert_eq!(Square::E8.rank_for(Color::White), Rank::Eighth);
assert_eq!(Square::E2.rank_for(Color::Black), Rank::Seventh);
assert_eq!(Square::E7.rank_for(Color::Black), Rank::Second);

pub fn up(&self) -> Self

Go one Rank up.

Examples

use chess::Square;

assert_eq!(Square::B2.up(), Square::B3);

pub fn n_up(&self, n: usize) -> Self

Go n Rank up.

Examples

use chess::Square;

assert_eq!(Square::B2.n_up(3), Square::B5);

pub fn forward(&self, color: Color) -> Self

Go one Rank forward according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::B2.forward(Color::White), Square::B3);
assert_eq!(Square::B2.forward(Color::Black), Square::B1);

pub fn n_forward(&self, color: Color, n: usize) -> Self

Go n Rank forward according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::B2.n_forward(Color::White, 2), Square::B4);
assert_eq!(Square::B8.n_forward(Color::Black, 5), Square::B3);

pub fn down(&self) -> Self

Go one Rank down.

Examples

use chess::Square;

assert_eq!(Square::B2.down(), Square::B1);

pub fn n_down(&self, n: usize) -> Self

Go n Rank down.

Examples

use chess::{Color, Square};

assert_eq!(Square::B4.n_down(2), Square::B2);

pub fn backward(&self, color: Color) -> Self

Go one Rank backward according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::B2.backward(Color::White), Square::B1);
assert_eq!(Square::B2.backward(Color::Black), Square::B3);

pub fn n_backward(&self, color: Color, n: usize) -> Self

Go n Rank backward according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::B4.n_backward(Color::White, 2), Square::B2);
assert_eq!(Square::B3.n_backward(Color::Black, 5), Square::B8);

pub fn right(&self) -> Self

Go one File to the right.

Examples

use chess::Square;

assert_eq!(Square::B2.right(), Square::C2);

pub fn n_right(&self, n: usize) -> Self

Go n File to the right.

Examples

use chess::{Color, Square};

assert_eq!(Square::A4.n_right(3), Square::D4);

pub fn right_for(&self, color: Color) -> Self

Go one File right according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::B2.right_for(Color::White), Square::C2);
assert_eq!(Square::B2.right_for(Color::Black), Square::A2);

pub fn n_right_for(&self, color: Color, n: usize) -> Self

Go n File to the right according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::A4.n_right_for(Color::White, 3), Square::D4);
assert_eq!(Square::D4.n_right_for(Color::Black, 3), Square::A4);

pub fn left(&self) -> Self

Go one File to the left.

Examples

use chess::Square;

assert_eq!(Square::B2.left(), Square::A2);

pub fn n_left(&self, n: usize) -> Self

Go n File to the left.

Examples

use chess::{Color, Square};

assert_eq!(Square::D4.n_left(3), Square::A4);

pub fn left_for(&self, color: Color) -> Self

Go one File left according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::B2.left_for(Color::White), Square::A2);
assert_eq!(Square::B2.left_for(Color::Black), Square::C2);

pub fn n_left_for(&self, color: Color, n: usize) -> Self

Go n File to the left according to the side.

Examples

use chess::{Color, Square};

assert_eq!(Square::D4.n_left_for(Color::White, 3), Square::A4);
assert_eq!(Square::A4.n_left_for(Color::Black, 3), Square::D4);

pub fn follow_direction(&self, direction: Direction) -> Self

Go one Square in the given direction.

Examples

use chess::{Direction, Square};

assert_eq!(Square::B2.follow_direction(Direction::Up), Square::B3);
assert_eq!(Square::B2.follow_direction(Direction::DownRight), Square::C1);

pub fn distance(&self, other: Square) -> u32

The distance between the two squares, i.e. the number of king steps to get from one square to the other.

Examples

use chess::Square;

assert_eq!(Square::A2.distance(Square::B5), 3);

Trait Implementations

impl Clone for Square

fn clone(&self) -> Square

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Square

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

Formats the value using the given formatter.

impl Display for Square

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

Formats the value using the given formatter.

impl FromStr for Square

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Index<Square> for Board

type Output = Option<(Piece, Color)>

The returned type after indexing.

fn index(&self, index: Square) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<Square> for Board

fn index_mut(&mut self, index: Square) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl Ord for Square

fn cmp(&self, other: &Square) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Square> for Square

fn eq(&self, other: &Square) -> 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 PartialOrd<Square> for Square

fn partial_cmp(&self, other: &Square) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Square

impl Eq for Square

impl StructuralEq for Square

impl StructuralPartialEq for Square