refactr

rust/runner/src/ansi.rs

@@ -1,3 +1,6 @@
+#![expect(clippy::allow_attributes)]
+#![allow(dead_code)]
+
 pub const RESET: &str = "\x1b[0m";
 pub const RED: &str = "\x1b[31m";
 pub const BLUE: &str = "\x1b[34m";

rust/runner/src/gamestate.rs

@@ -0,0 +1,338 @@
+use minimax::{
+	agents::{Agent, RhaiAgent},
+	game::Board,
+};
+use rand::{rngs::StdRng, SeedableRng};
+use rhai::ParseError;
+use wasm_bindgen::prelude::*;
+
+use crate::ansi;
+
+#[wasm_bindgen]
+pub struct GameState {
+	red_agent: RhaiAgent<StdRng>,
+	blue_agent: RhaiAgent<StdRng>,
+
+	board: Board,
+	is_red_turn: bool,
+	is_first_turn: bool,
+	is_error: bool,
+	red_is_maximizer: bool,
+	red_score: Option<f32>,
+	red_won: Option<bool>,
+
+	game_state_callback: Box<dyn Fn(&str) + 'static>,
+}
+
+#[wasm_bindgen]
+impl GameState {
+	#[wasm_bindgen(constructor)]
+	pub fn new(
+		red_script: &str,
+		red_print_callback: js_sys::Function,
+		red_debug_callback: js_sys::Function,
+
+		blue_script: &str,
+		blue_print_callback: js_sys::Function,
+		blue_debug_callback: js_sys::Function,
+
+		game_state_callback: js_sys::Function,
+	) -> Result<GameState, String> {
+		Self::new_native(
+			red_script,
+			move |s| {
+				let _ = red_print_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+			move |s| {
+				let _ = red_debug_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+			blue_script,
+			move |s| {
+				let _ = blue_print_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+			move |s| {
+				let _ = blue_debug_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+			move |s| {
+				let _ = game_state_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+		)
+		.map_err(|x| format!("Error at {}: {}", x.1, x.0))
+	}
+
+	fn new_native(
+		red_script: &str,
+		red_print_callback: impl Fn(&str) + 'static,
+		red_debug_callback: impl Fn(&str) + 'static,
+
+		blue_script: &str,
+		blue_print_callback: impl Fn(&str) + 'static,
+		blue_debug_callback: impl Fn(&str) + 'static,
+
+		game_state_callback: impl Fn(&str) + 'static,
+	) -> Result<GameState, ParseError> {
+		console_error_panic_hook::set_once();
+
+		let mut seed1 = [0u8; 32];
+		let mut seed2 = [0u8; 32];
+		getrandom::getrandom(&mut seed1).unwrap();
+		getrandom::getrandom(&mut seed2).unwrap();
+
+		Ok(GameState {
+			board: Board::new(),
+			is_first_turn: true,
+			is_error: false,
+			red_score: None,
+			is_red_turn: true,
+			red_is_maximizer: true,
+			red_won: None,
+
+			red_agent: RhaiAgent::new(
+				red_script,
+				StdRng::from_seed(seed1),
+				red_print_callback,
+				red_debug_callback,
+			)?,
+
+			blue_agent: RhaiAgent::new(
+				blue_script,
+				StdRng::from_seed(seed2),
+				blue_print_callback,
+				blue_debug_callback,
+			)?,
+
+			game_state_callback: Box::new(game_state_callback),
+		})
+	}
+
+	// Play one turn
+	#[wasm_bindgen]
+	pub fn step(&mut self) -> Result<(), String> {
+		if self.is_done() {
+			return Ok(());
+		}
+
+		let action = match (self.is_red_turn, self.red_is_maximizer) {
+			(false, false) => self.blue_agent.step_max(&self.board),
+			(false, true) => self.blue_agent.step_min(&self.board),
+			(true, false) => self.red_agent.step_min(&self.board),
+			(true, true) => self.red_agent.step_max(&self.board),
+		}
+		.map_err(|err| format!("{err}"))?;
+
+		if !self.board.play(
+			action,
+			self.is_red_turn
+				.then_some("Red")
+				.unwrap_or("Blue")
+				.to_owned(),
+		) {
+			self.is_error = true;
+			return Err(format!(
+				"{} ({}) made an invalid move {}",
+				self.is_red_turn.then_some("Red").unwrap_or("Blue"),
+				self.is_red_turn
+					.then_some(self.red_agent.name())
+					.unwrap_or(self.blue_agent.name()),
+				action
+			));
+		}
+
+		if self.board.is_full() {
+			self.print_end()?;
+			return Ok(());
+		}
+
+		self.print_board(
+			self.is_red_turn.then_some(ansi::RED).unwrap_or(ansi::BLUE),
+			self.is_red_turn.then_some("Red").unwrap_or("Blue"),
+		);
+		(self.game_state_callback)("\n\r");
+
+		self.is_red_turn = !self.is_red_turn;
+
+		return Ok(());
+	}
+
+	#[wasm_bindgen]
+	pub fn is_done(&self) -> bool {
+		(self.board.is_full() && self.red_score.is_some()) || self.is_error
+	}
+
+	#[wasm_bindgen]
+	pub fn red_won(&self) -> Option<bool> {
+		self.red_won
+	}
+
+	#[wasm_bindgen]
+	pub fn is_error(&self) -> bool {
+		self.is_error
+	}
+
+	#[wasm_bindgen]
+	pub fn print_start(&mut self) {
+		self.print_board("", "");
+		(self.game_state_callback)("\r\n");
+	}
+
+	#[wasm_bindgen]
+	pub fn print_board(&mut self, color: &str, player: &str) {
+		let board_label = format!("{}{:<6}{}", color, player, ansi::RESET);
+
+		// Print board
+		(self.game_state_callback)(&format!(
+			"\r{}{}{}{}",
+			board_label,
+			if self.is_first_turn { '╓' } else { '║' },
+			self.board.prettyprint(),
+			if self.is_first_turn { '╖' } else { '║' },
+		));
+		self.is_first_turn = false;
+	}
+
+	fn print_end(&mut self) -> Result<(), String> {
+		let board_label = format!(
+			"{}{:<6}{}",
+			self.is_red_turn.then_some(ansi::BLUE).unwrap_or(ansi::RED),
+			self.is_red_turn.then_some("Blue").unwrap_or("Red"),
+			ansi::RESET
+		);
+
+		(self.game_state_callback)(&format!("\r{}║{}║", board_label, self.board.prettyprint()));
+		(self.game_state_callback)("\r\n");
+
+		(self.game_state_callback)(&format!(
+			"\r{}╙{}╜",
+			"      ",
+			" ".repeat(self.board.size())
+		));
+		(self.game_state_callback)("\r\n");
+
+		let score = self.board.evaluate();
+
+		let score = match score {
+			Some(x) => x,
+			None => {
+				self.is_error = true;
+				return Err(format!("could not compute final score"));
+			}
+		};
+
+		(self.game_state_callback)(&format!(
+			"\r\n{}{} score:{} {:.2}\r\n",
+			self.red_is_maximizer
+				.then_some(ansi::RED)
+				.unwrap_or(ansi::BLUE),
+			self.red_is_maximizer.then_some("Red").unwrap_or("Blue"),
+			ansi::RESET,
+			score
+		));
+		(self.game_state_callback)("\r\n");
+
+		match self.red_score {
+			// Start second round
+			None => {
+				let mut seed1 = [0u8; 32];
+				let mut seed2 = [0u8; 32];
+				getrandom::getrandom(&mut seed1).unwrap();
+				getrandom::getrandom(&mut seed2).unwrap();
+
+				self.red_is_maximizer = !self.red_is_maximizer;
+				self.board = Board::new();
+				self.is_red_turn = !self.red_is_maximizer;
+				self.is_first_turn = true;
+				self.is_error = false;
+				self.red_score = Some(score);
+
+				self.print_start();
+			}
+
+			// End game
+			Some(red_score) => {
+				if red_score == score {
+					(self.game_state_callback)(&format!("Tie! Score: {:.2}\r\n", score));
+				} else {
+					let red_wins = red_score > score;
+					self.red_won = Some(red_wins);
+					(self.game_state_callback)(&format!(
+						"{}{} wins!{}",
+						red_wins.then_some(ansi::RED).unwrap_or(ansi::BLUE),
+						red_wins.then_some("Red").unwrap_or("Blue"),
+						ansi::RESET,
+					));
+				}
+			}
+		}
+
+		return Ok(());
+	}
+}
+
+//
+// MARK: tests
+//
+// TODO:
+// - infinite loop
+// - random is different
+// - incorrect return type
+// - globals
+
+#[test]
+fn full_random() {
+	const SCRIPT: &str = r#"
+	fn random_action(board) {
+		let symb = rand_symb();
+		let pos = rand_int(0, 10);
+		let action = Action(symb, pos);
+
+		while !board.can_play(action) {
+			let symb = rand_symb();
+			let pos = rand_int(0, 10);
+			action = Action(symb, pos);
+		}
+
+		return action
+	}
+
+	fn step_min(board) {
+		random_action(board)
+	}
+
+	fn step_max(board) {
+		random_action(board)
+	}
+	"#;
+
+	let mut game =
+		GameState::new_native(&SCRIPT, |_| {}, |_| {}, &SCRIPT, |_| {}, |_| {}, |_| {}).unwrap();
+
+	let mut n = 0;
+	while !game.is_done() {
+		println!("{:?}", game.step());
+		println!("{:?}", game.board);
+
+		n += 1;
+		assert!(n < 10);
+	}
+}
+
+#[test]
+fn infinite_loop() {
+	const SCRIPT: &str = r#"
+	fn step_min(board) {
+		loop {}
+	}
+
+	fn step_max(board) {
+		loop {}
+	}
+	"#;
+
+	let mut game =
+		GameState::new_native(&SCRIPT, |_| {}, |_| {}, &SCRIPT, |_| {}, |_| {}, |_| {}).unwrap();
+
+	while !game.is_done() {
+		println!("{:?}", game.step());
+		println!("{:?}", game.board);
+	}
+}

rust/runner/src/gamestatehuman.rs

@@ -0,0 +1,288 @@
+use minimax::{
+	agents::{Agent, RhaiAgent},
+	game::Board,
+};
+use rand::{rngs::StdRng, SeedableRng};
+use rhai::ParseError;
+use wasm_bindgen::prelude::*;
+
+use crate::{ansi, terminput::TermInput};
+
+#[wasm_bindgen]
+pub struct GameStateHuman {
+	/// Red player
+	human: TermInput,
+
+	// Blue player
+	agent: RhaiAgent<StdRng>,
+
+	board: Board,
+	is_red_turn: bool,
+	is_first_turn: bool,
+	is_error: bool,
+	red_score: Option<f32>,
+
+	game_state_callback: Box<dyn Fn(&str) + 'static>,
+}
+
+#[wasm_bindgen]
+impl GameStateHuman {
+	#[wasm_bindgen(constructor)]
+	pub fn new(
+		max_script: &str,
+		max_print_callback: js_sys::Function,
+		max_debug_callback: js_sys::Function,
+
+		game_state_callback: js_sys::Function,
+	) -> Result<GameStateHuman, String> {
+		Self::new_native(
+			max_script,
+			move |s| {
+				let _ = max_print_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+			move |s| {
+				let _ = max_debug_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+			move |s| {
+				let _ = game_state_callback.call1(&JsValue::null(), &JsValue::from_str(s));
+			},
+		)
+		.map_err(|x| format!("Error at {}: {}", x.1, x.0))
+	}
+
+	fn new_native(
+		max_script: &str,
+		max_print_callback: impl Fn(&str) + 'static,
+		max_debug_callback: impl Fn(&str) + 'static,
+
+		game_state_callback: impl Fn(&str) + 'static,
+	) -> Result<Self, ParseError> {
+		console_error_panic_hook::set_once();
+
+		let mut seed1 = [0u8; 32];
+		let mut seed2 = [0u8; 32];
+		getrandom::getrandom(&mut seed1).unwrap();
+		getrandom::getrandom(&mut seed2).unwrap();
+
+		Ok(Self {
+			board: Board::new(),
+			is_red_turn: true,
+			is_first_turn: true,
+			is_error: false,
+			red_score: None,
+
+			human: TermInput::new(ansi::RED.to_string()),
+			agent: RhaiAgent::new(
+				max_script,
+				StdRng::from_seed(seed1),
+				max_print_callback,
+				max_debug_callback,
+			)?,
+
+			game_state_callback: Box::new(game_state_callback),
+		})
+	}
+
+	#[wasm_bindgen]
+	pub fn is_done(&self) -> bool {
+		(self.board.is_full() && self.red_score.is_some()) || self.is_error
+	}
+
+	#[wasm_bindgen]
+	pub fn is_error(&self) -> bool {
+		self.is_error
+	}
+
+	#[wasm_bindgen]
+	pub fn print_start(&mut self) -> Result<(), String> {
+		self.print_board("", "");
+		(self.game_state_callback)("\r\n");
+
+		if !self.is_red_turn {
+			let action = {
+				if self.red_score.is_none() {
+					self.agent.step_min(&self.board)
+				} else {
+					self.agent.step_max(&self.board)
+				}
+			}
+			.map_err(|err| format!("{err}"))?;
+
+			if !self.board.play(action, "Blue") {
+				self.is_error = true;
+				return Err(format!(
+					"{} ({}) made an invalid move {}",
+					self.is_red_turn.then_some("Red").unwrap_or("Blue"),
+					self.is_red_turn
+						.then_some("Human")
+						.unwrap_or(self.agent.name()),
+					action
+				));
+			}
+
+			self.print_board(
+				self.is_red_turn.then_some(ansi::RED).unwrap_or(ansi::BLUE),
+				self.is_red_turn.then_some("Red").unwrap_or("Blue"),
+			);
+			(self.game_state_callback)("\r\n");
+			self.is_red_turn = true;
+		}
+
+		self.print_ui();
+
+		return Ok(());
+	}
+
+	#[wasm_bindgen]
+	pub fn print_board(&mut self, color: &str, player: &str) {
+		let board_label = format!("{}{:<6}{}", color, player, ansi::RESET);
+
+		// Print board
+		(self.game_state_callback)(&format!(
+			"\r{}{}{}{}",
+			board_label,
+			if self.is_first_turn { '╓' } else { '║' },
+			self.board.prettyprint(),
+			if self.is_first_turn { '╖' } else { '║' },
+		));
+		self.is_first_turn = false;
+	}
+
+	#[wasm_bindgen]
+	pub fn print_ui(&mut self) {
+		(self.game_state_callback)(
+			&self
+				.human
+				.print_state(&self.board, self.red_score.is_some()),
+		);
+	}
+
+	#[wasm_bindgen]
+	pub fn take_input(&mut self, data: String) -> Result<(), String> {
+		self.human.process_input(&self.board, data);
+		self.print_ui();
+
+		if let Some(action) = self.human.pop_action() {
+			if !self.board.play(action, "Red") {
+				self.is_error = true;
+				return Err(format!(
+					"{} ({}) made an invalid move {}",
+					self.is_red_turn.then_some("Red").unwrap_or("Blue"),
+					self.is_red_turn
+						.then_some("Human")
+						.unwrap_or(self.agent.name()),
+					action
+				));
+			}
+			self.is_red_turn = false;
+
+			if self.board.is_full() {
+				self.print_end()?;
+				return Ok(());
+			}
+			self.print_board(ansi::RED, "Red");
+			(self.game_state_callback)("\r\n");
+
+			let action = {
+				if self.red_score.is_none() {
+					self.agent.step_min(&self.board)
+				} else {
+					self.agent.step_max(&self.board)
+				}
+			}
+			.map_err(|err| format!("{err}"))?;
+
+			if !self.board.play(action, "Blue") {
+				self.is_error = true;
+				return Err(format!(
+					"{} ({}) made an invalid move {}",
+					self.is_red_turn.then_some("Red").unwrap_or("Blue"),
+					self.is_red_turn
+						.then_some("Human")
+						.unwrap_or(self.agent.name()),
+					action
+				));
+			}
+			self.is_red_turn = true;
+
+			if self.board.is_full() {
+				self.print_end()?;
+				return Ok(());
+			}
+			self.print_board(ansi::BLUE, "Blue");
+			(self.game_state_callback)("\r\n");
+
+			self.print_ui();
+		}
+
+		return Ok(());
+	}
+
+	fn print_end(&mut self) -> Result<(), String> {
+		let board_label = format!(
+			"{}{:<6}{}",
+			self.is_red_turn.then_some(ansi::BLUE).unwrap_or(ansi::RED),
+			self.is_red_turn.then_some("Blue").unwrap_or("Red"),
+			ansi::RESET
+		);
+
+		(self.game_state_callback)(&format!("\r{}║{}║", board_label, self.board.prettyprint()));
+		(self.game_state_callback)("\r\n");
+
+		(self.game_state_callback)(&format!(
+			"\r{}╙{}╜",
+			"      ",
+			" ".repeat(self.board.size())
+		));
+		(self.game_state_callback)("\r\n");
+
+		let score = self.board.evaluate().unwrap();
+		(self.game_state_callback)(&format!(
+			"\r\n{}{} score:{} {:.2}\r\n",
+			self.red_score
+				.is_none()
+				.then_some(ansi::RED)
+				.unwrap_or(ansi::BLUE),
+			self.red_score.is_none().then_some("Red").unwrap_or("Blue"),
+			ansi::RESET,
+			score
+		));
+		(self.game_state_callback)("\r\n");
+
+		match self.red_score {
+			// Start second round
+			None => {
+				let mut seed1 = [0u8; 32];
+				let mut seed2 = [0u8; 32];
+				getrandom::getrandom(&mut seed1).unwrap();
+				getrandom::getrandom(&mut seed2).unwrap();
+
+				self.board = Board::new();
+				self.is_red_turn = false;
+				self.is_first_turn = true;
+				self.is_error = false;
+				self.human = TermInput::new(ansi::RED.to_string());
+				self.red_score = Some(score);
+
+				self.print_start()?;
+			}
+
+			// End game
+			Some(red_score) => {
+				if red_score == score {
+					(self.game_state_callback)(&format!("Tie! Score: {:.2}\r\n", score));
+				} else {
+					let red_wins = red_score > score;
+					(self.game_state_callback)(&format!(
+						"{}{} wins!{}",
+						red_wins.then_some(ansi::RED).unwrap_or(ansi::BLUE),
+						red_wins.then_some("Red").unwrap_or("Blue"),
+						ansi::RESET,
+					));
+				}
+			}
+		}
+
+		return Ok(());
+	}
+}

rust/runner/src/lib.rs

@@ -1,15 +1,9 @@
-use minimax::{
-	agents::{Agent, Rhai},
-	board::Board,
-};
-use rand::{rngs::StdRng, SeedableRng};
-use rhai::ParseError;
 use wasm_bindgen::prelude::*;
 
-use crate::human::HumanInput;
-
 mod ansi;
-mod human;
+mod gamestate;
+mod gamestatehuman;
+mod terminput;
 
 #[global_allocator]
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
@@ -18,723 +12,3 @@ static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
 pub fn init_panic_hook() {
 	console_error_panic_hook::set_once();
 }
-
-//
-// MARK: GameState
-//
-
-#[wasm_bindgen]
-pub struct GameState {
-	red_agent: Rhai<StdRng>,
-	red_name: String,
-
-	blue_agent: Rhai<StdRng>,
-	blue_name: String,
-
-	board: Board,
-	is_red_turn: bool,
-	is_first_turn: bool,
-	is_error: bool,
-	red_is_maximizer: bool,
-	red_score: Option<f32>,
-	red_won: Option<bool>,
-
-	game_state_callback: Box<dyn Fn(&str) + 'static>,
-}
-
-#[wasm_bindgen]
-impl GameState {
-	#[wasm_bindgen(constructor)]
-	pub fn new(
-		red_script: &str,
-		red_name: &str,
-		red_print_callback: js_sys::Function,
-		red_debug_callback: js_sys::Function,
-
-		blue_script: &str,
-		blue_name: &str,
-		blue_print_callback: js_sys::Function,
-		blue_debug_callback: js_sys::Function,
-
-		game_state_callback: js_sys::Function,
-	) -> Result<GameState, String> {
-		Self::new_native(
-			red_script,
-			red_name,
-			move |s| {
-				let _ = red_print_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-			move |s| {
-				let _ = red_debug_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-			blue_script,
-			blue_name,
-			move |s| {
-				let _ = blue_print_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-			move |s| {
-				let _ = blue_debug_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-			move |s| {
-				let _ = game_state_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-		)
-		.map_err(|x| format!("Error at {}: {}", x.1, x.0))
-	}
-
-	fn new_native(
-		red_script: &str,
-		red_name: &str,
-		red_print_callback: impl Fn(&str) + 'static,
-		red_debug_callback: impl Fn(&str) + 'static,
-
-		blue_script: &str,
-		blue_name: &str,
-		blue_print_callback: impl Fn(&str) + 'static,
-		blue_debug_callback: impl Fn(&str) + 'static,
-
-		game_state_callback: impl Fn(&str) + 'static,
-	) -> Result<GameState, ParseError> {
-		console_error_panic_hook::set_once();
-
-		let mut seed1 = [0u8; 32];
-		let mut seed2 = [0u8; 32];
-		getrandom::getrandom(&mut seed1).unwrap();
-		getrandom::getrandom(&mut seed2).unwrap();
-
-		Ok(GameState {
-			board: Board::new(),
-			is_first_turn: true,
-			is_error: false,
-			red_score: None,
-			is_red_turn: true,
-			red_is_maximizer: true,
-			red_won: None,
-
-			red_name: red_name.to_owned(),
-			red_agent: Rhai::new(
-				red_script,
-				StdRng::from_seed(seed1),
-				red_print_callback,
-				red_debug_callback,
-			)?,
-
-			blue_name: blue_name.to_owned(),
-			blue_agent: Rhai::new(
-				blue_script,
-				StdRng::from_seed(seed2),
-				blue_print_callback,
-				blue_debug_callback,
-			)?,
-
-			game_state_callback: Box::new(game_state_callback),
-		})
-	}
-
-	// Play one turn
-	#[wasm_bindgen]
-	pub fn step(&mut self) -> Result<(), String> {
-		if self.is_done() {
-			return Ok(());
-		}
-
-		let action = match (self.is_red_turn, self.red_is_maximizer) {
-			(false, false) => self.blue_agent.step_max(&self.board),
-			(false, true) => self.blue_agent.step_min(&self.board),
-			(true, false) => self.red_agent.step_min(&self.board),
-			(true, true) => self.red_agent.step_max(&self.board),
-		};
-
-		let action = match action {
-			Ok(x) => x,
-			Err(err) => {
-				let error_msg = format!(
-					"{}ERROR:{} Error while computing next move: {:?}",
-					ansi::RED,
-					ansi::RESET,
-					err
-				);
-
-				(self.game_state_callback)(&error_msg);
-				self.is_error = true;
-				return Ok(());
-			}
-		};
-
-		if !self.board.play(
-			action,
-			self.is_red_turn
-				.then_some(&self.red_name)
-				.unwrap_or(&self.blue_name)
-				.to_owned(),
-		) {
-			let error_msg = format!(
-				"{} {} ({}) made an invalid move {}!",
-				format!("{}ERROR:{}", ansi::RED, ansi::RESET),
-				self.is_red_turn
-					.then_some(&self.red_name)
-					.unwrap_or(&self.blue_name),
-				self.is_red_turn
-					.then_some(self.red_agent.name())
-					.unwrap_or(self.blue_agent.name()),
-				action
-			);
-
-			(self.game_state_callback)(&error_msg);
-			self.is_error = true;
-			return Ok(());
-		}
-
-		if self.board.is_full() {
-			self.print_end();
-			return Ok(());
-		}
-
-		self.print_board(
-			self.is_red_turn.then_some(ansi::RED).unwrap_or(ansi::BLUE),
-			self.is_red_turn.then_some("Red").unwrap_or("Blue"),
-		);
-		(self.game_state_callback)("\n\r");
-
-		self.is_red_turn = !self.is_red_turn;
-
-		return Ok(());
-	}
-
-	#[wasm_bindgen]
-	pub fn is_done(&self) -> bool {
-		(self.board.is_full() && self.red_score.is_some()) || self.is_error
-	}
-
-	#[wasm_bindgen]
-	pub fn red_won(&self) -> Option<bool> {
-		self.red_won
-	}
-
-	#[wasm_bindgen]
-	pub fn is_error(&self) -> bool {
-		self.is_error
-	}
-
-	#[wasm_bindgen]
-	pub fn print_start(&mut self) {
-		self.print_board("", "");
-		(self.game_state_callback)("\r\n");
-	}
-
-	#[wasm_bindgen]
-	pub fn print_board(&mut self, color: &str, player: &str) {
-		let board_label = format!("{}{:<6}{}", color, player, ansi::RESET);
-
-		// Print board
-		(self.game_state_callback)(&format!(
-			"\r{}{}{}{}",
-			board_label,
-			if self.is_first_turn { '╓' } else { '║' },
-			self.board.prettyprint(),
-			if self.is_first_turn { '╖' } else { '║' },
-		));
-		self.is_first_turn = false;
-	}
-
-	fn print_end(&mut self) {
-		let board_label = format!(
-			"{}{:<6}{}",
-			self.is_red_turn.then_some(ansi::BLUE).unwrap_or(ansi::RED),
-			self.is_red_turn.then_some("Blue").unwrap_or("Red"),
-			ansi::RESET
-		);
-
-		(self.game_state_callback)(&format!("\r{}║{}║", board_label, self.board.prettyprint()));
-		(self.game_state_callback)("\r\n");
-
-		(self.game_state_callback)(&format!(
-			"\r{}╙{}╜",
-			"      ",
-			" ".repeat(self.board.size())
-		));
-		(self.game_state_callback)("\r\n");
-
-		let score = self.board.evaluate();
-
-		let score = match score {
-			Some(x) => x,
-			None => {
-				let error_msg = format!(
-					"{}ERROR:{} Could not compute final score.\n\r",
-					ansi::RED,
-					ansi::RESET,
-				);
-
-				(self.game_state_callback)(&error_msg);
-				(self.game_state_callback)("This was probably a zero division.\n\r");
-				self.is_error = true;
-				return;
-			}
-		};
-
-		(self.game_state_callback)(&format!(
-			"\r\n{}{} score:{} {:.2}\r\n",
-			self.red_is_maximizer
-				.then_some(ansi::RED)
-				.unwrap_or(ansi::BLUE),
-			self.red_is_maximizer.then_some("Red").unwrap_or("Blue"),
-			ansi::RESET,
-			score
-		));
-		(self.game_state_callback)("\r\n");
-
-		match self.red_score {
-			// Start second round
-			None => {
-				let mut seed1 = [0u8; 32];
-				let mut seed2 = [0u8; 32];
-				getrandom::getrandom(&mut seed1).unwrap();
-				getrandom::getrandom(&mut seed2).unwrap();
-
-				self.red_is_maximizer = !self.red_is_maximizer;
-				self.board = Board::new();
-				self.is_red_turn = !self.red_is_maximizer;
-				self.is_first_turn = true;
-				self.is_error = false;
-				self.red_score = Some(score);
-
-				self.print_start();
-			}
-
-			// End game
-			Some(red_score) => {
-				if red_score == score {
-					(self.game_state_callback)(&format!("Tie! Score: {:.2}\r\n", score));
-					return;
-				}
-
-				let red_wins = red_score > score;
-				self.red_won = Some(red_wins);
-				(self.game_state_callback)(&format!(
-					"{}{} wins!{}",
-					red_wins.then_some(ansi::RED).unwrap_or(ansi::BLUE),
-					red_wins.then_some("Red").unwrap_or("Blue"),
-					ansi::RESET,
-				));
-			}
-		}
-	}
-}
-
-//
-// MARK: GameStateHuman
-//
-
-#[wasm_bindgen]
-pub struct GameStateHuman {
-	human: HumanInput,
-
-	/// If true, human goes first and maximizes score.
-	/// If false, human goes second and minimizes score.
-	human_is_maximizer: bool,
-
-	agent: Rhai<StdRng>,
-	agent_name: String,
-
-	board: Board,
-	is_human_turn: bool,
-	is_first_turn: bool,
-	is_error: bool,
-	red_score: Option<f32>,
-
-	game_state_callback: Box<dyn Fn(&str) + 'static>,
-}
-
-#[wasm_bindgen]
-impl GameStateHuman {
-	#[wasm_bindgen(constructor)]
-	pub fn new(
-		human_is_maximizer: bool,
-		max_script: &str,
-		max_name: &str,
-		max_print_callback: js_sys::Function,
-		max_debug_callback: js_sys::Function,
-
-		game_state_callback: js_sys::Function,
-	) -> Result<GameStateHuman, String> {
-		Self::new_native(
-			human_is_maximizer,
-			max_script,
-			max_name,
-			move |s| {
-				let _ = max_print_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-			move |s| {
-				let _ = max_debug_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-			move |s| {
-				let _ = game_state_callback.call1(&JsValue::null(), &JsValue::from_str(s));
-			},
-		)
-		.map_err(|x| format!("Error at {}: {}", x.1, x.0))
-	}
-
-	fn new_native(
-		human_is_maximizer: bool,
-		max_script: &str,
-		max_name: &str,
-		max_print_callback: impl Fn(&str) + 'static,
-		max_debug_callback: impl Fn(&str) + 'static,
-
-		game_state_callback: impl Fn(&str) + 'static,
-	) -> Result<Self, ParseError> {
-		console_error_panic_hook::set_once();
-
-		let mut seed1 = [0u8; 32];
-		let mut seed2 = [0u8; 32];
-		getrandom::getrandom(&mut seed1).unwrap();
-		getrandom::getrandom(&mut seed2).unwrap();
-
-		Ok(Self {
-			human_is_maximizer,
-			board: Board::new(),
-			is_human_turn: human_is_maximizer,
-			is_first_turn: true,
-			is_error: false,
-			red_score: None,
-
-			human: HumanInput::new(ansi::RED.to_string()),
-			agent_name: max_name.to_owned(),
-			agent: Rhai::new(
-				max_script,
-				StdRng::from_seed(seed1),
-				max_print_callback,
-				max_debug_callback,
-			)?,
-
-			game_state_callback: Box::new(game_state_callback),
-		})
-	}
-
-	#[wasm_bindgen]
-	pub fn is_done(&self) -> bool {
-		(self.board.is_full() && self.red_score.is_some()) || self.is_error
-	}
-
-	#[wasm_bindgen]
-	pub fn is_error(&self) -> bool {
-		self.is_error
-	}
-
-	#[wasm_bindgen]
-	pub fn human_is_maximizer(&self) -> bool {
-		self.human_is_maximizer
-	}
-
-	#[wasm_bindgen]
-	pub fn print_start(&mut self) {
-		self.print_board("", "");
-		(self.game_state_callback)("\r\n");
-
-		if !self.is_human_turn {
-			let action = {
-				if self.human_is_maximizer {
-					self.agent.step_min(&self.board)
-				} else {
-					self.agent.step_max(&self.board)
-				}
-			};
-
-			let action = match action {
-				Ok(x) => x,
-				Err(err) => {
-					let error_msg = format!(
-						"{}ERROR:{} Error while computing next move: {:?}",
-						ansi::RED,
-						ansi::RESET,
-						err
-					);
-
-					(self.game_state_callback)(&error_msg);
-					self.is_error = true;
-					return;
-				}
-			};
-
-			if !self.board.play(action, "Blue") {
-				let error_msg = format!(
-					"{}ERROR:{} {} made an invalid move {}!",
-					ansi::RED,
-					ansi::RESET,
-					self.agent_name,
-					action
-				);
-
-				(self.game_state_callback)(&error_msg);
-			}
-
-			self.print_board(
-				self.is_human_turn
-					.then_some(ansi::RED)
-					.unwrap_or(ansi::BLUE),
-				self.is_human_turn.then_some("Red").unwrap_or("Blue"),
-			);
-			(self.game_state_callback)("\r\n");
-			self.is_human_turn = true;
-		}
-
-		self.print_ui();
-	}
-
-	#[wasm_bindgen]
-	pub fn print_board(&mut self, color: &str, player: &str) {
-		let board_label = format!("{}{:<6}{}", color, player, ansi::RESET);
-
-		// Print board
-		(self.game_state_callback)(&format!(
-			"\r{}{}{}{}",
-			board_label,
-			if self.is_first_turn { '╓' } else { '║' },
-			self.board.prettyprint(),
-			if self.is_first_turn { '╖' } else { '║' },
-		));
-		self.is_first_turn = false;
-	}
-
-	#[wasm_bindgen]
-	pub fn print_ui(&mut self) {
-		(self.game_state_callback)(
-			&self
-				.human
-				.print_state(&self.board, !self.human_is_maximizer),
-		);
-	}
-
-	#[wasm_bindgen]
-	pub fn take_input(&mut self, data: String) {
-		self.human.process_input(&self.board, data);
-		self.print_ui();
-
-		if let Some(action) = self.human.pop_action() {
-			if !self.board.play(action, "Red") {
-				let error_msg = format!(
-					"{}ERROR:{} {} made an invalid move {}!",
-					ansi::RED,
-					ansi::RESET,
-					"Human",
-					action
-				);
-
-				(self.game_state_callback)(&error_msg);
-			}
-			self.is_human_turn = false;
-
-			if self.board.is_full() {
-				self.print_end();
-				return;
-			}
-			self.print_board(ansi::RED, "Red");
-			(self.game_state_callback)("\r\n");
-
-			let action = {
-				if self.human_is_maximizer {
-					self.agent.step_min(&self.board)
-				} else {
-					self.agent.step_max(&self.board)
-				}
-			};
-
-			let action = match action {
-				Ok(x) => x,
-				Err(err) => {
-					let error_msg = format!(
-						"{}ERROR:{} Error while computing next move: {:?}",
-						ansi::RED,
-						ansi::RESET,
-						err
-					);
-
-					(self.game_state_callback)(&error_msg);
-					self.is_error = true;
-					return;
-				}
-			};
-
-			if !self.board.play(action, "Blue") {
-				let error_msg = format!(
-					"{}ERROR:{} {} made an invalid move {}!",
-					ansi::RED,
-					ansi::RESET,
-					self.agent_name,
-					action
-				);
-
-				(self.game_state_callback)(&error_msg);
-			}
-			self.is_human_turn = true;
-
-			if self.board.is_full() {
-				self.print_end();
-				return;
-			}
-			self.print_board(ansi::BLUE, "Blue");
-			(self.game_state_callback)("\r\n");
-
-			self.print_ui();
-		}
-	}
-
-	fn print_end(&mut self) {
-		let board_label = format!(
-			"{}{:<6}{}",
-			self.is_human_turn
-				.then_some(ansi::BLUE)
-				.unwrap_or(ansi::RED),
-			self.is_human_turn.then_some("Blue").unwrap_or("Red"),
-			ansi::RESET
-		);
-
-		(self.game_state_callback)(&format!("\r{}║{}║", board_label, self.board.prettyprint()));
-		(self.game_state_callback)("\r\n");
-
-		(self.game_state_callback)(&format!(
-			"\r{}╙{}╜",
-			"      ",
-			" ".repeat(self.board.size())
-		));
-		(self.game_state_callback)("\r\n");
-
-		let score = self.board.evaluate().unwrap();
-		(self.game_state_callback)(&format!(
-			"\r\n{}{} score:{} {:.2}\r\n",
-			self.human_is_maximizer
-				.then_some(ansi::RED)
-				.unwrap_or(ansi::BLUE),
-			self.human_is_maximizer.then_some("Red").unwrap_or("Blue"),
-			ansi::RESET,
-			score
-		));
-		(self.game_state_callback)("\r\n");
-
-		match self.red_score {
-			// Start second round
-			None => {
-				let mut seed1 = [0u8; 32];
-				let mut seed2 = [0u8; 32];
-				getrandom::getrandom(&mut seed1).unwrap();
-				getrandom::getrandom(&mut seed2).unwrap();
-
-				self.human_is_maximizer = !self.human_is_maximizer;
-				self.board = Board::new();
-				self.is_human_turn = !self.human_is_maximizer;
-				self.is_first_turn = true;
-				self.is_error = false;
-				self.human = HumanInput::new(ansi::RED.to_string());
-				self.red_score = Some(score);
-
-				self.print_start();
-			}
-
-			// End game
-			Some(red_score) => {
-				if red_score == score {
-					(self.game_state_callback)(&format!("Tie! Score: {:.2}\r\n", score));
-					return;
-				}
-
-				let red_wins = red_score > score;
-				(self.game_state_callback)(&format!(
-					"{}{} wins!{}",
-					red_wins.then_some(ansi::RED).unwrap_or(ansi::BLUE),
-					red_wins.then_some("Red").unwrap_or("Blue"),
-					ansi::RESET,
-				));
-			}
-		}
-	}
-}
-
-//
-// MARK: tests
-//
-// TODO:
-// - infinite loop
-// - random is different
-// - incorrect return type
-// - globals
-
-#[test]
-fn full_random() {
-	const SCRIPT: &str = r#"
-	fn random_action(board) {
-		let symb = rand_symb();
-		let pos = rand_int(0, 10);
-		let action = Action(symb, pos);
-
-		while !board.can_play(action) {
-			let symb = rand_symb();
-			let pos = rand_int(0, 10);
-			action = Action(symb, pos);
-		}
-
-		return action
-	}
-
-	fn step_min(board) {
-		random_action(board)
-	}
-
-	fn step_max(board) {
-		random_action(board)
-	}
-	"#;
-
-	let mut game = GameState::new_native(
-		&SCRIPT,
-		"max",
-		|_| {},
-		|_| {},
-		&SCRIPT,
-		"min",
-		|_| {},
-		|_| {},
-		|_| {},
-	)
-	.unwrap();
-
-	let mut n = 0;
-	while !game.is_done() {
-		println!("{:?}", game.step());
-		println!("{:?}", game.board);
-
-		n += 1;
-		assert!(n < 10);
-	}
-}
-
-#[test]
-fn infinite_loop() {
-	const SCRIPT: &str = r#"
-	fn step_min(board) {
-		loop {}
-	}
-
-	fn step_max(board) {
-		loop {}
-	}
-	"#;
-
-	let mut game = GameState::new_native(
-		&SCRIPT,
-		"max",
-		|_| {},
-		|_| {},
-		&SCRIPT,
-		"min",
-		|_| {},
-		|_| {},
-		|_| {},
-	)
-	.unwrap();
-
-	while !game.is_done() {
-		println!("{:?}", game.step());
-		println!("{:?}", game.board);
-	}
-}

rust/runner/src/terminput.rs

@@ -1,8 +1,5 @@
 use itertools::Itertools;
-use minimax::{
-	board::{Board, PlayerAction},
-	util::Symb,
-};
+use minimax::game::{Board, PlayerAction, Symb};
 
 use crate::ansi::{DOWN, LEFT, RESET, RIGHT, UP};
 
@@ -63,7 +60,7 @@ impl SymbolSelector {
 	}
 }
 
-pub struct HumanInput {
+pub struct TermInput {
 	player_color: String,
 	cursor: usize,
 	symbol_selector: SymbolSelector,
@@ -73,7 +70,7 @@ pub struct HumanInput {
 	queued_action: Option<PlayerAction>,
 }
 
-impl HumanInput {
+impl TermInput {
 	pub fn new(player_color: String) -> Self {
 		Self {
 			cursor: 0,
@@ -152,7 +149,7 @@ impl HumanInput {
 				self.symbol_selector.down(board);
 			}
 
-			" " | "\n" => {
+			" " | "\n" | "\r" => {
 				let symb = Symb::from_char(self.symbol_selector.current());
 				if let Some(symb) = symb {
 					let action = PlayerAction {