shakmaty-python-binding 0.1.2__tar.gz → 0.1.4__tar.gz

{shakmaty_python_binding-0.1.2 → shakmaty_python_binding-0.1.4}/Cargo.lock

@@ -564,7 +564,7 @@ dependencies = [
 
 [[package]]
 name = "shakmaty_python_binding"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "arrayvec",
  "bitflags",

{shakmaty_python_binding-0.1.2 → shakmaty_python_binding-0.1.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shakmaty_python_binding"
-version = "0.1.2"
+version = "0.1.4"
 edition = "2021"
 rust-version = "1.56"
 

{shakmaty_python_binding-0.1.2 → shakmaty_python_binding-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: shakmaty_python_binding
-Version: 0.1.2
+Version: 0.1.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{shakmaty_python_binding-0.1.2 → shakmaty_python_binding-0.1.4}/shakmaty_python_binding.pyi

@@ -88,7 +88,7 @@ class MyChess(object):
     def has_queenside_castling_rights(self, color:bool)-> bool: 
         ...    
 
-    def fullmove_clock(self) -> int: 
+    def fullmove_number(self) -> int: 
        ...
        
     def halfmove_clock(self) -> int: 
@@ -100,6 +100,9 @@ class MyChess(object):
     def play(self, move:MyMove)-> None: 
         ...
         
+    def play_and_return_o(self, my_move_: MyMove) -> tuple[int,int,int,int,int,int,int,int,int,int,int,int]:
+    	...
+        
     def number_of_pieces_on_the_board(self)-> int: 
         ...
            

{shakmaty_python_binding-0.1.2 → shakmaty_python_binding-0.1.4}/src/lib.rs

@@ -1,4 +1,3 @@
-use std::collections::HashSet;
 use std::collections::HashMap;
 use std::vec::Vec;
 
@@ -37,13 +36,13 @@ fn setup_fen<T: Position + FromSetup>(fen: &str) -> T {
 }
 
 
-
 ///////////// MOVE
 
 #[derive(Eq, Hash)]
 #[pyclass]
 pub struct MyMove {
-    chess_move:Move
+    chess_move:Move,
+    uci:String
 }
 
 impl PartialEq for MyMove {
@@ -57,8 +56,10 @@ impl MyMove {
 
     #[new]
     pub fn new(uci:&str, my_chess:&MyChess) -> MyMove {
+    	let chess_move = UciMove::from_ascii(uci.as_bytes()).expect("REASON").to_move(&my_chess.chess).expect("REASON");
         MyMove{
-        	chess_move:UciMove::from_ascii(uci.as_bytes()).expect("REASON").to_move(&my_chess.chess).expect("REASON")
+        	chess_move:chess_move,
+        	uci:uci.to_string()
         }
     }
     
@@ -68,7 +69,7 @@ impl MyMove {
 
 
     fn uci(&self) -> PyResult<String> {
-        Ok(self.chess_move.to_uci(CastlingMode::Standard).to_string())
+        Ok(self.uci.clone())
     }
 }
 
@@ -78,11 +79,158 @@ impl MyMove {
     pub fn new_rust(move_:Move) -> MyMove {
     
         MyMove {
-            chess_move: move_
+            chess_move: move_.clone(),
+            uci:move_.to_uci(CastlingMode::Standard).to_string()
+        }
+    }
+
+}
+
+
+/////////////// Board state
+
+
+
+pub struct MyBoardStateRust {
+    
+pub     __str__:String ,
+pub ply:u32,
+pub turn:u8, 
+pub  is_game_over:bool,
+pub legal_moves:Vec<MyMove>,
+pub number_of_pieces_on_the_board: u32,
+pub has_queenside_castling_rights:bool,
+pub has_kingside_castling_rights:bool,
+pub piece_map:HashMap<u64, (u32,bool)>,
+pub is_attacked_white:bool,
+pub is_attacked_black:bool,
+pub occupied:u64,
+pub pawns:u64,
+pub knights:u64,
+pub bishops:u64,
+pub rooks:u64,
+pub queens:u64,
+pub kings:u64,
+pub promoted:u64,
+pub ep_square:i32,
+pub halfmove_clock:u32,
+pub fullmove_number:u32,
+pub castling_rights:u64,
+pub white:u64,
+pub black:u64,
+pub result:String,
+
+}
+
+
+
+impl MyBoardStateRust {
+ 
+    pub fn new(
+         __str__:&str ,
+ply:u32,
+ turn:u8, 
+  is_game_over:bool,
+ legal_moves:Vec<MyMove>,
+ number_of_pieces_on_the_board: u32,
+ has_queenside_castling_rights:bool,
+ has_kingside_castling_rights:bool,
+ piece_map:HashMap<u64, (u32,bool)>,
+ is_attacked_white:bool,
+ is_attacked_black:bool,
+ occupied:u64,
+ pawns:u64,
+ knights:u64,
+ bishops:u64,
+ rooks:u64,
+ queens:u64,
+ kings:u64,
+ promoted:u64,
+ ep_square:i32,
+ halfmove_clock:u32,
+ fullmove_number:u32,
+ castling_rights:u64,
+ white:u64,
+ black:u64,
+ result:&str,
+) -> MyBoardStateRust {
+    
+
+MyBoardStateRust {
+__str__:(*__str__).to_string(),
+ply:ply,
+ turn:turn, 
+  is_game_over:is_game_over,
+ legal_moves:legal_moves,
+ number_of_pieces_on_the_board:number_of_pieces_on_the_board,
+ has_queenside_castling_rights:has_queenside_castling_rights,
+ has_kingside_castling_rights:has_kingside_castling_rights,
+ piece_map:piece_map,
+ is_attacked_white:is_attacked_white,
+ is_attacked_black:is_attacked_black,
+ occupied:occupied,
+ pawns:pawns,
+ knights:knights,
+ bishops:bishops,
+ rooks:rooks,
+ queens:queens,
+ kings:kings,
+ promoted:promoted,
+ ep_square:ep_square,
+ halfmove_clock:halfmove_clock,
+ fullmove_number:fullmove_number,
+ castling_rights:castling_rights,
+ white:white,
+ black:black,
+ result:(*result).to_string(),
         }
     }
+    
+}
+
+#[pyclass]
+
+pub struct MyBoardState2 {
+    
+pub     __str__:PyResult<String> ,
+pub ply:PyResult<u32>,
+pub turn:PyResult<u8>, 
+pub  is_game_over:PyResult<bool>,
+pub legal_moves:PyResult<Vec<MyMove>>,
+pub number_of_pieces_on_the_board: PyResult<u32>,
+pub has_queenside_castling_rights:PyResult<bool>,
+pub has_kingside_castling_rights:PyResult<bool>,
+pub piece_map:PyResult<HashMap<u64, (u32,bool)>>,
+pub is_attacked_white:PyResult<bool>,
+pub is_attacked_black:PyResult<bool>,
+pub occupied:PyResult<u64>,
+pub pawns:PyResult<u64>,
+pub knights:PyResult<u64>,
+pub bishops:PyResult<u64>,
+pub rooks:PyResult<u64>,
+pub queens:PyResult<u64>,
+pub kings:PyResult<u64>,
+pub promoted:PyResult<u64>,
+pub ep_square:PyResult<i32>,
+pub halfmove_clock:PyResult<u32>,
+pub fullmove_number:PyResult<u32>,
+pub castling_rights:PyResult<u64>,
+pub white:PyResult<u64>,
+pub black:PyResult<u64>,
+pub result:PyResult<String>,
 
 }
+
+
+
+
+    
+#[pyclass]   
+pub struct MyBoardState {
+ board_state_rust : MyBoardStateRust
+}
+    
+
 /////////////// TABLE BASE
 
 
@@ -142,14 +290,84 @@ impl MyChess {
         }
     }
 
-    fn __str__(&self) -> PyResult<String> {
-        Ok(format!("board fen: {}", self.chess.board()))
-    }
+
 
     fn play(&mut self, my_move_: &MyMove) -> PyResult<()> {
         self.chess.play_unchecked(&my_move_.chess_move);
         Ok(()) 
     }
+    
+    fn play_and_return(&mut self, my_move_: &MyMove) -> PyResult<(String,u32,u8,bool)> {
+        self.chess.play_unchecked(&my_move_.chess_move);
+        
+        let a = u32::from(self.chess.fullmoves()) -1;
+        let b = self.chess.turn() as u32;
+        let c = 2*a+1-b;
+        
+
+
+        Ok(
+        (
+        format!("board fen: {}", self.chess.board()),
+        c,
+        self.chess.turn() as u8,
+        self.chess.is_game_over()
+        )
+        ) 
+    }
+    
+    fn play_and_return_o(&mut self, my_move_: &MyMove) -> PyResult<(u64,u64,u64,u64,u64,u64,u64,u64,u64,u8,i32,u64)> {
+        self.chess.play_unchecked(&my_move_.chess_move);
+        
+	let cas = u64::from(self.chess.castles().castling_rights());
+       // let  is_game_over = self.chess.is_game_over();
+       
+        let pawns = u64::from(self.chess.board().by_role(Role::Pawn));
+	let knights =u64::from(self.chess.board().by_role(Role::Knight));
+ 	let bishops = u64::from(self.chess.board().by_role(Role::Bishop));
+	 let rooks = u64::from(self.chess.board().by_role(Role::Rook));
+let queens = u64::from(self.chess.board().by_role(Role::Queen));
+let kings = u64::from(self.chess.board().by_role(Role::King));
+let white = u64::from(self.chess.board().by_color(Color::White));
+let black =u64::from(self.chess.board().by_color(Color::Black));
+let turn = self.chess.turn() as u8;
+    
+       	let a= self.chess.maybe_ep_square();
+       	let ep_square;
+
+        match a {
+    		Some(x) => {ep_square= i32::from(x) }
+    		None => {ep_square = i32::from(-1) }
+}
+let promoted = u64::from(self.chess.promoted());
+        
+        Ok(
+        (
+cas,
+ pawns , knights , bishops,rooks ,queens,kings,white , black,
+ turn, ep_square ,promoted      )
+        ) 
+    }
+
+    fn copy(&mut self) -> PyResult<MyChess> {
+        Ok(MyChess {
+            chess: self.chess.clone()
+        })
+    }
+
+    fn piece_at(&mut self, square_int:u32)-> PyResult<Option<(bool,u32)>> {
+        let square = Square::new(square_int);
+        let a: Option<Piece> = self.chess.board().piece_at(square);
+        if a.is_none() {
+        Ok(None)
+            } else{
+                        Ok(Some((a.unwrap().color as u32 != 0,a.unwrap().role as u32)))
+                }
+        }
+
+    fn __str__(&self) -> PyResult<String> {
+        Ok(format!("board fen: {}", self.chess.board()))
+    }
 
     fn ply(&mut self) -> PyResult<u32> {
         let a = u32::from(self.chess.fullmoves()) -1;
@@ -165,28 +383,26 @@ impl MyChess {
     fn is_game_over(&mut self) -> PyResult<bool> {
         Ok(self.chess.is_game_over())
     }
-
-    fn copy(&mut self) -> PyResult<MyChess> {
-        Ok(MyChess {
-            chess: self.chess.clone()
-        })
-    }
+    
+   // fn legal_moves_dic(&mut self) -> PyResult<HashMap<String,MyMove,>> {
+   ///     let move_list :MoveList = self.chess.legal_moves();
+   //     let mut legal_moves_my = HashMap::new();
+    //    for a_move in move_list {
+      //      legal_moves_my.push((MyMove::new_rust(a_move.clone()),a_move.clone().to_uci(CastlingMode::Standard).to_string() ));
+       //     }
+ //       Ok(legal_moves_my)
+  //  }
 
     fn legal_moves(&mut self) -> PyResult<Vec<MyMove>> {
         let move_list :MoveList = self.chess.legal_moves();
         let mut legal_moves_my = Vec::new();
         for a_move in move_list {
-            legal_moves_my.push(MyMove::new_rust(a_move));
+            legal_moves_my.push(MyMove::new_rust(a_move.clone()));
             }
         Ok(legal_moves_my)
     }
 
 
-    //fn legal_moves_2(&mut self) -> PyResult<MoveList> {
-    //    let move_list :MoveList = self.chess.legal_moves();
-    //    Ok(move_list)
-    //}
-
     fn number_of_pieces_on_the_board(&mut self)-> PyResult<u32> {
         Ok(self.chess.board().occupied().0.count_ones())
         }
@@ -202,15 +418,7 @@ impl MyChess {
         }
 
 
-    fn piece_at(&mut self, square_int:u32)-> PyResult<Option<(bool,u32)>> {
-        let square = Square::new(square_int);
-        let a: Option<Piece> = self.chess.board().piece_at(square);
-        if a.is_none() {
-        Ok(None)
-            } else{
-                        Ok(Some((a.unwrap().color as u32 != 0,a.unwrap().role as u32)))
-                }
-        }
+
 
 
 
@@ -316,7 +524,7 @@ impl MyChess {
         
     }
     
-    pub  fn fullmove_clock(&self) -> PyResult<u32> {
+    pub  fn fullmove_number(&self) -> PyResult<u32> {
         Ok(u32::from(self.chess.fullmoves()))
         
     }
@@ -332,6 +540,7 @@ impl MyChess {
         Ok(u64::from(self.chess.board().by_color(Color::White)))
     }
 
+
     #[inline]
     pub  fn black(&self) -> PyResult<u64> {
         Ok(u64::from(self.chess.board().by_color(Color::Black)))
@@ -347,26 +556,7 @@ impl MyChess {
 }
     } 
     
-        
-    fn play_modifications(&mut self, to: String) -> PyResult<()> {
-        //let uci = to.parse::<UciMove>().expect("valid uci");
-        //let m = uci.to_move(&self.chess).expect("legal uci");
-        //let a = self.chess.ep_square(EnPassantMode::Legal);
-        //let mut epsq :Option<EnPassant>;
-        //if a.is_none(){
-         //                           epsq = None;
-
-           // }else{
-             //           epsq = Some(EnPassant(a.expect("REASON")));
-
-               // }
 
-        let uci = to.parse::<UciMove>().expect("valid uci");
-        let _m = uci.to_move(&self.chess).expect("legal uci");
-        //self.chess.play_unchecked_modifications(&m);
-        Ok(())
-
-    }
 
 }
 
@@ -379,6 +569,6 @@ fn shakmaty_python_binding(_py: Python, m: &PyModule) -> PyResult<()> {
     add_classes!(m, MyMove);
     add_classes!(m, MyChess);
     add_classes!(m, MyTableBase);
-
+    //add_classes!(m, MyBoardState);
     Ok(())
 }