You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
53 lines
2.3 KiB
53 lines
2.3 KiB
//! UCI is a simple library to allow people to ignore the lower-level protocol needed to create chess engines. |
|
//! The engine is fully generic. By specifying a valid reader and writing you can send the messages to STDIN |
|
//! and STDOUT, per the standard - or to memory for testing. |
|
|
|
mod commands; |
|
|
|
pub struct Engine<'a, R, W> { |
|
pub name: &'a str, |
|
pub author: &'a str, |
|
pub mut reader: R, |
|
pub mut writer: W, |
|
} |
|
|
|
/// Notes to delete later: |
|
/// |
|
/// |
|
/// A way to make this comfortable for users to use is this provides easy access to commands as well as a |
|
/// loop and stuff they can use. This way they don't have to override anything - they just include this |
|
/// in their code for their engine to make the communication portion easy. |
|
/// |
|
/// Think of this in the manner of a game engine. They don't provide the loop and everything, but they do |
|
/// provide convenience functions and stuff to make _building_ that loop easier. |
|
/// |
|
/// In other words, the engine writer still needs to know how the standard works. They just don't need to |
|
/// implement all the nasty details. |
|
/// For example, a start up function calls the correct "boot up" code for the engine so they only have to |
|
/// worry about calling "boot up" prior to their main engine loop. |
|
/// |
|
/// Additionally this code should have a parser. You call it with the reader supplied and it waits for a command |
|
/// and parses it into a tuple of some kind for the user. |
|
|
|
impl<'a> Engine<'a, R, W> { |
|
pub fn new(name: &'a str, author: &'a str, reader: R, writer: W) -> Engine<'a> { |
|
Engine { |
|
name: name, |
|
author: author, |
|
reader: R, |
|
writer: W, |
|
} |
|
} |
|
|
|
/// Sends identification messages to the writer for the GUI to pick up |
|
/// TODO: Write tests for this. Reference: |
|
/// https://stackoverflow.com/questions/28370126/how-can-i-test-stdin-and-stdout |
|
pub fn identify(&self) { |
|
let name_id: String = fmt!("{} {} {}", constants::ID, constants::NAME, self.name); |
|
let author_id: String = fmt!("{} {} {}", constants::ID, constants::AUTHOR, self.author); |
|
|
|
// For these two writes we can panic - there's no possibility of recovery if the engine fails at this stage |
|
write!(&mut self.writer, "{}", name_id).expect("failed to send name identification to writer"); |
|
write!(&mut self.writer, "{}", author_id).expect("failed to send author identification to writer"); |
|
} |
|
}
|
|
|