ocelot-chess 0.1.4

A simple(ish) chess engine written entirely in Rust with no dependencies.
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

mod bot;
mod evaluation;
mod physical;
mod tui;
use bot::Ocelot;
use physical::*;
use std::env;

//parse args
fn main() {
    //default depth
    let mut depth = 5;

    let args: Vec<_> = env::args().collect();

    //look for depth arguments
    for arg in args.iter() {
        match arg.parse::<i32>() {
            Ok(num) => {
                depth = num;
                break;
            }
            Err(_) => continue,
        }
    }

    if args.contains(&String::from("--help")) {
        help();
    } else if args.contains(&String::from("--demo")) {
        demo(depth);
    } else if args.contains(&String::from("--tui")) {
        tui::mainloop(depth);
    } else {
        uci(depth);
    }
}

//start a UCI bot
fn uci(depth: i32) {
    let b: Board = Default::default();
    let mut engine = Ocelot::new(&b, depth, 10.0);
    engine.uci_loop();
}

fn demo(depth: i32) {
    let b: Board = Default::default();

    println!("Depth: {depth}");
    let mut white_engine = Ocelot::new(&b, depth, 4.0);
    let mut black_engine = Ocelot::new(&b, depth, 4.0);

    println!(
        "This demo will play a game between equally-strengthed White and Black players until you kill the program. It gets chaotic and a little illegal!"
    );

    //play indefinitely
    loop {
        println!("Round {}", white_engine.board.round);
        let white_move = white_engine.safe_best_move();
        println!("White plays {white_move}");
        white_engine.perform_on_self(white_move.duplicate());
        black_engine.perform_on_self(white_move);
        println!("White in check: {}", b.is_check(board::Color::White));

        let black_move = black_engine.safe_best_move();
        println!("Black plays {black_move}");
        white_engine.perform_on_self(black_move.duplicate());
        black_engine.perform_on_self(black_move);
        println!("Black in check: {}", b.is_check(board::Color::Black));
    }
}

fn help() {
    println!(
        "ocelot-chess is a simple chess engine written from scratch with no dependencies. Flags:
    --tui - starts the built-in TUI.
    --demo - runs a chaotic demo of two Ocelots playing against each other.
    --help - prints this message.

    If no flags are supplied, the engine starts in UCI mode.
    You can supply a number as an argument and that will be the engine's depth.
    "
    );
}