aa

src/engine.rs

@@ -7,6 +7,7 @@ use evaluate::PosValue;
 use log::{info};
 use std::time::{Duration, Instant};
 use std::collections::{VecDeque, HashMap};
+use zobrist::ZobristTable;
 
 use std::thread::sleep_ms;
 use std::sync::mpsc::{Receiver, Sender};
@@ -48,17 +49,21 @@ pub struct Engine {
     messages: VecDeque<EngineMsg>,
     r: Receiver<EngineMsg>,
     s: Sender<InterfaceMsg>,
-    hash: HashMap<Game, HashEntry>
+    hash: HashMap<Game, HashEntry>,
+    zobrist_table: ZobristTable
 }
 
 impl Engine {
     pub fn new(r: Receiver<EngineMsg>, s: Sender<InterfaceMsg>) -> Self {
-        Engine {
+        let mut eng = Engine {
             game: Game::default(),
             messages: VecDeque::new(),
             r, s,
-            hash: HashMap::new()
-        }
+            hash: HashMap::new(),
+            zobrist_table: ZobristTable::new()
+        };
+        eng.game.zobrist = Some(eng.game.calculate_zobrist(&eng.zobrist_table));
+        eng
     }
 
     pub fn run(&mut self) {

src/game.rs

@@ -4,7 +4,7 @@ use log::info;
 use zobrist::{ZobristTable};
 use zobrist;
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct Game
 {
     pub pieces: [Bitboard; 12],
@@ -20,7 +20,8 @@ pub struct Game
     /// 
     pub castling_rights: [bool; 4],
     pub halfmoves_since_last_event: i32,
-    pub turn_number: i32,
+
+    pub zobrist: Option<zobrist::Hash>
 }
 
 impl Default for Game {
@@ -44,7 +45,8 @@ impl Default for Game {
             en_passant: None,
             castling_rights: [true; 4],
             halfmoves_since_last_event: 0,
-            turn_number: 0
+            //turn_number: 0,
+            zobrist: None
         }
     }
 }
@@ -57,7 +59,8 @@ impl Game {
             en_passant: None,
             castling_rights: [true; 4],
             halfmoves_since_last_event: 0,
-            turn_number: 0
+            //turn_number: 0,
+            zobrist: None
         }
     }
 
@@ -128,7 +131,7 @@ impl Game {
         info!("en passant on file {:?}", game.en_passant);
 
         game.halfmoves_since_last_event = halfmoves_since_last_event.parse::<i32>().unwrap_or(0);
-        game.turn_number = turn_number.parse::<i32>().unwrap_or(0);
+        //game.turn_number = turn_number.parse::<i32>().unwrap_or(0);
         
         Some(game)
     }
@@ -445,3 +448,12 @@ impl Game {
         return hash;
     }
 }
+
+
+impl std::hash::Hash for Game {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        if let Some(zb) = self.zobrist {
+            zb.hash(state);
+        }
+    }
+}

src/hash.rs

@@ -1,14 +1,17 @@
 use game::Game;
 use evaluate::PosValue;
 use std::collections::{HashMap};
-use std::hash::{BuildHasher, Hasher};
+use std::hash::{BuildHasher, Hasher, Hash};
+use log::info;
 
+#[derive(Clone)]
 pub enum EntryType {
     Value,
     LowerBound,
     UpperBound,
 }
 
+#[derive(Clone)]
 pub struct CacheEntry {
     entry_type: EntryType,
     depth: i32,
@@ -19,26 +22,22 @@ pub struct Cache {
     hashmap: HashMap<Game, CacheEntry>,
 }
 
-pub struct GameHasher {
-}
-
-impl Hasher for GameHasher {
-    type Hasher = Self;
-
-    fn build_hasher(&self) -> Self::Hasher {
-        GameHasher {}
-    }
-
-    fn hash_one(&self, x: &Game) -> u64 {
-        0
-    }
-}
-
-
 impl Cache {
     pub fn new() -> Self {
         Cache {
-            hashmap: HashMap::with_hasher(hash_builder: S)
+            hashmap: HashMap::new()
+        }
+    }
+
+    pub fn lookup(&self, game_pos: &Game) -> Option<CacheEntry> {
+        self.hashmap.get(game_pos).map(|x| x.clone())
+    }
+    
+    pub fn cache(&mut self, game_pos: &Game, ce: CacheEntry) {
+        if self.hashmap.len() > 1000000 {
+            let first_key = self.hashmap.keys().next().unwrap().clone();
+            self.hashmap.remove(&first_key);
         }
+        self.hashmap.insert(game_pos.clone(), ce);
     }
 }

src/main.rs

@@ -1,4 +1,3 @@
-#![feature(build_hasher_simple_hash_one)]
 mod interface;
 mod bitboard;
 mod movegen;