improved the engine

src/engine.rs

@@ -1,3 +1,5 @@
+use bitboard::Bitboard;
+use std::sync::mpsc::{Receiver, Sender};
 use movegen::Move;
 
 pub enum EngineMsg {
@@ -23,10 +25,9 @@ pub enum InterfaceMsg {
 }
 
 
-
-pub fn run_engine(r: Receiver<EngineMsg>) {
+pub fn run_engine(r: Receiver<EngineMsg>, s: Sender<InterfaceMsg>) {
     for msg in r {
-
+        println!("engine received message");
     }
 }
 

src/interface.rs

@@ -1,31 +1,35 @@
 use std::io::{self, BufRead};
+use std::sync::mpsc::{Receiver, Sender};
 
+use engine::{EngineMsg, InterfaceMsg};
 
-pub fn run() {
+
+pub fn run(r: Receiver<InterfaceMsg>, s: Sender<EngineMsg>) {
     let stdin = io::stdin();
-    println!("id name bishop 1.0");
-    println!("id author bishop");
     for line_m in stdin.lock().lines() {
         let line = line_m.unwrap();
         let mut split = line.split_whitespace().collect::<Vec<&str>>();
-        run_command(split);
+        run_command(split, &r, &s);
+        s.send(EngineMsg::Ping);
     }
 }
 
-fn run_command(mut cmd: Vec<&str>) {
+fn run_command(mut cmd: Vec<&str>, r: &Receiver<InterfaceMsg>, s: &Sender<EngineMsg>) {
     if cmd.len() > 0 {
         let command = cmd[0];
         cmd.drain(0..1);
         match command {
             "uci" => cmd_uci(cmd),
             "isready" => cmd_isready(cmd),
-            "register" => cmd_register(cmd),
-            _ => {}
+            "go" => cmd_go(cmd, r, s),
+            cmd => { println!("unknown command: {}", cmd); }
         }
     }
 }
 
 fn cmd_uci(_args: Vec<&str>) {
+    println!("id name bishop 1.0");
+    println!("id author bishop");
     println!("uciok");
 }
 
@@ -33,7 +37,8 @@ fn cmd_isready(_args: Vec<&str>) {
     println!("readyok");
 }
 
-fn cmd_register(_args: Vec<&str>) {
+fn cmd_go(args: Vec<&str>, r: &Receiver<InterfaceMsg>, s: &Sender<EngineMsg>) {
+    println!("searchin' da game!");
 }
 
 
@@ -41,5 +46,3 @@ fn cmd_register(_args: Vec<&str>) {
 
 
 
-
-

src/main.rs

@@ -4,9 +4,19 @@ mod movegen;
 mod engine;
 mod search;
 
+use std::sync::mpsc;
+use std::thread;
 
 fn main() {
-    interface::run();
+    let (esend, erecv) = mpsc::channel();
+    let (isend, irecv) = mpsc::channel();
+
+    // spawn engine thread
+    thread::spawn(move || {
+        engine::run_engine(erecv, isend);
+    });
+
+    interface::run(irecv, esend);
 }
 
 

src/movegen.rs

@@ -1,15 +1,32 @@
 use bitboard::Bitboard;
+use search::Game;
 
-type Square = u8;
-type Side = bool;
+pub type Square = u8;
+pub type Side = bool;
 
-const WHITE: Side = false;
-const BLACK: Side = true;
+pub const WHITE: Side = false;
+pub const BLACK: Side = true;
+
+pub type PieceType = u8;
+
+pub const PAWN:     PieceType = 0;
+pub const KNIGHT:   PieceType = 1;
+pub const BISHOP:   PieceType = 2;
+pub const ROOK:     PieceType = 3;
+pub const QUEEN:    PieceType = 4;
+pub const KING:     PieceType = 5;
+
+
+pub struct SimpleMove {
+    from: Square,
+    to: Square,
+}
 
 pub enum Move {
-    Default     { from: Square, to: Square },
+    Default     { mov: SimpleMove, capture: PieceType },
     Castling    { side: Side, left: bool },
-    EnPassant   { side: Side, column: u8}
+    EnPassant   { side: Side, column: u8},
+    Promotion   { side: Side, column: u8, promote_to: PieceType },
 }
 
 
@@ -32,8 +49,23 @@ impl Iterator for BitboardIterator {
 }
 
 
-fn generate_pawn_moves()
+fn generate_pawn_moves(game: &Game, side: Side) 
 {
+    let pawns = game.pawns(side);
+}
+
+
+
+#[cfg(test)]
+mod tests {
+    use search::Game;
+    use movegen::*;
+    #[test]
+    fn pawn_pushes() {
+        let game: Game = Game::default();
+        let pawn_moves = generate_pawn_moves(&game, WHITE);
+        assert_eq!(pawn_moves, ());
+    }
 }
 
 

src/search.rs

@@ -1,2 +1,77 @@
 use std::sync::mpsc::Receiver;
 
+use bitboard::Bitboard;
+use movegen::*;
+
+
+pub struct Game
+{
+    pieces: [Bitboard; 12],
+    en_passant: u8,
+}
+
+impl Default for Game {
+    fn default () -> Game {
+        Game {
+            pieces: [0; 12],
+            en_passant: 0,
+        }
+    }
+}
+impl Game {
+    pub fn bitboard(&self, pt: PieceType, side: Side) -> Bitboard {
+        if side == BLACK {
+            self.pieces[(pt + 6) as usize]
+        } else {
+            self.pieces[pt as usize]
+        }
+    }
+
+    pub fn pawns(&self, side: Side) -> Bitboard {
+        match side {
+            WHITE => self.pieces[0],
+            BLACK => self.pieces[6],
+        }
+    }
+
+    pub fn knights(&self, side: Side) -> Bitboard {
+        match side {
+            WHITE => self.pieces[1],
+            BLACK => self.pieces[7],
+        }
+    }
+
+    pub fn bishops(&self, side: Side) -> Bitboard {
+        match side {
+            WHITE => self.pieces[2],
+            BLACK => self.pieces[8],
+        }
+    }
+
+    pub fn rooks(&self, side: Side) -> Bitboard {
+        match side {
+            WHITE => self.pieces[3],
+            BLACK => self.pieces[9],
+        }
+    }
+
+    pub fn queens(&self, side: Side) -> Bitboard {
+        match side {
+            WHITE => self.pieces[4],
+            BLACK => self.pieces[10],
+        }
+    }
+
+    pub fn kings(&self, side: Side) -> Bitboard {
+        match side {
+            WHITE => self.pieces[5],
+            BLACK => self.pieces[11],
+        }
+    }
+}
+
+pub fn search() {
+
+}
+
+