more stuffy

src/bitboard.rs

@@ -7,6 +7,7 @@
  *
  */
 pub type Bitboard = u64;
+pub type Square = u8;
 
 
 
@@ -77,6 +78,10 @@ pub fn set_bit_index(b: &mut Bitboard, index: u32) {
     *b |= 1 << index;
 }
 
+pub fn square(b: Bitboard) -> Square {
+    b.trailing_zeros() as Square
+}
+
 pub fn print_board(b: Bitboard) -> String {
     (0..8).map(
         |i| (0..8).map(

src/engine.rs

@@ -30,9 +30,12 @@ pub enum InterfaceMsg {
 pub fn run_engine(r: Receiver<EngineMsg>, s: Sender<InterfaceMsg>) {
     let mut game = Game::default();
     for msg in r {
-        game.pieces[0] = 0xFF00;
-        generate_pawn_moves(&game, WHITE);
-        println!("engine received message");
+        game.pieces[0] = 0x00ff_0000_0000_0100;
+        game.pieces[10] = 0x4000_0000_0000_0000;
+        let moves = generate_moves(&game, WHITE);
+        for mov in moves {
+            println!("move: {:?}", mov);
+        }
     }
 }
 

src/movegen.rs

@@ -1,8 +1,8 @@
 use bitboard::Bitboard;
+use bitboard::Square;
 use bitboard::*;
 use search::Game;
 
-pub type Square = u8;
 pub type Side = bool;
 
 pub const WHITE: Side = false;
@@ -17,17 +17,18 @@ pub const ROOK: PieceType = 3;
 pub const QUEEN: PieceType = 4;
 pub const KING: PieceType = 5;
 
-
+#[derive(Copy, Clone, Debug)]
 pub struct SimpleMove {
     from: Square,
     to: Square,
 }
 
+#[derive(Debug)]
 pub enum Move {
     Default { mov: SimpleMove, piece_type: PieceType },
     Castling { side: Side, left: bool },
     EnPassant { side: Side, column: u8 },
-    Promotion { side: Side, column: u8, promote_to: PieceType },
+    Promotion { mov: SimpleMove, promote_to: PieceType },
 }
 
 /**
@@ -53,6 +54,16 @@ impl Iterator for BitboardIterator {
 }
 
 
+pub fn generate_moves(game: &Game, side: Side) -> Vec<Move> {
+    let mut moves: Vec<Move> = Vec::new();
+    generate_pawn_pushes(game, side, &mut moves);
+    generate_pawn_captures(game, side, &mut moves);
+    generate_bishop_moves(game, side, &mut moves);
+    return moves;
+}
+
+
+/*
 pub fn generate_pawn_moves(game: &Game, side: Side) -> Bitboard {
     let pushed = generate_pawn_pushes(game, side);
     let iter = BitboardIterator { board: pushed };
@@ -61,31 +72,56 @@ pub fn generate_pawn_moves(game: &Game, side: Side) -> Bitboard {
     }
 
     return 0;
-}
+}*/
 
-fn generate_pawn_pushes(game: &Game, side: Side) -> Bitboard {
+fn generate_pawn_pushes(game: &Game, side: Side, move_list: &mut Vec<Move>) {
     let pawns = game.pawns(side);
     let others = game.get_all_side(!side);
     let moved_pawns =
         match side {
             WHITE => north_one(pawns),
             BLACK => south_one(pawns)
-        }
-            & !(ROW_1 | ROW_8);
+        } & !(ROW_1 | ROW_8);
 
-    let possible_pushes = moved_pawns & !others;
-    return possible_pushes;
+    let iter = BitboardIterator { board: moved_pawns & !others };
+    for p in iter {
+        let origin = match side {
+            WHITE => south_one(p),
+            BLACK => north_one(p)
+        };
+        move_list.push(Move::Default { mov: SimpleMove { from: square(origin), to: square(p) }, piece_type: PAWN });
+    }
 }
 
 fn generate_pawn_captures(game: &Game, side: Side, move_list: &mut Vec<Move>) {
     let pawns = game.pawns(side);
     let others = game.get_all_side(!side);
+    let promotion_mask = ROW_1 | ROW_8;
 
-    let pawn_iterator = BitboardIterator{ pawns };
+    let pawn_iterator = BitboardIterator { board: pawns };
 
     for pawn in pawn_iterator {
         let left_cap = match side {
-
+            WHITE => northeast_one(pawn),
+            BLACK => southeast_one(pawn)
+        };
+        let right_cap = match side {
+            WHITE => northwest_one(pawn),
+            BLACK => southwest_one(pawn)
+        };
+
+        for cap in [left_cap, right_cap].iter() {
+            if cap & others != 0 {
+                let simple_move = SimpleMove { from: pawn.trailing_zeros() as u8, to: cap.trailing_zeros() as u8 };
+                if cap & promotion_mask != 0 {
+                    move_list.push(Move::Promotion { mov: simple_move, promote_to: QUEEN });
+                    move_list.push(Move::Promotion { mov: simple_move, promote_to: ROOK });
+                    move_list.push(Move::Promotion { mov: simple_move, promote_to: BISHOP });
+                    move_list.push(Move::Promotion { mov: simple_move, promote_to: KNIGHT });
+                } else {
+                    move_list.push(Move::Default { mov: simple_move, piece_type: PAWN });
+                }
+            }
         }
     }
 }