added method uci_notation to struct BitMove

Engine/library functions

engine/src/bitboard.rs

@@ -3,5 +3,6 @@ mod utils;
 mod legality;
 mod checkinfo;
 mod attacks;
+mod bitmove;
 
 pub mod board;

engine/src/bitboard/bitmove.rs

@@ -0,0 +1,77 @@
+use super::utils::*;
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct BitMove {
+
+  move_type: BitMoveType,
+  from_square: u8,
+  to_square: u8,
+  promotion_piece: Option<u8>
+}
+
+impl BitMove {
+
+  #[inline]
+  pub fn quiet(from: u8, to: u8, promotion_piece: Option<u8>) -> Self {
+    return Self {
+      move_type: BitMoveType::Quiet,
+      from_square: from,
+      to_square: to,
+      promotion_piece: promotion_piece
+    };
+  }
+  #[inline]
+  pub fn capture(from: u8, to: u8, promotion_piece: Option<u8>) -> Self {
+    return Self {
+      move_type: BitMoveType::Capture,
+      from_square: from,
+      to_square: to,
+      promotion_piece: promotion_piece
+    };
+  }
+  #[inline]
+  pub fn castle(from: u8, to: u8) -> Self {
+    return Self {
+      move_type: BitMoveType::Castle,
+      from_square: from,
+      to_square: to,
+      promotion_piece: None
+    };
+  }
+
+  #[inline(always)]
+  pub fn move_type(&self) -> BitMoveType {
+    return self.move_type;
+  }
+  #[inline(always)]
+  pub fn from_square(&self) -> u8 {
+    return self.from_square;
+  }
+  #[inline(always)]
+  pub fn to_square(&self) -> u8 {
+    return self.to_square;
+  }
+  #[inline(always)]
+  pub fn promotion_piece(&self) -> Option<u8> {
+    return self.promotion_piece;
+  }
+
+  pub fn uci_notation(&self) -> String {
+    let mut notation = notation_from_square_number(self.from_square());
+    notation.push_str(&notation_from_square_number(self.to_square()));
+
+    if let Some(promotion_piece) = self.promotion_piece {
+      notation.push(get_character_by_piece_id(promotion_piece).to_ascii_lowercase());
+    }
+
+    return notation;
+  }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum BitMoveType {
+  Quiet,
+  Capture,
+  Castle,
+  EnPassant
+}

engine/src/bitboard/utils.rs

@@ -48,6 +48,11 @@ pub fn try_get_square_number_from_notation(notation: &str) -> Result<u8, ()> {
   }
 }
 
+const PIECE_CHARACTERS: [char; 12] = ['P', 'N', 'B', 'R', 'Q', 'K', 'p', 'n', 'b', 'r', 'q', 'k'];
+pub fn get_character_by_piece_id(id: u8) -> char {
+  return PIECE_CHARACTERS[id as usize];
+}
+
 
 // <----- TESTS ----->
 

engine/src/boardsquare.rs

@@ -0,0 +1,32 @@
+
+pub struct BoardSquare {
+  pub x: usize,
+  pub y: usize
+}
+
+impl BoardSquare {
+
+  pub fn new() -> Self {
+    return Self{
+      x: 0,
+      y: 0
+    };
+  }
+
+  pub fn from_coord(x: usize, y: usize) -> Self {
+    
+    #[cfg(debug_assertions)]
+    {
+      if x > 7 {
+        println!("Warning: x coordinate of square is bigger than 7, it might not be on the board!");
+      }
+      if y > 7 {
+        println!("Warning: y coordinate of square is bigger than 7, it might not be on the board!");
+      }
+    }
+    return Self {
+      x: x,
+      y: y
+    };
+  }
+}

engine/src/chessmove.rs

@@ -0,0 +1,71 @@
+use crate::piecetype;
+
+use super::boardsquare::BoardSquare;
+use super::piecetype::PieceType;
+use super::movetype::MoveType;
+
+
+pub struct ChessMove {
+  pub move_type: MoveType,
+  pub piece_type: PieceType,
+  pub from_square: BoardSquare,
+  pub to_square: BoardSquare,
+  pub rook_from: BoardSquare,
+  pub rook_to: BoardSquare,
+  pub promotion_piece: Option<PieceType>
+}
+
+impl ChessMove {
+
+  pub fn quiet(
+    piece_type: PieceType,
+    from_square: BoardSquare,
+    to_square: BoardSquare,
+    promotion_piece: Option<PieceType>
+  ) -> Self {
+    return Self {
+      move_type: MoveType::Quiet,
+      piece_type: piece_type,
+      from_square: from_square,
+      to_square: to_square,
+      rook_from: BoardSquare::new(),
+      rook_to: BoardSquare::new(),
+      promotion_piece: promotion_piece
+    }
+  }
+
+  pub fn capture(
+    piece_type: PieceType,
+    from_square: BoardSquare,
+    to_square: BoardSquare,
+    promotion_piece: Option<PieceType>
+  ) -> Self {
+    return Self {
+      move_type: MoveType::Capture,
+      piece_type: piece_type,
+      from_square: from_square,
+      to_square: to_square,
+      rook_from: BoardSquare::new(),
+      rook_to: BoardSquare::new(),
+      promotion_piece: promotion_piece
+    }
+  }
+
+  pub fn castle(
+    piece_type: PieceType,
+    from_square: BoardSquare,
+    to_square: BoardSquare,
+    rook_from: BoardSquare,
+    rook_to: BoardSquare
+  ) -> Self {
+    return Self {
+      move_type: MoveType::Quiet,
+      piece_type: piece_type,
+      from_square: from_square,
+      to_square: to_square,
+      rook_from: rook_from,
+      rook_to: rook_to,
+      promotion_piece: None
+    }
+  }
+}

engine/src/gameend.rs

@@ -0,0 +1,6 @@
+
+pub enum GameEnd {
+  WhiteWon(String),
+  BlackWon(String),
+  Draw(String)
+}

engine/src/lib.rs

@@ -0,0 +1,24 @@
+mod bitboard;
+pub mod chessmove;
+pub mod piecetype;
+pub mod boardsquare;
+pub mod movetype;
+pub mod gameend;
+
+use chessmove::ChessMove;
+use gameend::GameEnd;
+
+pub fn get_available_moves(fen: &str) -> Vec<ChessMove> {
+  println!("get_available_moves answered");
+  return vec![];
+}
+
+pub fn is_game_over(fen: &str) -> Option<GameEnd> {
+  println!("is_game_over answered");
+  return None;
+}
+
+pub fn get_board_after_move(fen: &str, chess_move: &ChessMove) -> String {
+  println!("get_board_after_move answered");
+  return String::from("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+}

engine/src/movetype.rs

@@ -0,0 +1,7 @@
+
+pub enum MoveType {
+  Quiet,
+  Capture,
+  Castle,
+  EnPassant
+}

engine/src/piecetype.rs

@@ -0,0 +1,15 @@
+
+pub enum PieceType {
+  WhitePawn,
+  WhiteKnight,
+  WhiteBishop,
+  WhiteRook,
+  WhiteQueen,
+  WhiteKing,
+  BlackPawn,
+  BlackKnight,
+  BlackBishop,
+  BlackRook,
+  BlackQueen,
+  BlackKing
+}