//! # Play a TricTrac Game use crate::board::{Board, CheckerMove, Field, EMPTY_MOVE}; use crate::dice::Dice; use crate::game::GameState; use crate::player::Color; use std::cmp; #[derive(std::cmp::PartialEq, Debug)] pub enum MoveError { // 2 checkers must go at the same time on an empty corner // & the last 2 checkers of a corner must leave at the same time CornerNeedsTwoCheckers, // Prise de coin de repos par puissance alors qu'il est possible // de le prendre directement (par "effet") CornerByEffectPossible, // toutes les dames doivent être dans le jan de retour ExitNeedsAllCheckersOnLastQuarter, // mouvement avec nombre en exédant alors qu'une séquence de mouvements // sans nombre en excédant est possible ExitByEffectPossible, // Sortie avec nombre en excédant d'une dame qui n'est pas la plus éloignée ExitNotFasthest, // Jeu dans un cadran que l'adversaire peut encore remplir OpponentCanFillQuarter, // remplir cadran si possible & conserver cadran rempli si possible ---- MustFillQuarter, } pub trait MoveRules { fn board(&self) -> &Board; fn dice(&self) -> &Dice; fn moves_possible(&self, color: &Color, moves: &(CheckerMove, CheckerMove)) -> bool { // Check move is physically possible if !self.board().move_possible(color, &moves.0) { return false; } // Chained_move : "Tout d'une" if let Ok(chained_move) = moves.0.chain(moves.1) { if !self.board().move_possible(color, &chained_move) { return false; } } else if !self.board().move_possible(color, &moves.1) { return false; } true } fn get_move_compatible_dices(&self, color: &Color, cmove: &CheckerMove) -> Vec { let (dice1, dice2) = self.dice().values; let mut move_dices = Vec::new(); if cmove.get_to() == 0 { // handle empty move (0, 0) only one checker left, exiting with the first die. if cmove.get_from() == 0 { move_dices.push(dice1); move_dices.push(dice2); return move_dices; } // Exits let min_dist = match color { Color::White => 25 - cmove.get_from(), Color::Black => cmove.get_from(), }; if dice1 as usize >= min_dist { move_dices.push(dice1); } if dice2 as usize >= min_dist { move_dices.push(dice2); } } else { let dist = (cmove.get_to() as i8 - cmove.get_from() as i8).unsigned_abs(); if dice1 == dist { move_dices.push(dice1); } if dice2 == dist { move_dices.push(dice2); } } move_dices } fn moves_follows_dices(&self, color: &Color, moves: &(CheckerMove, CheckerMove)) -> bool { // Prise de coin par puissance if self.is_move_by_puissance(color, moves) { return true; } let (dice1, dice2) = self.dice().values; let (move1, move2): &(CheckerMove, CheckerMove) = moves; let move1_dices = self.get_move_compatible_dices(color, move1); if move1_dices.is_empty() { return false; } let move2_dices = self.get_move_compatible_dices(color, move2); if move2_dices.is_empty() { return false; } if move1_dices.len() == 1 && move2_dices.len() == 1 && move1_dices[0] == move2_dices[0] && dice1 != dice2 { return false; } // no rule was broken true } fn moves_allowed( &self, color: &Color, moves: &(CheckerMove, CheckerMove), ) -> Result<(), MoveError> { // ------- corner rules ---------- let corner_field: Field = self.board().get_color_corner(color); let (corner_count, _color) = self.board().get_field_checkers(corner_field).unwrap(); let (from0, to0, from1, to1) = ( moves.0.get_from(), moves.0.get_to(), moves.1.get_from(), moves.1.get_to(), ); // 2 checkers must go at the same time on an empty corner if (to0 == corner_field || to1 == corner_field) && (to0 != to1) && corner_count == 0 { return Err(MoveError::CornerNeedsTwoCheckers); } // the last 2 checkers of a corner must leave at the same time if (from0 == corner_field || from1 == corner_field) && (from0 != from1) && corner_count == 2 { return Err(MoveError::CornerNeedsTwoCheckers); } if self.is_move_by_puissance(color, moves) && self.can_take_corner_by_effect(color) { return Err(MoveError::CornerByEffectPossible); } // check exit rules if moves.0.get_to() == 0 || moves.1.get_to() == 0 { // toutes les dames doivent être dans le jan de retour let has_outsiders = !self .board() .get_color_fields(*color) .iter() .filter(|(field, _count)| { (*color == Color::White && *field < 19) || (*color == Color::Black && *field > 6) }) .collect::>() .is_empty(); if has_outsiders { return Err(MoveError::ExitNeedsAllCheckersOnLastQuarter); } // toutes les sorties directes sont autorisées, ainsi que les nombre défaillants let possible_moves_sequences = self.get_possible_moves_sequences(color); if !possible_moves_sequences.contains(moves) { // À ce stade au moins un des déplacements concerne un nombre en excédant // - si d'autres séquences de mouvements sans nombre en excédant étaient possibles, on // refuse cette séquence if !possible_moves_sequences.is_empty() { return Err(MoveError::ExitByEffectPossible); } // - la dame choisie doit être la plus éloignée de la sortie let mut checkers = self.board().get_color_fields(*color); checkers.sort_by(|a, b| { if *color == Color::White { b.0.cmp(&a.0) } else { a.0.cmp(&b.0) } }); let mut farthest = if *color == Color::White { 24 } else { 1 }; let mut next_farthest = if *color == Color::White { 24 } else { 1 }; let mut has_two_checkers = false; if let Some((field, count)) = checkers.first() { farthest = *field; if *count > 1 { next_farthest = *field; has_two_checkers = true; } else if let Some((field, _count)) = checkers.get(1) { next_farthest = *field; has_two_checkers = true; } } // s'il reste au moins deux dames, on vérifie que les plus éloignées soint choisies if has_two_checkers { if moves.0.get_to() == 0 && moves.1.get_to() == 0 { // Deux coups sortants en excédant if *color == Color::White { if cmp::max(moves.0.get_from(), moves.1.get_from()) > next_farthest { return Err(MoveError::ExitNotFasthest); } } else if cmp::min(moves.0.get_from(), moves.1.get_from()) < next_farthest { return Err(MoveError::ExitNotFasthest); } } else { // Un seul coup sortant en excédant le coup sortant doit concerner la plus éloignée du bord let exit_move_field = if moves.0.get_to() == 0 { moves.0.get_from() } else { moves.1.get_from() }; if exit_move_field != farthest { return Err(MoveError::ExitNotFasthest); } } } } } // --- interdit de jouer dans cadran que l'adversaire peut encore remplir ---- let farthest = if *color == Color::White { cmp::max(moves.0.get_to(), moves.1.get_to()) } else { cmp::min(moves.0.get_to(), moves.1.get_to()) }; let in_opponent_side = if *color == Color::White { farthest > 12 } else { farthest < 13 }; if in_opponent_side && self .board() .is_quarter_fillable(color.opponent_color(), farthest) { return Err(MoveError::OpponentCanFillQuarter); } // --- remplir cadran si possible & conserver cadran rempli si possible ---- let filling_moves_sequences = self.get_quarter_filling_moves_sequences(color); if !filling_moves_sequences.contains(moves) && !filling_moves_sequences.is_empty() { return Err(MoveError::MustFillQuarter); } // no rule was broken Ok(()) } fn get_possible_moves_sequences(&self, color: &Color) -> Vec<(CheckerMove, CheckerMove)> { let (dice1, dice2) = self.dice().values; let mut moves_seqs = self.get_possible_moves_sequences_by_dices(color, dice1, dice2); let mut moves_seqs_order2 = self.get_possible_moves_sequences_by_dices(color, dice1, dice2); moves_seqs.append(&mut moves_seqs_order2); moves_seqs } fn get_quarter_filling_moves_sequences( &self, color: &Color, ) -> Vec<(CheckerMove, CheckerMove)> { let mut moves_seqs = Vec::new(); for moves in self.get_possible_moves_sequences(color) { let mut board = self.board().clone(); board.move_checker(color, moves.0).unwrap(); board.move_checker(color, moves.1).unwrap(); if board.any_quarter_filled(*color) { moves_seqs.push(moves); } } moves_seqs } fn get_possible_moves_sequences_by_dices( &self, color: &Color, dice1: u8, dice2: u8, ) -> Vec<(CheckerMove, CheckerMove)> { let mut moves_seqs = Vec::new(); for first_move in self.board().get_possible_moves(*color, dice1, false) { let mut board2 = self.board().clone(); if board2.move_checker(color, first_move).is_err() { println!("err move"); continue; } if board2.get_color_fields(*color).is_empty() { // no checkers left : empty move println!("empty move"); moves_seqs.push((first_move, EMPTY_MOVE)); } else { for second_move in board2.get_possible_moves(*color, dice2, false) { moves_seqs.push((first_move, second_move)); } } } moves_seqs } fn get_direct_exit_moves(&self, state: &GameState, color: &Color) -> Vec { let mut moves = Vec::new(); let (dice1, dice2) = state.dice.values; // sorties directes simples let (field1_candidate, field2_candidate) = if color == &Color::White { (25 - dice1 as usize, 25 - dice2 as usize) } else { (dice1 as usize, dice2 as usize) }; let (count1, col1) = state.board.get_field_checkers(field1_candidate).unwrap(); let (count2, col2) = state.board.get_field_checkers(field2_candidate).unwrap(); if count1 > 0 { moves.push(CheckerMove::new(field1_candidate, 0).unwrap()); } if dice2 != dice1 { if count2 > 0 { moves.push(CheckerMove::new(field2_candidate, 0).unwrap()); } } else if count1 > 1 { // doublet et deux dames disponibles moves.push(CheckerMove::new(field1_candidate, 0).unwrap()); } // sortie directe tout d'une let fieldall_candidate = if color == &Color::White { 25 - dice1 - dice2 } else { dice1 + dice2 } as usize; let (countall, _col) = state.board.get_field_checkers(fieldall_candidate).unwrap(); if countall > 0 { if col1.is_none() || col1 == Some(color) { moves.push(CheckerMove::new(fieldall_candidate, field1_candidate).unwrap()); moves.push(CheckerMove::new(field1_candidate, 0).unwrap()); } if col2.is_none() || col2 == Some(color) { moves.push(CheckerMove::new(fieldall_candidate, field2_candidate).unwrap()); moves.push(CheckerMove::new(field2_candidate, 0).unwrap()); } } moves } fn is_move_by_puissance(&self, color: &Color, moves: &(CheckerMove, CheckerMove)) -> bool { let (dice1, dice2) = self.dice().values; let (move1, move2): &(CheckerMove, CheckerMove) = moves; let dist1 = (move1.get_to() as i8 - move1.get_from() as i8).unsigned_abs(); let dist2 = (move2.get_to() as i8 - move2.get_from() as i8).unsigned_abs(); // Both corners must be empty let (count1, _color) = self.board().get_field_checkers(12).unwrap(); let (count2, _color2) = self.board().get_field_checkers(13).unwrap(); if count1 > 0 || count2 > 0 { return false; } move1.get_to() == move2.get_to() && move1.get_to() == self.board().get_color_corner(color) && ((*color == Color::White && cmp::min(dist1, dist2) == cmp::min(dice1, dice2) - 1 && cmp::max(dist1, dist2) == cmp::max(dice1, dice2) - 1) || (*color == Color::Black && cmp::min(dist1, dist2) == cmp::min(dice1, dice2) + 1 && cmp::max(dist1, dist2) == cmp::max(dice1, dice2) + 1)) } fn can_take_corner_by_effect(&self, color: &Color) -> bool { // return false if corner already taken let corner_field: Field = self.board().get_color_corner(color); let (count, _col) = self.board().get_field_checkers(corner_field).unwrap(); if count > 0 { return false; } let (dice1, dice2) = self.dice().values; let (field1, field2) = match color { Color::White => (12 - dice1, 12 - dice2), Color::Black => (13 + dice1, 13 + dice2), }; let res1 = self.board().get_field_checkers(field1.into()); let res2 = self.board().get_field_checkers(field2.into()); if res1.is_err() || res2.is_err() { return false; } let (count1, opt_color1) = res1.unwrap(); let (count2, opt_color2) = res2.unwrap(); count1 > 0 && count2 > 0 && opt_color1 == Some(color) && opt_color2 == Some(color) } } #[cfg(test)] mod tests { use super::*; #[test] fn can_take_corner_by_effect() { let mut state = GameState::default(); state.board.set_positions([ 10, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, ]); state.dice.values = (4, 4); assert!(state.can_take_corner_by_effect(&Color::White)); state.dice.values = (5, 5); assert!(!state.can_take_corner_by_effect(&Color::White)); state.board.set_positions([ 10, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, ]); state.dice.values = (4, 4); assert!(!state.can_take_corner_by_effect(&Color::White)); state.board.set_positions([ 10, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13, ]); state.dice.values = (1, 1); assert!(state.can_take_corner_by_effect(&Color::Black)); } #[test] fn prise_en_puissance() { let mut state = GameState::default(); // prise par puissance ok state.board.set_positions([ 10, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(8, 12).unwrap(), CheckerMove::new(8, 12).unwrap(), ); assert!(state.is_move_by_puissance(&Color::White, &moves)); assert!(state.moves_follows_dices(&Color::White, &moves)); assert!(state.moves_allowed(&Color::White, &moves).is_ok()); // opponent corner must be empty state.board.set_positions([ 10, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -13, ]); assert!(!state.is_move_by_puissance(&Color::White, &moves)); assert!(!state.moves_follows_dices(&Color::White, &moves)); // Si on a la possibilité de prendre son coin à la fois par effet, c'est à dire naturellement, et aussi par puissance, on doit le prendre par effet state.board.set_positions([ 5, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, ]); assert_eq!( Err(MoveError::CornerByEffectPossible), state.moves_allowed(&Color::White, &moves) ); // on a déjà pris son coin : on ne peux plus y deplacer des dames par puissance state.board.set_positions([ 8, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, ]); assert!(!state.is_move_by_puissance(&Color::White, &moves)); assert!(!state.moves_follows_dices(&Color::White, &moves)); } #[test] fn exit() { let mut state = GameState::default(); // exit ok state.board.set_positions([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(20, 0).unwrap(), CheckerMove::new(20, 0).unwrap(), ); assert!(state.moves_follows_dices(&Color::White, &moves)); assert!(state.moves_allowed(&Color::White, &moves).is_ok()); // toutes les dames doivent être dans le jan de retour state.board.set_positions([ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(20, 0).unwrap(), CheckerMove::new(20, 0).unwrap(), ); assert_eq!( Err(MoveError::ExitNeedsAllCheckersOnLastQuarter), state.moves_allowed(&Color::White, &moves) ); // on ne peut pas sortir une dame avec un nombre excédant si on peut en jouer une avec un nombre défaillant state.board.set_positions([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 2, 0, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(20, 0).unwrap(), CheckerMove::new(23, 0).unwrap(), ); assert_eq!( Err(MoveError::ExitByEffectPossible), state.moves_allowed(&Color::White, &moves) ); // on doit jouer le nombre excédant le plus éloigné state.board.set_positions([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(20, 0).unwrap(), CheckerMove::new(23, 0).unwrap(), ); assert_eq!( Err(MoveError::ExitNotFasthest), state.moves_allowed(&Color::White, &moves) ); let moves = ( CheckerMove::new(20, 0).unwrap(), CheckerMove::new(20, 0).unwrap(), ); assert!(state.moves_allowed(&Color::White, &moves).is_ok()); // Cas de la dernière dame state.board.set_positions([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(23, 0).unwrap(), CheckerMove::new(0, 0).unwrap(), ); assert!(state.moves_follows_dices(&Color::White, &moves)); assert!(state.moves_allowed(&Color::White, &moves).is_ok()); } #[test] fn move_check_opponent_fillable_quarter() { let mut state = GameState::default(); state.board.set_positions([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(11, 16).unwrap(), CheckerMove::new(11, 16).unwrap(), ); assert!(state.moves_allowed(&Color::White, &moves).is_ok()); state.board.set_positions([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, -12, 0, 0, 0, 0, 1, 0, ]); state.dice.values = (5, 5); let moves = ( CheckerMove::new(11, 16).unwrap(), CheckerMove::new(11, 16).unwrap(), ); assert_eq!( Err(MoveError::OpponentCanFillQuarter), state.moves_allowed(&Color::White, &moves) ); } #[test] fn move_check_fillable_quarter() { let mut state = GameState::default(); state.board.set_positions([ 3, 3, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, ]); state.dice.values = (5, 4); let moves = ( CheckerMove::new(1, 6).unwrap(), CheckerMove::new(2, 6).unwrap(), ); assert!(state.moves_allowed(&Color::White, &moves).is_ok()); let moves = ( CheckerMove::new(1, 5).unwrap(), CheckerMove::new(2, 7).unwrap(), ); assert_eq!( Err(MoveError::MustFillQuarter), state.moves_allowed(&Color::White, &moves) ); state.board.set_positions([ 2, 3, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ]); state.dice.values = (2, 3); let moves = ( CheckerMove::new(6, 8).unwrap(), CheckerMove::new(6, 9).unwrap(), ); assert_eq!( Err(MoveError::MustFillQuarter), state.moves_allowed(&Color::White, &moves) ); let moves = ( CheckerMove::new(2, 4).unwrap(), CheckerMove::new(5, 8).unwrap(), ); assert!(state.moves_allowed(&Color::White, &moves).is_ok()); } #[test] fn moves_possible() { let state = GameState::default(); // Chained moves let moves = ( CheckerMove::new(1, 5).unwrap(), CheckerMove::new(5, 9).unwrap(), ); assert!(state.moves_possible(&Color::White, &moves)); // not chained moves let moves = ( CheckerMove::new(1, 5).unwrap(), CheckerMove::new(6, 9).unwrap(), ); assert!(!state.moves_possible(&Color::White, &moves)); // black moves let moves = ( CheckerMove::new(24, 20).unwrap(), CheckerMove::new(20, 19).unwrap(), ); assert!(state.moves_possible(&Color::Black, &moves)); } }