356 lines
7.5 KiB
Rust
356 lines
7.5 KiB
Rust
use std::fmt::Display;
|
|
use termion::color::{self, Color};
|
|
|
|
use super::{PlayerAction, TreeElement};
|
|
use crate::util::{Player, Symb};
|
|
|
|
#[derive(Debug)]
|
|
enum InterTreeElement {
|
|
Unprocessed(Token),
|
|
Processed(TreeElement),
|
|
}
|
|
|
|
impl InterTreeElement {
|
|
fn to_value(&self) -> TreeElement {
|
|
match self {
|
|
InterTreeElement::Processed(x) => x.clone(),
|
|
InterTreeElement::Unprocessed(Token::Value(s)) => {
|
|
if let Some(s) = s.strip_prefix('-') {
|
|
TreeElement::Neg {
|
|
r: {
|
|
if s.contains('_') {
|
|
Box::new(TreeElement::Partial(s.to_string()))
|
|
} else {
|
|
Box::new(TreeElement::Number(s.parse().unwrap()))
|
|
}
|
|
},
|
|
}
|
|
} else if s.contains('_') {
|
|
TreeElement::Partial(s.to_string())
|
|
} else {
|
|
TreeElement::Number(s.parse().unwrap())
|
|
}
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
enum Token {
|
|
Value(String),
|
|
OpAdd,
|
|
OpSub,
|
|
OpMult,
|
|
OpDiv,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Board {
|
|
board: [Option<(Symb, Player)>; 11],
|
|
|
|
/// Number of Nones in `board`
|
|
free_spots: usize,
|
|
|
|
/// Index of the last board index that was changed
|
|
last_placed: Option<usize>,
|
|
}
|
|
|
|
impl Display for Board {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
// Print board
|
|
for (i, o) in self.board.iter().enumerate() {
|
|
match o {
|
|
Some((symb, player)) => write!(
|
|
f,
|
|
"{}{}{}",
|
|
// If index matches last placed, draw symbol in red.
|
|
// If last_placed is None, this check will always fail
|
|
// since self.board.len is always greater than i.
|
|
if self.last_placed.unwrap_or(self.board.len()) == i {
|
|
color::Fg(&color::Red as &dyn Color)
|
|
} else {
|
|
color::Fg(player.color())
|
|
},
|
|
symb,
|
|
color::Fg(color::Reset)
|
|
)?,
|
|
|
|
None => write!(f, "_")?,
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
impl Board {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
free_spots: 11,
|
|
board: Default::default(),
|
|
last_placed: None,
|
|
}
|
|
}
|
|
|
|
pub fn iter(&self) -> impl Iterator<Item = &Option<(Symb, Player)>> {
|
|
self.board.iter()
|
|
}
|
|
|
|
pub fn get(&self, idx: usize) -> Option<&Option<(Symb, Player)>> {
|
|
self.board.get(idx)
|
|
}
|
|
|
|
pub fn is_done(&self) -> bool {
|
|
self.free_spots == 0
|
|
}
|
|
|
|
pub fn size(&self) -> usize {
|
|
self.board.len()
|
|
}
|
|
|
|
pub fn contains(&self, s: Symb) -> bool {
|
|
for i in self.board.iter().flatten() {
|
|
if i.0 == s {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
/// Is the given action valid?
|
|
pub fn can_play(&self, action: &PlayerAction) -> bool {
|
|
match &self.board[action.pos] {
|
|
Some(_) => return false,
|
|
None => {
|
|
// Check for duplicate symbols
|
|
if self.contains(action.symb) {
|
|
return false;
|
|
}
|
|
|
|
// Check syntax
|
|
match action.symb {
|
|
Symb::Minus => {
|
|
if action.pos == self.board.len() - 1 {
|
|
return false;
|
|
}
|
|
|
|
let r = &self.board[action.pos + 1];
|
|
if r.is_some_and(|(s, _)| s.is_op() && !s.is_minus()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Symb::Zero => {
|
|
if action.pos != 0 {
|
|
let l = &self.board[action.pos - 1].map(|x| x.0);
|
|
if l == &Some(Symb::Div) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
Symb::Div | Symb::Plus | Symb::Times => {
|
|
if action.pos == 0 || action.pos == self.board.len() - 1 {
|
|
return false;
|
|
}
|
|
|
|
let l = &self.board[action.pos - 1].map(|x| x.0);
|
|
let r = &self.board[action.pos + 1].map(|x| x.0);
|
|
|
|
if action.symb == Symb::Div && r == &Some(Symb::Zero) {
|
|
return false;
|
|
}
|
|
|
|
if l.is_some_and(|s| s.is_op())
|
|
|| r.is_some_and(|s| s.is_op() && !s.is_minus())
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
/// Place the marked symbol at the given position.
|
|
/// Returns true for valid moves and false otherwise.
|
|
pub fn play(&mut self, action: PlayerAction, player: Player) -> bool {
|
|
if !self.can_play(&action) {
|
|
return false;
|
|
}
|
|
|
|
self.board[action.pos] = Some((action.symb, player));
|
|
self.free_spots -= 1;
|
|
self.last_placed = Some(action.pos);
|
|
true
|
|
}
|
|
|
|
fn tokenize(&self) -> Vec<Token> {
|
|
let mut tokens = Vec::new();
|
|
let mut is_neg = true; // if true, - is negative. if false, subtract.
|
|
let mut current_num = String::new();
|
|
|
|
for s in self.board.iter().map(|x| x.map(|(s, _)| s)) {
|
|
match s {
|
|
Some(Symb::Div) => {
|
|
tokens.push(Token::Value(current_num.clone()));
|
|
current_num.clear();
|
|
tokens.push(Token::OpDiv);
|
|
is_neg = true;
|
|
}
|
|
Some(Symb::Minus) => {
|
|
if is_neg {
|
|
current_num = format!("-{}", current_num);
|
|
} else {
|
|
tokens.push(Token::Value(current_num.clone()));
|
|
current_num.clear();
|
|
tokens.push(Token::OpSub);
|
|
is_neg = true;
|
|
}
|
|
}
|
|
Some(Symb::Plus) => {
|
|
tokens.push(Token::Value(current_num.clone()));
|
|
current_num.clear();
|
|
tokens.push(Token::OpAdd);
|
|
is_neg = true;
|
|
}
|
|
Some(Symb::Times) => {
|
|
tokens.push(Token::Value(current_num.clone()));
|
|
current_num.clear();
|
|
tokens.push(Token::OpMult);
|
|
is_neg = true;
|
|
}
|
|
Some(Symb::Zero) => {
|
|
current_num.push('0');
|
|
is_neg = false;
|
|
}
|
|
Some(Symb::Number(x)) => {
|
|
current_num.push_str(&x.to_string());
|
|
is_neg = false;
|
|
}
|
|
None => {
|
|
current_num.push('_');
|
|
is_neg = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
tokens.push(Token::Value(current_num));
|
|
tokens
|
|
}
|
|
|
|
pub fn to_tree(&self) -> TreeElement {
|
|
let tokens = self.tokenize();
|
|
|
|
let mut tree: Vec<_> = tokens
|
|
.iter()
|
|
.map(|x| InterTreeElement::Unprocessed(x.clone()))
|
|
.collect();
|
|
|
|
let mut priority_level = 0;
|
|
let mut did_something;
|
|
while tree.len() > 1 {
|
|
did_something = false;
|
|
for i in 0..tree.len() {
|
|
if match priority_level {
|
|
0 => matches!(
|
|
tree[i],
|
|
InterTreeElement::Unprocessed(Token::OpMult)
|
|
| InterTreeElement::Unprocessed(Token::OpDiv)
|
|
),
|
|
1 => matches!(
|
|
tree[i],
|
|
InterTreeElement::Unprocessed(Token::OpAdd)
|
|
| InterTreeElement::Unprocessed(Token::OpSub)
|
|
),
|
|
_ => false,
|
|
} {
|
|
did_something = true;
|
|
let l = tree[i - 1].to_value();
|
|
let r = tree[i + 1].to_value();
|
|
|
|
let v = match tree[i] {
|
|
InterTreeElement::Unprocessed(Token::OpAdd) => TreeElement::Add {
|
|
l: Box::new(l),
|
|
r: Box::new(r),
|
|
},
|
|
InterTreeElement::Unprocessed(Token::OpDiv) => TreeElement::Div {
|
|
l: Box::new(l),
|
|
r: Box::new(r),
|
|
},
|
|
InterTreeElement::Unprocessed(Token::OpMult) => TreeElement::Mul {
|
|
l: Box::new(l),
|
|
r: Box::new(r),
|
|
},
|
|
InterTreeElement::Unprocessed(Token::OpSub) => TreeElement::Sub {
|
|
l: Box::new(l),
|
|
r: Box::new(r),
|
|
},
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
tree.remove(i - 1);
|
|
tree.remove(i - 1);
|
|
tree[i - 1] = InterTreeElement::Processed(v);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if !did_something {
|
|
priority_level += 1;
|
|
}
|
|
}
|
|
|
|
match tree.into_iter().next().unwrap() {
|
|
InterTreeElement::Processed(x) => x,
|
|
x => x.to_value(),
|
|
}
|
|
}
|
|
|
|
pub fn evaluate(&self) -> Option<f32> {
|
|
self.to_tree().evaluate()
|
|
}
|
|
|
|
/// Hacky method to parse a board from a string
|
|
pub fn from_string(s: &str, current_player: Player) -> Option<Self> {
|
|
if s.len() != 11 {
|
|
return None;
|
|
}
|
|
|
|
let x = s
|
|
.chars()
|
|
.filter_map(|c| {
|
|
if c == '_' {
|
|
Some(None)
|
|
} else {
|
|
Symb::from_char(c).map(|s| Some((s, current_player)))
|
|
}
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
if x.len() != 11 {
|
|
return None;
|
|
}
|
|
|
|
let mut free_spots = 11;
|
|
let mut board = [None; 11];
|
|
for i in 0..x.len() {
|
|
board[i] = x[i];
|
|
if x[i].is_some() {
|
|
free_spots -= 1;
|
|
}
|
|
}
|
|
|
|
Some(Self {
|
|
board,
|
|
free_spots,
|
|
last_placed: None,
|
|
})
|
|
}
|
|
}
|