serde is sick

Author: robo-monk

Cargo.lock

@@ -9,6 +9,10 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
+serde = { version = "1.0", features = ["derive"] }
+# Each data format lives in its own crate; the sample code below uses JSON
+# but you may be using a different one.
+serde_json = "1.0"
 wasm-bindgen = "0.2"
 getrandom = { version = "0.2", features = ["js"] }
 rand = "0.8"

Cargo.toml

@@ -1,11 +1,15 @@
-import init, { greet } from "../../crust";
+import init, { greet, parse_fen } from "../../crust";
+
+const initFen = "r1bqkbnr/1pp2p1p/p1n5/1P1P4/P1p1p1p1/5N2/4PPPP/RNBQKB1R b KQkq - 0 1"
 
 init().then(() => {
   // console.log("helloooooo ")
-  greet("Webassambly")
+  let board = parse_fen(initFen);
+  console.log('board is', board);
+  // greet("Webassambly")
+
 })
 
 
 export class Board {
-
 }

crust-ui/src/chess/board.ts

@@ -2,8 +2,12 @@ use super::board::{Board, CastlingRights};
 use super::piece::{Color, Direction, Piece, P};
 use rand::Rng;
 use std::fmt::Debug; // 0.8.5
+                     // use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
+// use serde::*;
+// use serde_derive::{Serialize, Deserialize};
 
-#[derive(Clone)]
+#[derive(Serialize, Deserialize)]
 pub struct Move {
     pub from: u32,
     pub target: u32,
@@ -187,7 +191,7 @@ fn pawn_attacks(bb: u64, color: Color) -> u64 {
 //    return (maindia >> sout) << nort;
 // }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BBoard {
     white: [u64; 7],
     black: [u64; 7],
@@ -532,12 +536,12 @@ impl BBoard {
             }
         }
 
-        return alpha
+        return alpha;
     }
 
     fn alpha_beta_min(&self, alpha: i32, mut beta: i32, depth: u32) -> i32 {
         if depth == 0 {
-            return -self.evaluate(self.turn)
+            return -self.evaluate(self.turn);
         }
 
         let moves = self.get_moves_and_captures(self.turn);
@@ -548,15 +552,15 @@ impl BBoard {
             let score = c.alpha_beta_max(alpha, beta, depth - 1);
 
             if score <= alpha {
-                return alpha
+                return alpha;
             }
 
             if score < beta {
                 beta = score
             }
         }
 
-        return beta
+        return beta;
     }
 
     pub fn eval_side_score(&self, side: Color) -> i32 {
@@ -582,7 +586,6 @@ impl BBoard {
     }
 
     pub fn search_good_move(&self, depth: u32) -> Move {
-
         // let mut best_score: i32 = -999999999;
         let mut best_score = -f32::INFINITY as i32;
         let mut best_score = f32::INFINITY as i32;
@@ -597,9 +600,8 @@ impl BBoard {
             },
         };
 
-
         let score = self.alpha_beta_max(-f32::INFINITY as i32, f32::INFINITY as i32, depth);
-        println!(">> score of alpha beta max is {score}", );
+        println!(">> score of alpha beta max is {score}",);
         self.loop_through_moves_and_captures(self.turn, |m| {
             let mut c = self.clone();
             c.push_unchecked_move(&m);
@@ -609,7 +611,6 @@ impl BBoard {
                 best_score = score;
                 best_move = m;
             }
-
         });
 
         best_move
@@ -1009,4 +1010,24 @@ impl BBoard {
 
         return panic!("no piece there");
     }
+
+
+    pub fn serialize(&self) -> String {
+        // self
+        let serialized = serde_json::to_string(self).unwrap();
+
+        // Prints serialized = {"x":1,"y":2}
+        println!("serialized = {}", serialized);
+        serialized
+    }
+
+    pub fn from_serialization(val: &str) -> BBoard {
+        let b: BBoard = serde_json::from_str(val).unwrap();
+        b
+        // serde_json::Deserializer
+    }
+
+    pub fn to_fen(&self) -> String {
+        todo!()
+    }
 }

src/chess/bboard.rs

@@ -1,16 +1,17 @@
 use std::collections::HashMap;
 
 use super::piece::{Color, Direction, Piece, P};
+use serde::{Deserialize, Serialize};
 use super::bboard::BBoard;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Move {
     pub from: usize,
     pub target: usize,
 		// pub capture: Option<usize>
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone,)]
 pub struct Board {
     pub turn: Color,
     pub move_count: u64,
@@ -21,7 +22,7 @@ pub struct Board {
     pub black_cr: CastlingRights,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CastlingRights {
     pub queen: bool,
     pub king: bool,

src/chess/board.rs

@@ -1,6 +1,7 @@
 use super::board::Board;
 use super::bboard::*;
 use std::ops::{Add, BitXor, Mul, Shr, ShrAssign};
+use serde::{Serialize, Deserialize};
 
 // A >> B (can A pass through B?)
 impl Shr for Piece {
@@ -156,7 +157,7 @@ impl Direction {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
 pub enum Direction {
     Up,
     Down, // and in the end its only round and round
@@ -168,7 +169,7 @@ pub enum Direction {
     DownRight,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
 pub enum Color {
     Black,
     White,
@@ -183,7 +184,7 @@ impl Color {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub enum P {
     Pawn,
     Knight,
@@ -196,7 +197,7 @@ pub enum P {
 }
 
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct Piece {
     pub class: P,
     pub color: Color,

src/chess/piece.rs

@@ -9,13 +9,37 @@ use chess::piece::{Color, Piece, P};
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
-extern {
+extern "C" {
     pub fn alert(s: &str);
 }
 
-
 #[wasm_bindgen]
 pub fn greet(name: &str) -> () {
-  // return 1
-  alert(&format!("Hello, {}!", name));
+    // return 1
+    alert(&format!("Hello, {}!", name));
+}
+
+#[wasm_bindgen]
+pub fn parse_fen(fen: &str) -> String {
+    let fen = fen.to_string();
+    // let fen = String::from("r1bqkbnr/1pp2p1p/p1n5/1P1P4/P1p1p1p1/5N2/4PPPP/RNBQKB1R b KQkq - 0 1");
+    let board = Board::from_fen(&fen);
+    let mut bboard = BBoard::new();
+
+    bboard.white_cr = board.white_cr;
+    bboard.black_cr = board.black_cr;
+    bboard.en_passant_target = board.en_passant;
+    bboard.turn = board.turn;
+
+    for (i, sq) in board.squares.iter().enumerate() {
+        if sq.is_none() {
+            continue;
+        }
+        let piece = sq.unwrap();
+        dbg!(i, piece);
+
+        bboard.place(piece, i as u8);
+    }
+
+    bboard.serialize()
 }