eschac 0.6.2

computing chess moves
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# eschac

A library for computing chess moves.

[![docs.rs](https://docs.rs/eschac/badge.svg)](https://docs.rs/eschac)

## Overview

eschac implements fast legal move generation and a copy-make interface that
enforces at compile time that no illegal move is played, with no runtime checks
and no potential panics.

## Example

```rust
use eschac::prelude::*;

// read a position from a text record
let setup = Setup::from_text_record("7k/4P1rp/5Q2/5p2/1Pp1bP2/8/r4K1P/6R1 w - -")?;
let position = setup.into_position()?;

// read a move in algebraic notation
let san = "Ke1".parse::<San>()?;
let m = san.to_move(&position)?;

// play the move (note the absence of error handling)
let position = m.make();

// generate all the legal moves on the new position
let moves = position.legal_moves();
for m in moves {
    // print the UCI notation of each move
    println!("{}", m.to_uci());
}
```

## Comparison with [shakmaty](https://crates.io/crates/shakmaty)

shakmaty is another Rust library for chess processing. It is written by Niklas
Fiekas, whose work greatly inspired the development of eschac. Both libraries
have similar base features to handle the chessboard -- editing the position &
making moves -- as well as fast move generation. **eschac** distinguishes
itself with a focus on performance for standard chess, a more compact board
representation and its use of the borrow checker. **shakmaty** on the other
hand has a more complex interface that handles chess960 and other variants, and
offers more features such as PGN parsing, Zobrist hashing, Syzygy endgame
tablebases, and more.

## License

eschac is licensed under [AGPL-3.0](./COPYING) (or any later version at your option).