chore: basic first move mover

Author: raklaptudirm

Cargo.toml

@@ -16,4 +16,4 @@ tetka-games = { path = "./games" }
 
 [workspace]
 resolver = "2"
-members = [ "uxi", "games" ]
+members = [ "uxi", "games", "friendhaver" ]

friendhaver/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "friendhaver"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tetka = { path = ".." }
+rand = "0.8.5"
+derive-new = "0.5"
+derive_more = "0.99.18"
+
+[profile.release]
+opt-level = 3
+codegen-units = 1
+lto = true

friendhaver/src/commands/context.rs

@@ -0,0 +1,22 @@
+use std::str::FromStr;
+
+use tetka::games::isolation::Position;
+
+use crate::search::{self, Searcher};
+
+pub struct Context {
+    pub position: Position,
+    pub searcher: search::Searcher,
+}
+
+impl Default for Context {
+    fn default() -> Self {
+        let position =
+            Position::from_str("--------/--------/p-------/-------P/--------/-------- w 1")
+                .unwrap();
+        Context {
+            position,
+            searcher: Searcher::new(position),
+        }
+    }
+}

friendhaver/src/commands/go.rs

@@ -0,0 +1,134 @@
+use tetka::games::isolation::{self, Position};
+use tetka::uxi::{error, Bundle, Command, Flag, RunError};
+
+use crate::search;
+
+use super::Context;
+
+// TODO: Move these macros into UXI
+
+macro_rules! lock {
+    ($bundle:ident > $ctx:ident => $($stmt:stmt;)*) => {
+        let $ctx = $bundle.lock();
+        $(
+            $stmt
+        )*
+        drop($ctx);
+    };
+
+    ($bundle:ident > mut $ctx:ident => $($stmt:stmt;)*) => {
+        let mut $ctx = $bundle.lock();
+        $(
+            $stmt
+        )*
+        drop($ctx);
+    };
+}
+
+pub fn go() -> Command<Context> {
+    Command::new(|bundle: Bundle<Context>| {
+        lock! {
+            bundle > ctx =>
+            let position = ctx.position; // Get the position to search
+            let mut searcher = ctx.searcher.clone(); // Get the previous search state
+        }
+
+        let mut nodes = 0;
+
+        // Update the searcher with the new position and start searching.
+        searcher.update_position(position);
+        let limits = parse_limits(&bundle, &position)?;
+        let bestmove = searcher.search(limits, &mut nodes);
+
+        println!("bestmove {}", bestmove);
+
+        lock! {
+            bundle > mut ctx =>
+            // Push the new search state to the context.
+            ctx.searcher = searcher;
+        }
+
+        Ok(())
+    })
+    // Flags for reporting the current time situation.
+    .flag("p2inc", Flag::Single)
+    .flag("p1inc", Flag::Single)
+    .flag("p2time", Flag::Single)
+    .flag("p1time", Flag::Single)
+    .flag("movestogo", Flag::Single)
+    // Flags for imposing other search limits.
+    .flag("depth", Flag::Single)
+    .flag("nodes", Flag::Single)
+    .flag("movetime", Flag::Single)
+    // Flags for setting the search type.
+    // .flag("ponder", Flag::Single)
+    .flag("infinite", Flag::Single)
+    // This command should be run in a separate thread so that the Client
+    // can still respond to and run other Commands while this one is running.
+    .parallelize(true)
+}
+
+fn parse_limits(bundle: &Bundle<Context>, position: &Position) -> Result<search::Limits, RunError> {
+    ////////////////////////////////////////////
+    // Check which of the limit flags are set //
+    ////////////////////////////////////////////
+
+    // Standard Time Control flags
+    let p1inc = bundle.is_flag_set("p1inc");
+    let p2inc = bundle.is_flag_set("p2inc");
+    let p1time = bundle.is_flag_set("p1time");
+    let p2time = bundle.is_flag_set("p2time");
+
+    // Other limit flags
+    let depth = bundle.is_flag_set("depth");
+    let nodes = bundle.is_flag_set("nodes");
+    let movetime = bundle.is_flag_set("movetime");
+
+    // Infinite flag
+    let infinite = bundle.is_flag_set("infinite");
+
+    ///////////////////////////////////////////////////////
+    // Ensure that the given flag configuration is valid //
+    ///////////////////////////////////////////////////////
+
+    let std_tc = p2time || p1time || p2inc || p1inc;
+    let oth_tc = depth || nodes || movetime;
+
+    // No other time control flags may be set alongside 'infinite'.
+    if infinite && (std_tc || oth_tc) {
+        return error!("bad flag set: time control flags set alongside infinite");
+    }
+
+    // A little utility macro to parse the given flag into the required type.
+    macro_rules! get_flag {
+        ($name:expr) => {
+            match bundle.get_single_flag($name) {
+                Some(value) => Some(value.parse()?),
+                None => None,
+            }
+        };
+    }
+
+    ////////////////////////////////////////////
+    // Parse the provided search/perft limits //
+    ////////////////////////////////////////////
+
+    Ok(search::Limits {
+        maxnodes: get_flag!("nodes"),
+        maxdepth: get_flag!("depth"),
+        movetime: if std_tc {
+            let (time, incr) = match position.side_to_move {
+                isolation::Color::White => ("p1time", "p1inc"),
+                isolation::Color::Black => ("p2time", "p2inc"),
+            };
+
+            let time: u128 = get_flag!(time).unwrap_or(0);
+            let incr: u128 = get_flag!(incr).unwrap_or(0);
+
+            Some((time / 20 + incr / 2).max(1))
+        } else {
+            get_flag!("movetime")
+        },
+        movestogo: get_flag!("movestogo"),
+    })
+}

friendhaver/src/commands/mod.rs

@@ -0,0 +1,11 @@
+// pub use bench::*;
+pub use context::*;
+pub use go::*;
+pub use position::*;
+pub use simple::*;
+
+// mod bench;
+mod context;
+mod go;
+mod position;
+mod simple;

friendhaver/src/commands/position.rs

@@ -0,0 +1,42 @@
+use std::str::FromStr;
+
+use tetka::games::{interface::PositionType, isolation};
+use tetka::uxi::{error, Bundle, Command, Flag, RunError};
+
+use super::Context;
+
+pub fn position() -> Command<Context> {
+    Command::new(|bundle: Bundle<Context>| {
+        let mut ctx = bundle.lock();
+
+        let has_fen = bundle.is_flag_set("fen");
+        let has_startpos = bundle.is_flag_set("startpos");
+
+        if has_fen && has_startpos {
+            return error!("only one of 'fen <fen>' or 'startpos' flags expected");
+        }
+
+        let fen = if has_startpos {
+            "--------/--------/p-------/-------P/--------/-------- w 1".to_string()
+        } else if has_fen {
+            bundle.get_array_flag("fen").unwrap().join(" ")
+        } else {
+            return error!("one of 'startpos' or 'fen <fen>' flags expected");
+        };
+
+        ctx.position = isolation::Position::from_str(&fen)?;
+
+        if bundle.is_flag_set("moves") {
+            for mov in bundle.get_array_flag("moves").unwrap() {
+                ctx.position = ctx
+                    .position
+                    .after_move::<true>(isolation::Move::from_str(&mov)?);
+            }
+        }
+
+        Ok(())
+    })
+    .flag("fen", Flag::Array(4))
+    .flag("startpos", Flag::Boolean)
+    .flag("moves", Flag::Variadic)
+}

friendhaver/src/commands/simple.rs

@@ -0,0 +1,34 @@
+use std::str::FromStr;
+
+use tetka::games::isolation;
+use tetka::uxi::Command;
+
+use super::Context;
+
+pub fn d() -> Command<Context> {
+    Command::new(|bundle| {
+        let ctx = bundle.lock();
+        println!("{}", ctx.position);
+
+        Ok(())
+    })
+}
+
+pub fn uginewgame() -> Command<Context> {
+    Command::new(|bundle| {
+        let mut ctx = bundle.lock();
+        ctx.position = isolation::Position::from_str(
+            "--------/--------/p-------/-------P/--------/-------- w 1",
+        )?;
+
+        Ok(())
+    })
+}
+
+pub fn protocol() -> Command<Context> {
+    Command::new(|bundle| {
+        let ctx = bundle.lock();
+        println!("current protocol: {}", ctx.protocol());
+        Ok(())
+    })
+}

friendhaver/src/main.rs

@@ -0,0 +1,37 @@
+use std::env;
+
+use tetka::uxi::Client;
+
+mod commands;
+mod options;
+mod search;
+
+fn main() {
+    let client = Client::new()
+        .protocol("uii")
+        .engine("FriendHaver v0.0.0")
+        .author("Rak Laptudirm")
+        // Register engine options.
+        .option("Hash", options::hash())
+        .option("Threads", options::threads())
+        // Register the custom commands.
+        .command("d", commands::d())
+        .command("go", commands::go())
+        .command("protocol", commands::protocol())
+        .command("position", commands::position())
+        .command("uginewgame", commands::uginewgame());
+
+    let args = env::args()
+        .skip(1)
+        .reduce(|acc, e| format!("{} {}", acc, e))
+        .unwrap_or("".to_string());
+    let args = args.trim().to_string();
+    if args.is_empty() {
+        client.start(Default::default());
+    } else {
+        println!("args found {}", args);
+        if let Err(err) = client.run_cmd_string(args, Default::default()) {
+            println!("{}", err);
+        };
+    }
+}

friendhaver/src/options.rs

@@ -0,0 +1,9 @@
+use tetka::uxi::Parameter;
+
+pub fn hash() -> Parameter {
+    Parameter::Spin(16, 1, 33554432)
+}
+
+pub fn threads() -> Parameter {
+    Parameter::Spin(1, 1, 1024)
+}

friendhaver/src/search/mod.rs

@@ -0,0 +1,34 @@
+use tetka::games::{
+    interface::{MoveType, PositionType},
+    isolation,
+};
+
+#[derive(Clone)]
+pub struct Searcher {
+    position: isolation::Position,
+}
+
+impl Searcher {
+    pub fn new(position: isolation::Position) -> Searcher {
+        Searcher { position }
+    }
+
+    pub fn update_position(&mut self, position: isolation::Position) {
+        self.position = position;
+    }
+
+    pub fn search(&mut self, limits: Limits, nodes: &mut usize) -> isolation::Move {
+        let moves = self.position.generate_moves::<false, true, true>();
+        moves.into_iter().next().unwrap_or(isolation::Move::NULL)
+    }
+}
+
+#[derive(Debug)]
+pub struct Limits {
+    pub maxdepth: Option<usize>,
+    pub maxnodes: Option<usize>,
+    pub movetime: Option<u128>,
+
+    #[allow(unused)]
+    pub movestogo: Option<usize>,
+}

src/main.rs

@@ -0,0 +1,23 @@
+use std::env;
+use std::{str::FromStr, time};
+use tetka::games::{isolation, perft};
+
+fn main() {
+    let depth = env::args().nth(1).unwrap_or("5".to_string());
+    let fen = env::args()
+        .nth(2)
+        .unwrap_or("--------/--------/p-------/-------P/--------/-------- w 1".to_string());
+
+    let position = isolation::Position::from_str(&fen).unwrap();
+    println!("{}", position);
+
+    let start = time::Instant::now();
+    let nodes = perft::<true, true, isolation::Position>(position, depth.parse().unwrap());
+    let elapsed = start.elapsed();
+
+    println!(
+        "nodes {} nps {}",
+        nodes,
+        nodes as u128 * 1000 / elapsed.as_millis().max(1)
+    )
+}