htamas1210/Knightly
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 20 Wiki Activity

Merge pull request #29 from htamas1210/UI/event

Browse Source 
UI/event
This commit was merged in pull request #29.
This commit is contained in:
vargadavidlajos
2025-12-04 14:46:44 +01:00
committed by GitHub
parent 2fd04238f5 da858d9ed4
commit db527ce259
7 changed files with 1475 additions and 689 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
engine/src/boardsquare.rs
View File

@@ -1,6 +1,6 @@
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct BoardSquare {
pub x: usize,
pub y: usize,
@@ -28,10 +28,10 @@ impl BoardSquare {
return Self { x: x, y: y };
}
pub(in super) fn from_index(idx: u8) -> Self {
pub(super) fn from_index(idx: u8) -> Self {
let file = idx % 8;
let rank = idx / 8;
#[cfg(debug_assertions)]
{
if !(0..8).contains(&rank) {
@@ -39,10 +39,12 @@ impl BoardSquare {
}
}
return Self {x: file as usize, y: rank as usize};
return Self {
x: file as usize,
y: rank as usize,
};
}
pub(in super) fn to_index(&self) -> u8 {
pub(super) fn to_index(&self) -> u8 {
return (8 * self.y + self.x) as u8;
}
}

122
engine/src/chessmove.rs
View File

@@ -1,10 +1,13 @@
use crate::{bitboard::{bitmove::{BitMove, BitMoveType}, board::Board}};
use crate::bitboard::{
bitmove::{BitMove, BitMoveType},
board::Board,
};
use super::boardsquare::BoardSquare;
use super::piecetype::PieceType;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
#[derive(Serialize, Deserialize, Debug, Clone)]
/*pub struct ChessMove {
pub move_type: MoveType,
pub piece_type: PieceType,
@@ -19,14 +22,14 @@ pub enum ChessMove {
piece_type: PieceType,
from_square: BoardSquare,
to_square: BoardSquare,
promotion_piece: Option<PieceType>
promotion_piece: Option<PieceType>,
},
Capture {
piece_type: PieceType,
from_square: BoardSquare,
to_square: BoardSquare,
captured_piece: PieceType,
promotion_piece: Option<PieceType>
promotion_piece: Option<PieceType>,
},
Castle {
king_type: PieceType,
@@ -34,15 +37,15 @@ pub enum ChessMove {
king_to: BoardSquare,
rook_type: PieceType,
rook_from: BoardSquare,
rook_to: BoardSquare
rook_to: BoardSquare,
},
EnPassant {
pawn_type: PieceType,
from_square: BoardSquare,
to_square: BoardSquare,
captured_piece: PieceType,
captured_from: BoardSquare
}
captured_from: BoardSquare,
},
}
impl ChessMove {
@@ -56,7 +59,7 @@ impl ChessMove {
piece_type,
from_square,
to_square,
promotion_piece
promotion_piece,
};
}
@@ -72,7 +75,7 @@ impl ChessMove {
from_square,
to_square,
captured_piece,
promotion_piece
promotion_piece,
};
}
@@ -90,11 +93,11 @@ impl ChessMove {
king_to,
rook_type,
rook_from,
rook_to
rook_to,
};
}
pub(in super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
pub(super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
match bitmove.move_type() {
BitMoveType::Quiet => {
let from_square_index = bitmove.from_square();
@@ -103,11 +106,16 @@ impl ChessMove {
let to_square = BoardSquare::from_index(bitmove.to_square());
let promotion_piece = match bitmove.promotion_piece() {
Some(piece) => Some(PieceType::from_index(piece)),
None => None
None => None,
};
return ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece }
},
return ChessMove::Quiet {
piece_type,
from_square,
to_square,
promotion_piece,
};
}
BitMoveType::Capture => {
let from_square_index = bitmove.from_square();
let to_square_index = bitmove.to_square();
@@ -117,18 +125,28 @@ impl ChessMove {
let captured_piece = PieceType::from_index(board.piece_board(to_square_index));
let promotion_piece = match bitmove.promotion_piece() {
Some(piece) => Some(PieceType::from_index(piece)),
None => None
None => None,
};
return ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece }
},
return ChessMove::Capture {
piece_type,
from_square,
to_square,
captured_piece,
promotion_piece,
};
}
BitMoveType::Castle => {
let from_square_index = bitmove.from_square();
let to_square_index = bitmove.to_square();
let king_type = PieceType::from_index(board.piece_board(from_square_index));
let king_from = BoardSquare::from_index(from_square_index);
let king_to = BoardSquare::from_index(to_square_index);
let rook_type = if bitmove.from_square() < 32 { PieceType::WhiteRook } else { PieceType::BlackRook };
let rook_type = if bitmove.from_square() < 32 {
PieceType::WhiteRook
} else {
PieceType::BlackRook
};
let rook_from_index = if bitmove.to_square() > bitmove.from_square() {
bitmove.from_square() + 3
} else {
@@ -142,47 +160,79 @@ impl ChessMove {
};
let rook_to = BoardSquare::from_index(rook_to_index);
return ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to }
},
return ChessMove::Castle {
king_type,
king_from,
king_to,
rook_type,
rook_from,
rook_to,
};
}
BitMoveType::EnPassant => {
panic!("ChessMove::from_bitmove was left unimplemented");
}
}
}
pub(in super) fn to_bitmove(&self) -> BitMove {
pub(super) fn to_bitmove(&self) -> BitMove {
let bitmove = match self {
ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece } => {
ChessMove::Quiet {
piece_type,
from_square,
to_square,
promotion_piece,
} => {
let promotion_piece = match promotion_piece {
Some(piece) => Some(piece.to_index()),
None => None
None => None,
};
return BitMove::quiet(
from_square.to_index(),
to_square.to_index(),
promotion_piece
promotion_piece,
);
},
ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece } => {
}
ChessMove::Capture {
piece_type,
from_square,
to_square,
captured_piece,
promotion_piece,
} => {
let promotion_piece = match promotion_piece {
Some(piece) => Some(piece.to_index()),
None => None
None => None,
};
return BitMove::capture(
from_square.to_index(),
to_square.to_index(),
promotion_piece
promotion_piece,
);
},
ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to } => {
return BitMove::castle(
king_from.to_index(),
king_to.to_index()
);
},
ChessMove::EnPassant { pawn_type, from_square, to_square, captured_piece, captured_from } => {
}
ChessMove::Castle {
king_type,
king_from,
king_to,
rook_type,
rook_from,
rook_to,
} => {
return BitMove::castle(king_from.to_index(), king_to.to_index());
}
ChessMove::EnPassant {
pawn_type,
from_square,
to_square,
captured_piece,
captured_from,
} => {
panic!("ChessMove::to_bitmove was left unimplemented");
}
};
return bitmove;
}
pub fn notation(&self) -> String {
return self.to_bitmove().uci_notation();
}
}

3
engine/src/gameend.rs
View File

@@ -1,9 +1,8 @@
use serde::{Deserialize, Serialize};
#[derive(Deserialize, Serialize, Debug)]
#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
pub enum GameEnd {
WhiteWon(String),
BlackWon(String),
Draw(String),
}

687
engine/src/lib.rs
View File

@@ -1,215 +1,538 @@
mod bitboard;
pub mod chessmove;
pub mod piecetype;
pub mod boardsquare;
pub mod movetype;
pub mod chessmove;
pub mod gameend;
pub mod movetype;
pub mod piecetype;
use chessmove::ChessMove;
use gameend::GameEnd;
use bitboard::board::Board;
use bitboard::movebuffer::MoveBuffer;
use chessmove::ChessMove;
use gameend::GameEnd;
pub fn get_available_moves(fen: &str) -> Vec<ChessMove> {
let mut board = Board::build(fen);
let mut buffer = MoveBuffer::new();
let mut temp_buffer = MoveBuffer::new();
let mut generated_moves: Vec<ChessMove> = vec![];
let mut board = Board::build(fen);
let mut buffer = MoveBuffer::new();
let mut temp_buffer = MoveBuffer::new();
let mut generated_moves: Vec<ChessMove> = vec![];
board.collect_moves(&mut buffer, &mut temp_buffer);
board.collect_moves(&mut buffer, &mut temp_buffer);
for idx in 0..buffer.count() {
generated_moves.push(ChessMove::from_bitmove(buffer.get(idx), &board));
}
for idx in 0..buffer.count() {
generated_moves.push(ChessMove::from_bitmove(buffer.get(idx), &board));
}
println!("get_available_moves resulted in {} moves", generated_moves.len());
return generated_moves;
println!(
"get_available_moves resulted in {} moves",
generated_moves.len()
);
return generated_moves;
}
pub fn is_game_over(fen: &str) -> Option<GameEnd> {
let mut board = Board::build(fen);
let mut buffer = MoveBuffer::new();
let mut temp_buffer = MoveBuffer::new();
let in_check = board.collect_moves(&mut buffer, &mut temp_buffer);
let mut board = Board::build(fen);
let mut buffer = MoveBuffer::new();
let mut temp_buffer = MoveBuffer::new();
let in_check = board.collect_moves(&mut buffer, &mut temp_buffer);
println!("is_game_over answered");
if buffer.count() > 0 {
return None;
}
if !in_check {
return Some(GameEnd::Draw("".to_string()));
}
return if board.side_to_move() == 0 { Some(GameEnd::BlackWon("".to_string())) } else { Some(GameEnd::WhiteWon("".to_string())) };
println!("is_game_over answered");
if buffer.count() > 0 {
return None;
}
if !in_check {
return Some(GameEnd::Draw("".to_string()));
}
return if board.side_to_move() == 0 {
Some(GameEnd::BlackWon("".to_string()))
} else {
Some(GameEnd::WhiteWon("".to_string()))
};
}
pub fn get_board_after_move(fen: &str, chess_move: &ChessMove) -> String {
let mut board = Board::build(fen);
let played_move = chess_move.to_bitmove();
let mut board = Board::build(fen);
let played_move = chess_move.to_bitmove();
println!("get_board_after_move answered");
board.make_move(&played_move);
println!("get_board_after_move answered");
board.make_move(&played_move);
return board.fen();
return board.fen();
}
#[cfg(test)]
mod tests {
use crate::boardsquare::BoardSquare;
use crate::piecetype::PieceType::*;
use crate::gameend::GameEnd;
use crate::boardsquare::BoardSquare;
use crate::gameend::GameEnd;
use crate::piecetype::PieceType::*;
use super::*;
use super::*;
impl PartialEq for ChessMove {
fn eq(&self, other: &Self) -> bool {
canonical(self) == canonical(other)
impl PartialEq for ChessMove {
fn eq(&self, other: &Self) -> bool {
canonical(self) == canonical(other)
}
}
impl Eq for ChessMove {}
impl Ord for ChessMove {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
let lhs = canonical(self);
let rhs = canonical(other);
lhs.cmp(&rhs)
}
}
impl PartialOrd for ChessMove {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
}
impl Eq for ChessMove {
}
impl Ord for ChessMove {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
let lhs = canonical(self);
let rhs = canonical(other);
lhs.cmp(&rhs)
fn canonical(m: &ChessMove) -> (u8, u8, u8) {
match m {
ChessMove::Quiet {
piece_type,
from_square,
to_square,
promotion_piece,
} => (0, from_square.to_index(), to_square.to_index()),
ChessMove::Capture {
piece_type,
from_square,
to_square,
captured_piece,
promotion_piece,
} => (1, from_square.to_index(), to_square.to_index()),
ChessMove::Castle {
king_type,
king_from,
king_to,
rook_type,
rook_from,
rook_to,
} => (2, king_from.to_index(), king_to.to_index()),
ChessMove::EnPassant {
pawn_type,
from_square,
to_square,
captured_piece,
captured_from,
} => (3, from_square.to_index(), to_square.to_index()),
}
}
}
impl PartialOrd for ChessMove {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for GameEnd {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(GameEnd::WhiteWon(a), GameEnd::WhiteWon(b)) => a == b,
(GameEnd::BlackWon(a), GameEnd::BlackWon(b)) => a == b,
(GameEnd::Draw(a), GameEnd::Draw(b)) => a == b,
_ => false,
#[test]
fn get_available_moves_test() {
let boards: [&str; 2] = [
"rnbqkbnr/pppppppp/8/1B6/4P3/5P1N/PPPP2PP/RNBQK2R w KQkq e6 0 1",
"6Bn/B2Pk3/8/p1r3NK/3p4/b6P/3p2n1/2R5 w - - 0 1",
];
let mut expected_moves: Vec<Vec<ChessMove>> = vec![
vec![
ChessMove::capture(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(3, 6),
BlackPawn,
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(0, 1),
BoardSquare::from_coord(0, 2),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(0, 1),
BoardSquare::from_coord(0, 3),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(1, 1),
BoardSquare::from_coord(1, 2),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(1, 1),
BoardSquare::from_coord(1, 3),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(2, 1),
BoardSquare::from_coord(2, 2),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(2, 1),
BoardSquare::from_coord(2, 3),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(3, 1),
BoardSquare::from_coord(3, 2),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(3, 1),
BoardSquare::from_coord(3, 3),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(4, 3),
BoardSquare::from_coord(4, 4),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(5, 2),
BoardSquare::from_coord(5, 3),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(6, 1),
BoardSquare::from_coord(6, 2),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(6, 1),
BoardSquare::from_coord(6, 3),
None,
),
ChessMove::quiet(
WhiteKnight,
BoardSquare::from_coord(1, 0),
BoardSquare::from_coord(0, 2),
None,
),
ChessMove::quiet(
WhiteKnight,
BoardSquare::from_coord(1, 0),
BoardSquare::from_coord(2, 2),
None,
),
ChessMove::quiet(
WhiteKnight,
BoardSquare::from_coord(7, 2),
BoardSquare::from_coord(6, 0),
None,
),
ChessMove::quiet(
WhiteKnight,
BoardSquare::from_coord(7, 2),
BoardSquare::from_coord(5, 1),
None,
),
ChessMove::quiet(
WhiteKnight,
BoardSquare::from_coord(7, 2),
BoardSquare::from_coord(5, 3),
None,
),
ChessMove::quiet(
WhiteKnight,
BoardSquare::from_coord(7, 2),
BoardSquare::from_coord(6, 4),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(5, 0),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(4, 1),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(3, 2),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(2, 3),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(0, 3),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(0, 5),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(1, 4),
BoardSquare::from_coord(2, 5),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(7, 0),
BoardSquare::from_coord(6, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(7, 0),
BoardSquare::from_coord(5, 0),
None,
),
ChessMove::quiet(
WhiteQueen,
BoardSquare::from_coord(3, 0),
BoardSquare::from_coord(4, 1),
None,
),
ChessMove::quiet(
WhiteKing,
BoardSquare::from_coord(4, 0),
BoardSquare::from_coord(4, 1),
None,
),
ChessMove::quiet(
WhiteKing,
BoardSquare::from_coord(4, 0),
BoardSquare::from_coord(5, 1),
None,
),
ChessMove::quiet(
WhiteKing,
BoardSquare::from_coord(4, 0),
BoardSquare::from_coord(5, 0),
None,
),
ChessMove::castle(
WhiteKing,
BoardSquare::from_coord(4, 0),
BoardSquare::from_coord(6, 0),
WhiteRook,
BoardSquare::from_coord(7, 0),
BoardSquare::from_coord(5, 0),
),
],
vec![
ChessMove::capture(
WhiteBishop,
BoardSquare::from_coord(0, 6),
BoardSquare::from_coord(2, 4),
BlackRook,
None,
),
ChessMove::capture(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(2, 4),
BlackRook,
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(7, 2),
BoardSquare::from_coord(7, 3),
None,
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(3, 6),
BoardSquare::from_coord(3, 7),
Some(WhiteQueen),
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(3, 6),
BoardSquare::from_coord(3, 7),
Some(WhiteRook),
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(3, 6),
BoardSquare::from_coord(3, 7),
Some(WhiteBishop),
),
ChessMove::quiet(
WhitePawn,
BoardSquare::from_coord(3, 6),
BoardSquare::from_coord(3, 7),
Some(WhiteKnight),
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(0, 6),
BoardSquare::from_coord(1, 5),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(0, 6),
BoardSquare::from_coord(1, 7),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(6, 7),
BoardSquare::from_coord(7, 6),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(6, 7),
BoardSquare::from_coord(5, 6),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(6, 7),
BoardSquare::from_coord(4, 5),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(6, 7),
BoardSquare::from_coord(3, 4),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(6, 7),
BoardSquare::from_coord(2, 3),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(6, 7),
BoardSquare::from_coord(1, 2),
None,
),
ChessMove::quiet(
WhiteBishop,
BoardSquare::from_coord(6, 7),
BoardSquare::from_coord(0, 1),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(0, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(1, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(3, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(4, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(5, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(6, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(7, 0),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(2, 1),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(2, 2),
None,
),
ChessMove::quiet(
WhiteRook,
BoardSquare::from_coord(2, 0),
BoardSquare::from_coord(2, 3),
None,
),
ChessMove::quiet(
WhiteKing,
BoardSquare::from_coord(7, 4),
BoardSquare::from_coord(6, 3),
None,
),
ChessMove::quiet(
WhiteKing,
BoardSquare::from_coord(7, 4),
BoardSquare::from_coord(7, 5),
None,
),
],
];
for case in 0..2 {
let mut generated_moves = get_available_moves(boards[case]);
generated_moves.sort();
expected_moves[case].sort();
assert_eq!(generated_moves.len(), expected_moves[case].len());
assert_eq!(generated_moves, expected_moves[case]);
}
}
#[test]
fn is_game_over_test() {
let boards: [&str; 4] = [
"2k5/3pn3/2pP4/1R1P3B/1Np5/3RPp2/1B6/6Kb w - - 0 1",
"2K3B1/4P3/8/7p/4pPn1/1N1P1p1p/4bp2/2Rk4 b - - 0 1",
"6N1/B2PP3/pR1b4/3P2nb/6P1/3P1k2/2p5/4r1K1 w - - 0 1",
"3n1K2/p2k1p2/5P2/b1p2P2/P7/8/3p2r1/8 w - - 0 1",
];
let expected_results: [Option<GameEnd>; 4] = [
None,
Some(GameEnd::WhiteWon("".to_string())),
Some(GameEnd::BlackWon("".to_string())),
Some(GameEnd::Draw("".to_string())),
];
for case in 0..4 {
let fen = boards[case];
let actual = is_game_over(fen);
assert_eq!(actual, expected_results[case]);
}
}
}
}
fn canonical(m: &ChessMove) -> (u8, u8, u8) {
match m {
ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece } =>
(0, from_square.to_index(), to_square.to_index()),
ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece } =>
(1, from_square.to_index(), to_square.to_index()),
ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to } =>
(2, king_from.to_index(), king_to.to_index()),
ChessMove::EnPassant { pawn_type, from_square, to_square, captured_piece, captured_from } =>
(3, from_square.to_index(), to_square.to_index()),
}
}
#[test]
fn get_available_moves_test() {
let boards: [&str; 2] = [
"rnbqkbnr/pppppppp/8/1B6/4P3/5P1N/PPPP2PP/RNBQK2R w KQkq e6 0 1",
"6Bn/B2Pk3/8/p1r3NK/3p4/b6P/3p2n1/2R5 w - - 0 1"
];
let mut expected_moves: Vec<Vec<ChessMove>> = vec![
vec![
ChessMove::capture(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(3, 6), BlackPawn, None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(0, 1), BoardSquare::from_coord(0, 2), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(0, 1), BoardSquare::from_coord(0, 3), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(1, 1), BoardSquare::from_coord(1, 2), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(1, 1), BoardSquare::from_coord(1, 3), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(2, 1), BoardSquare::from_coord(2, 2), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(2, 1), BoardSquare::from_coord(2, 3), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 1), BoardSquare::from_coord(3, 2), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 1), BoardSquare::from_coord(3, 3), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(4, 3), BoardSquare::from_coord(4, 4), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(5, 2), BoardSquare::from_coord(5, 3), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(6, 1), BoardSquare::from_coord(6, 2), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(6, 1), BoardSquare::from_coord(6, 3), None),
ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(1, 0), BoardSquare::from_coord(0, 2), None),
ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(1, 0), BoardSquare::from_coord(2, 2), None),
ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(6, 0), None),
ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(5, 1), None),
ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(5, 3), None),
ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(6, 4), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(5, 0), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(4, 1), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(3, 2), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(2, 3), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(0, 3), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(0, 5), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(2, 5), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(7, 0), BoardSquare::from_coord(6, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(7, 0), BoardSquare::from_coord(5, 0), None),
ChessMove::quiet(WhiteQueen, BoardSquare::from_coord(3, 0), BoardSquare::from_coord(4, 1), None),
ChessMove::quiet(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(4, 1), None),
ChessMove::quiet(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(5, 1), None),
ChessMove::quiet(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(5, 0), None),
ChessMove::castle(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(6, 0), WhiteRook, BoardSquare::from_coord(7, 0), BoardSquare::from_coord(5, 0))
],
vec![
ChessMove::capture(WhiteBishop, BoardSquare::from_coord(0, 6), BoardSquare::from_coord(2, 4), BlackRook, None),
ChessMove::capture(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 4), BlackRook, None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(7, 3), None),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteQueen)),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteRook)),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteBishop)),
ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteKnight)),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(0, 6), BoardSquare::from_coord(1, 5), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(0, 6), BoardSquare::from_coord(1, 7), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(7, 6), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(5, 6), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(4, 5), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(3, 4), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(2, 3), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(1, 2), None),
ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(0, 1), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(0, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(1, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(3, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(4, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(5, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(6, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(7, 0), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 1), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 2), None),
ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 3), None),
ChessMove::quiet(WhiteKing, BoardSquare::from_coord(7, 4), BoardSquare::from_coord(6, 3), None),
ChessMove::quiet(WhiteKing, BoardSquare::from_coord(7, 4), BoardSquare::from_coord(7, 5), None)
]
];
for case in 0..2 {
let mut generated_moves = get_available_moves(boards[case]);
generated_moves.sort();
expected_moves[case].sort();
assert_eq!(generated_moves.len(), expected_moves[case].len());
assert_eq!(generated_moves, expected_moves[case]);
}
}
#[test]
fn is_game_over_test() {
let boards: [&str; 4] = [
"2k5/3pn3/2pP4/1R1P3B/1Np5/3RPp2/1B6/6Kb w - - 0 1",
"2K3B1/4P3/8/7p/4pPn1/1N1P1p1p/4bp2/2Rk4 b - - 0 1",
"6N1/B2PP3/pR1b4/3P2nb/6P1/3P1k2/2p5/4r1K1 w - - 0 1",
"3n1K2/p2k1p2/5P2/b1p2P2/P7/8/3p2r1/8 w - - 0 1"
];
let expected_results: [Option<GameEnd>; 4] = [
None,
Some(GameEnd::WhiteWon("".to_string())),
Some(GameEnd::BlackWon("".to_string())),
Some(GameEnd::Draw("".to_string()))
];
for case in 0..4 {
let fen = boards[case];
let actual = is_game_over(fen);
assert_eq!(actual, expected_results[case]);
}
}
}

18
engine/src/piecetype.rs
View File

@@ -1,6 +1,6 @@
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
#[derive(Clone, Serialize, Deserialize, Debug)]
pub enum PieceType {
WhitePawn,
WhiteKnight,
@@ -17,8 +17,7 @@ pub enum PieceType {
}
impl PieceType {
pub(in super) fn from_index(idx: u8) -> Self {
pub(super) fn from_index(idx: u8) -> Self {
return match idx {
0 => PieceType::WhitePawn,
1 => PieceType::WhiteKnight,
@@ -32,10 +31,10 @@ impl PieceType {
9 => PieceType::BlackRook,
10 => PieceType::BlackQueen,
11 => PieceType::BlackKing,
_ => panic!("invalid piece index! should NEVER appear")
}
_ => panic!("invalid piece index! should NEVER appear"),
};
}
pub(in super) fn to_index(&self) -> u8 {
pub(super) fn to_index(&self) -> u8 {
return match self {
&PieceType::WhitePawn => 0,
&PieceType::WhiteKnight => 1,
@@ -48,7 +47,8 @@ impl PieceType {
&PieceType::BlackBishop => 8,
&PieceType::BlackRook => 9,
&PieceType::BlackQueen => 10,
&PieceType::BlackKing => 11
}
&PieceType::BlackKing => 11,
};
}
}
}

93
server/src/connection.rs
View File

@@ -39,12 +39,6 @@ pub fn new_waiting_queue() -> WaitingQueue {
Arc::new(Mutex::new(VecDeque::new()))
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Step {
pub from: String,
pub to: String,
}
#[derive(Serialize, Deserialize)]
pub enum ServerMessage2 {
GameEnd {
@@ -52,12 +46,17 @@ pub enum ServerMessage2 {
},
UIUpdate {
fen: String,
turn_player: String,
move_history: Vec<String>,
},
MatchFound {
match_id: Uuid,
color: String,
opponent_name: String,
},
LegalMoves {
moves: Vec<ChessMove>,
},
Ok {
response: Result<(), String>,
},
@@ -66,12 +65,22 @@ pub enum ServerMessage2 {
#[derive(Serialize, Deserialize)]
#[serde(tag = "type")]
enum ClientEvent {
Join { username: String },
Join {
username: String,
},
FindMatch,
Move { step: ChessMove },
Move {
step: ChessMove,
turn_player: String,
},
Resign,
Chat { text: String },
RequestLegalMoves { fen: String },
Chat {
text: String,
},
RequestLegalMoves {
fen: String,
},
CloseConnection,
}
#[derive(Debug)]
@@ -88,7 +97,7 @@ pub struct GameMatch {
pub player_white: Uuid,
pub player_black: Uuid,
pub board_state: String,
pub move_history: Vec<Step>,
pub move_history: Vec<String>,
}
// Message sending utilities
@@ -179,6 +188,13 @@ pub async fn handle_connection(
info!("id: {}", &player_id);
println!("\n\n\n");
println!(
"{:?}",
engine::get_available_moves("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
);
println!("\n\n\n");
// Message processing loop
while let Some(Ok(message)) = read.next().await {
if message.is_text() {
@@ -213,7 +229,7 @@ pub async fn handle_connection(
info!("Appended {} to the waiting queue", player_id);
info!("queue {:?}", wait_queue);
}
Move { step } => {
Move { step, turn_player } => {
let match_id = connections
.lock()
.await
@@ -222,6 +238,8 @@ pub async fn handle_connection(
.current_match
.unwrap();
println!("\n\nstep: {:?}\n", step);
{
info!("updating board state in match: {}", &match_id);
let mut matches = matches.lock().await;
@@ -230,15 +248,29 @@ pub async fn handle_connection(
&matches.get(&match_id).unwrap().board_state,
&step,
);
}
let message = ServerMessage2::UIUpdate {
fen: matches
.lock()
.await
.get(&match_id)
info!(
"board after engine fn: {}",
matches.get_mut(&match_id).unwrap().board_state.clone()
);
matches
.get_mut(&match_id)
.unwrap()
.board_state
.clone(),
.move_history
.push(step.clone().notation());
}
let message = ServerMessage2::UIUpdate {
fen: {
let mut matches = matches.lock().await;
matches.get(&match_id).unwrap().board_state.clone()
},
turn_player: turn_player,
move_history: {
let mut matches = matches.lock().await;
matches.get(&match_id).unwrap().move_history.clone()
},
};
let _ = broadcast_to_match(
@@ -265,7 +297,7 @@ pub async fn handle_connection(
&serde_json::to_string(&message).unwrap(),
)
.await;
clean_up_match(&matches, &match_id);
clean_up_match(&matches, &match_id).await;
}
None => {
info!("No winner match continues. Id: {}", &match_id);
@@ -276,9 +308,10 @@ pub async fn handle_connection(
RequestLegalMoves { fen } => {
info!("Requesting legal moves player: {}", &player_id);
let moves = get_available_moves(&fen);
let message = ServerMessage2::LegalMoves { moves };
let _ = send_message_to_player_connection(
connections.lock().await.get_mut(&player_id),
&serde_json::to_string(&moves).unwrap(),
&serde_json::to_string(&message).unwrap(),
)
.await;
info!("Sent moves to player: {}", player_id);
@@ -329,20 +362,18 @@ pub async fn handle_connection(
}
};
broadcast_to_match(
let _ = broadcast_to_match(
&connections,
&matches,
connections
.lock()
.await
.get(&player_id)
.unwrap()
.current_match
.unwrap(),
fuck_id.clone(),
&serde_json::to_string(&fuck).unwrap(),
)
.await;
clean_up_match(&matches, fuck_id);
clean_up_match(&matches, fuck_id).await;
}
CloseConnection => {
warn!("Closing connection for: {}", &player_id);
break;
}
_ => {
warn!("Not known client event");

1227
ui/src/main.rs
View File

File diff suppressed because it is too large Load Diff