Bitboards and compact representation features (#4)

* Bitboards
* Compact representation
* Rename move module to eval
* Fix broken UI from previous changes

between.py

@@ -0,0 +1,54 @@
+print("const IN_BETWEEN_TABLE: [[u64; 64]; 64] = [")
+
+def index_to_rank_and_file(index):
+    rank = index // 8
+    file = index % 8
+    return rank, file
+
+for source_index in range(64):
+    print("    [")
+    for target_index in range(64):
+        # Check if the source and target are on the same rank, file or diagonal
+        source_rank, source_file = index_to_rank_and_file(source_index)
+        target_rank, target_file = index_to_rank_and_file(target_index)
+        if source_rank == target_rank or source_file == target_file or abs(source_rank - target_rank) == abs(source_file - target_file):
+            # They are on the same rank, file or diagonal
+            if source_index == target_index:
+                # They are the same square
+                print("        0,")
+            else:
+                # They are on the same rank, file or diagonal, but not the same square
+                # Print the squares in between
+                squares_in_between = []
+                if source_rank == target_rank:
+                    # They are on the same rank
+                    for file in range(min(source_file, target_file) + 1, max(source_file, target_file)):
+                        squares_in_between.append(source_rank * 8 + file)
+                elif source_file == target_file:
+                    # They are on the same file
+                    for rank in range(min(source_rank, target_rank) + 1, max(source_rank, target_rank)):
+                        squares_in_between.append(rank * 8 + source_file)
+                else:
+                    # They are on the same diagonal
+                    for i in range(1, abs(source_rank - target_rank)):
+                        if source_rank < target_rank:
+                            rank = source_rank + i
+                        else:
+                            rank = source_rank - i
+                        if source_file < target_file:
+                            file = source_file + i
+                        else:
+                            file = source_file - i
+                        squares_in_between.append(rank * 8 + file)
+                if len(squares_in_between) == 0:
+                    # There are no squares in between
+                    print("        0,")
+                else:
+                    # Print the squares in between
+                    print(f"        0x{sum([2 ** square for square in squares_in_between]):016x},")
+        else:
+            # They are not on the same rank, file or diagonal
+            print("        0,")
+    print("    ],")
+
+print("];")

bump_version.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 
 usage() {
     echo "Usage: $0 <major> <minor> <patch>"
@@ -26,4 +26,4 @@ cd src-tauri
 cargo bump "$new_ver"
 
 echo Updating tauri.conf.json
-sed -E -i '' "s/\"version\": \"[0-9.]+\"/\"version\": \"$new_ver\"/" tauri.conf.json
+sed -E -i'' "s/\"version\": \"[0-9.]+\"/\"version\": \"$new_ver\"/" tauri.conf.json

chusst-uci/src/engine.rs

@@ -1,12 +1,12 @@
 use crate::duplex_thread::{create_duplex_thread, DuplexThread};
-use chusst::board::{Game, Move};
-use chusst::moves::{
-    do_move, get_best_move_with_logger, EngineFeedback, EngineFeedbackMessage, GameMove,
-    HasStopSignal,
+use chusst::eval::{
+    do_move, get_best_move_with_logger, EngineFeedback, EngineFeedbackMessage, EngineMessage,
+    GameMove, HasStopSignal,
 };
+use chusst::game::{Game, Move};
 
-use std::io::Write;
 use std::fmt;
+use std::io::Write;
 
 #[derive(Clone)]
 pub struct GoCommand {
@@ -124,8 +124,15 @@ impl<'a> BufferedSenderWriter<'a> {
 }
 
 impl<'a> EngineFeedback for BufferedSenderWriter<'a> {
-    fn send(&self, msg: EngineFeedbackMessage) {
-        let _ = self.send(EngineResponse::Info(msg));
+    fn send(&self, msg: EngineMessage) {
+        match msg {
+            EngineMessage::Info(msg) => {
+                let _ = self.send(EngineResponse::Log(msg.message));
+            }
+            EngineMessage::SearchFeedback(msg) => {
+                let _ = self.send(EngineResponse::Info(msg));
+            }
+        }
     }
 }
 

chusst-uci/src/main.rs

@@ -2,8 +2,8 @@ mod duplex_thread;
 mod engine;
 mod stdin;
 
-use chusst::board::{Game, Move};
-use chusst::moves::GameMove;
+use chusst::eval::GameMove;
+use chusst::game::{Game, Move};
 use engine::{create_engine_thread, EngineCommand, EngineResponse, GoCommand, NewGameCommand};
 use stdin::{create_stdin_thread, StdinResponse};
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "chusst",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "dependencies": {
     "@tauri-apps/api": "^1.4.0",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chusst"
-version = "0.7.0"
+version = "0.8.0"
 description = "A simple chess engine in Rust"
 authors = ["Oriol Arcas"]
 license = ""
@@ -23,8 +23,14 @@ atty = "0.2.14"
 bencher = "0.1.5"
 
 [features]
-# DO NOT set 'default', breaks production build
-
+# default = ["compact-board"]
+# default = ["bitboards"]
+# default = ["compact-board", "bitboards"]
+
+# Use bitboards to evaluate valid moves
+bitboards = []
+# Use a memory-efficient representation of the board (1 byte per square)
+compact-board = []
 # Build with this feature to print the search tree to stdout
 verbose-search = []
 

src-tauri/benches/search.rs

@@ -1,5 +1,5 @@
-use chusst::board::Game;
-use chusst::moves::{do_move, get_best_move_recursive, SilentSearchFeedback};
+use chusst::eval::{do_move, get_best_move_recursive, SilentSearchFeedback};
+use chusst::game::Game;
 
 #[macro_use]
 extern crate bencher;