[DEAD END] This makes rustc crash

(this branch is only for reporting the bug)

Author: ludat

src/game.rs

@@ -7,8 +7,9 @@ use std::cmp::{Ord, Eq, PartialOrd, Ordering};
 use std::ops::{Not, Add, Neg};
 
 extern crate bit_vec;
+extern crate test;
 
-const KING_MOVES: [PositionDelta; 8] = [
+const KING_DELTAS: &'static [PositionDelta; 8] = &[
     PositionDelta { x:  1, y:  1},
     PositionDelta { x:  1, y:  0},
     PositionDelta { x:  1, y: -1},
@@ -18,7 +19,7 @@ const KING_MOVES: [PositionDelta; 8] = [
     PositionDelta { x:  0, y:  1},
     PositionDelta { x:  0, y: -1},
 ];
-const KNIGHT_MOVES: [PositionDelta; 8] = [
+const KNIGHT_DELTAS: &'static [PositionDelta; 8] = &[
     PositionDelta { x:  1, y:  2},
     PositionDelta { x: -1, y:  2},
     PositionDelta { x:  1, y: -2},
@@ -29,7 +30,7 @@ const KNIGHT_MOVES: [PositionDelta; 8] = [
     PositionDelta { x: -2, y: -1},
 ];
 
-const QUEEN_DIRS: [Direction; 8] = [
+const QUEEN_DIRS: &'static [Direction; 8] = &[
     Up,
     Down,
     Right,
@@ -40,14 +41,14 @@ const QUEEN_DIRS: [Direction; 8] = [
     DownLeft,
 ];
 
-const ROOK_DIRS: [Direction; 4] = [
+const ROOK_DIRS: &'static [Direction; 4] = &[
     Up,
     Down,
     Right,
     Left,
 ];
 
-const BISHOP_DIRS: [Direction; 4] = [
+const BISHOP_DIRS: &'static [Direction; 4] = &[
     UpRight,
     UpLeft,
     DownRight,
@@ -449,8 +450,8 @@ impl Game {
             _ => return moves,
         };
         match piece {
-            piece!(color, King)   => {
-                for delta_pos in KING_MOVES.iter() {
+            piece!(color, pt @ King) | piece!(color, pt @ Knight) => {
+                for delta_pos in pt.get_posible_deltas().iter() {
                     let to_pos = from_pos + *delta_pos;
                     if let Some(to_square) = self.get_raw_square(to_pos) {
                         if ! to_square.has_color(color) {
@@ -513,16 +514,6 @@ impl Game {
                     }
                 }
             },
-            piece!(color, Knight) => {
-                for delta_pos in KNIGHT_MOVES.iter() {
-                    let to_pos = from_pos + *delta_pos;
-                    if let Some(to_square) = self.get_raw_square(to_pos) {
-                        if ! to_square.has_color(color) {
-                            moves.push_back(ValuedMove::new(from_pos, to_pos, MoveType::Normal));
-                        }
-                    }
-                }
-            },
             piece!(color, Pawn)   => {
                 let (promotion_y, long_move_y, foward_dir) = match color {
                     White => (Position::ch2y('7'), Position::ch2y('2'), Up),
@@ -590,6 +581,13 @@ impl fmt::Display for Game {
     }
 }
 
+#[bench]
+fn bench_is_valid(b: &mut test::Bencher) {
+    let mut game: Game = Game::new();
+    // b.iter(|| game.make_move(&Move::safe_from_string("e2e4")));
+    b.iter(|| game.make_move(&Move::safe_from_string("a1e4")));
+}
+
 #[test]
 fn test_helper_functions() {
     let mut game = Game::new();
@@ -791,6 +789,22 @@ impl PieceType {
             Pawn   => 1,
         }
     }
+
+    pub fn get_posible_dirs(&self) -> &'static [Direction] {
+        match *self {
+            Queen => QUEEN_DIRS,
+            Rook => ROOK_DIRS,
+            Bishop => BISHOP_DIRS,
+            _ => unreachable!("Asked posible directions of a piece that doesn't have posible directions"),
+        }
+    }
+    pub fn get_posible_deltas(&self) -> &'static [PositionDelta] {
+        match *self {
+            King => KING_DELTAS,
+            Knight => KNIGHT_DELTAS,
+            _ => unreachable!("Asked posible positions of a piece that doesn't have defined positions"),
+        }
+    }
 }
 
 impl fmt::Display for PieceType {

src/lurri.rs

@@ -7,10 +7,10 @@ extern crate rand;
 extern crate test;
 
 pub fn get_move(game: &Game) -> Move {
-    get_best_move(game, 1, 1)
+    get_best_move(game)
 }
 
-pub fn get_best_move(game: &Game, final_depth: u32, current_depth: u32) -> Move {
+pub fn get_best_move(game: &Game) -> Move {
     let mut moves = game.get_all_valid_moves();
     game.evaluate_moves(&mut moves);
     let mov: ValuedMove = match game.turn {
@@ -23,28 +23,26 @@ pub fn get_best_move(game: &Game, final_depth: u32, current_depth: u32) -> Move
 
 impl Game {
     pub fn evaluate(&self) -> i32 {
-        Position::all().fold(0, |acc, val|
-            match self.get_piece(val) {
+        Position::all().fold(0, |acc, pos|
+            match self.get_piece(pos) {
                 None => acc,
                 Some(piece) =>
-                    acc + piece.get_value() * 10 + piece.color.get_sign() * (self.get_valid_moves(val).len() as i32),
+                    acc + piece.get_value() * 10
+                    + piece.color.get_sign() * (self.get_valid_moves(pos).len() as i32)
+                    ,
             }
         )
     }
     pub fn evaluate_move(&self, mov: &Move) -> i32 {
         let mut aux_game = (*self).clone();
         if let Err(e) = aux_game.make_move(mov) {
-            println!("ERROR mov: {}, reason: {}", mov, e)
+            println!("ERROR (engine generated an invalid move) mov: {}, reason: {}", mov, e)
         }
         aux_game.evaluate()
     }
-    pub fn evaluate_moves<'a>(&'a self, moves: &'a mut LinkedList<ValuedMove>) -> &'a mut LinkedList<ValuedMove> {
+    pub fn evaluate_moves<'a>(&self, moves: &'a mut LinkedList<ValuedMove>) -> &'a mut LinkedList<ValuedMove> {
         for mov in moves.iter_mut() {
-            if mov.value.is_none() {
-                mov.value = Some(self.evaluate_move(&mov.mov))
-            } else {
-                panic!("tried to value an already valued move")
-            }
+            mov.value = Some(self.evaluate_move(&mov.mov))
         }
         moves
     }
@@ -57,9 +55,25 @@ fn test_evaluate() {
 }
 
 #[bench]
-fn bench_speed(b: &mut test::Bencher) {
-    let mut game: Game = Game::new();
-    b.iter(|| get_move(&game));
-    game.make_move(&Move::safe_from_string("e2e4"));
+fn bench_evaluate(b: &mut test::Bencher) {
+    let game: Game = Game::new();
+    b.iter(|| game.evaluate());
+}
+#[bench]
+fn bench_get_all_valid_moves(b: &mut test::Bencher) {
+    let game: Game = Game::new();
+    b.iter(|| game.get_all_valid_moves());
+}
+#[bench]
+fn bench_evaluate_linkedlist(b: &mut test::Bencher) {
+    let game: Game = Game::new();
+    b.iter(|| {
+        let mut moves = game.get_all_valid_moves();
+        game.evaluate_moves(&mut moves);
+    });
+}
+#[bench]
+fn bench_get_move(b: &mut test::Bencher) {
+    let game: Game = Game::new();
     b.iter(|| get_move(&game));
 }