henri/trictrac
1
1
Fork 0
Code Issues 14 Pull requests Actions Packages Projects 1 Releases Wiki Activity

refact: fix clippy warnings

Browse source
This commit is contained in:
Henri Bourcereau 2024-11-07 12:52:57 +01:00
parent 25acc86059
commit 37cc50ed2a
8 changed files with 140 additions and 137 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
bot/src/lib.rs
View file

@ -100,10 +100,6 @@ impl Default for Bot {
impl Bot { impl Bot {
/// new initialize a bot /// new initialize a bot
/// # Examples
/// ```let mut bot = Bot::new(Color::Black);
/// assert_eq!(bot.game.stage, Stage::PreGame);
/// ```
// pub fn new(mut strategy: Box<dyn BotStrategy>, color: Color, schools_enabled: bool) -> Self { // pub fn new(mut strategy: Box<dyn BotStrategy>, color: Color, schools_enabled: bool) -> Self {
pub fn new(mut strategy: Box<dyn BotStrategy>, color: Color) -> Self { pub fn new(mut strategy: Box<dyn BotStrategy>, color: Color) -> Self {
// let game = strategy.get_mut_game(); // let game = strategy.get_mut_game();

5
client_cli/src/app.rs
View file

@ -286,7 +286,10 @@ Player :: holes :: points
---------------------------------------------------------------- ----------------------------------------------------------------
12 11 10 9 8 7 6 5 4 3 2 1 12 11 10 9 8 7 6 5 4 3 2 1
"; ";
let mut app = App::new(AppArgs { seed: Some(1327) }); let mut app = App::new(AppArgs {
seed: Some(1327),
bot: None,
});
app.input("roll"); app.input("roll");
app.input("1 3"); app.input("1 3");
app.input("1 4"); app.input("1 4");

6
server/src/main.rs
View file

@ -1,4 +1,3 @@
use bincode;
use log::{info, trace, warn}; use log::{info, trace, warn};
use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
use std::thread; use std::thread;
@ -92,7 +91,10 @@ fn main() {
trace!("The game gas begun"); trace!("The game gas begun");
} }
} }
ServerEvent::ClientDisconnected { client_id, reason: _ } => { ServerEvent::ClientDisconnected {
client_id,
reason: _,
} => {
// First consume a disconnect event // First consume a disconnect event
let event = store::GameEvent::PlayerDisconnected { let event = store::GameEvent::PlayerDisconnected {
player_id: client_id, player_id: client_id,

7
store/src/board.rs
View file

@ -6,6 +6,7 @@ use std::fmt;
/// field (aka 'point') position on the board (from 0 to 24, 0 being 'outside') /// field (aka 'point') position on the board (from 0 to 24, 0 being 'outside')
pub type Field = usize; pub type Field = usize;
pub type FieldWithCount = (Field, i8);
#[derive(Debug, Copy, Clone, Serialize, PartialEq, Deserialize)] #[derive(Debug, Copy, Clone, Serialize, PartialEq, Deserialize)]
pub struct CheckerMove { pub struct CheckerMove {
@ -143,9 +144,9 @@ impl Board {
.iter() .iter()
.filter(|count| { .filter(|count| {
if color == Color::White { if color == Color::White {
**count > 0 as i8 **count > 0
} else { } else {
**count < 0 as i8 **count < 0
} }
}) })
.sum::<i8>() .sum::<i8>()
@ -352,7 +353,7 @@ impl Board {
} }
pub fn is_field_in_small_jan(field: Field) -> bool { pub fn is_field_in_small_jan(field: Field) -> bool {
field < 7 || field > 18 !(7..=18).contains(&field)
} }
/// returns the list of Fields containing Checkers of the Color /// returns the list of Fields containing Checkers of the Color

16
store/src/game.rs
View file

@ -106,7 +106,7 @@ impl GameState {
fn get_opponent_id(&self) -> Option<PlayerId> { fn get_opponent_id(&self) -> Option<PlayerId> {
self.players self.players
.keys() .keys()
.map(|k| *k) .copied()
.filter(|k| k != &self.active_player_id) .filter(|k| k != &self.active_player_id)
.collect::<Vec<PlayerId>>() .collect::<Vec<PlayerId>>()
.first() .first()
@ -262,7 +262,10 @@ impl GameState {
return false; return false;
} }
} }
Mark { player_id, points } => { Mark {
player_id,
points: _,
} => {
// Check player exists // Check player exists
if !self.players.contains_key(player_id) { if !self.players.contains_key(player_id) {
return false; return false;
@ -353,6 +356,7 @@ impl GameState {
Some(player_id as PlayerId) Some(player_id as PlayerId)
} }
#[cfg(test)]
fn add_player(&mut self, player_id: PlayerId, player: Player) { fn add_player(&mut self, player_id: PlayerId, player: Player) {
self.players.insert(player_id, player); self.players.insert(player_id, player);
} }
@ -418,7 +422,7 @@ impl GameState {
self.turn_stage = TurnStage::RollWaiting; self.turn_stage = TurnStage::RollWaiting;
} }
} }
RollResult { player_id, dice } => { RollResult { player_id: _, dice } => {
self.dice = *dice; self.dice = *dice;
self.inc_roll_count(self.active_player_id); self.inc_roll_count(self.active_player_id);
self.turn_stage = TurnStage::MarkPoints; self.turn_stage = TurnStage::MarkPoints;
@ -458,7 +462,7 @@ impl GameState {
}; };
} }
} }
Go { player_id } => self.new_pick_up(), Go { player_id: _ } => self.new_pick_up(),
Move { player_id, moves } => { Move { player_id, moves } => {
let player = self.players.get(player_id).unwrap(); let player = self.players.get(player_id).unwrap();
self.board.move_checker(&player.color, moves.0).unwrap(); self.board.move_checker(&player.color, moves.0).unwrap();
@ -505,8 +509,8 @@ impl GameState {
// A player has won if he has got 12 holes // A player has won if he has got 12 holes
self.players self.players
.iter() .iter()
.filter(|(id, p)| p.holes > 11) .filter(|(_, p)| p.holes > 11)
.map(|(id, p)| *id) .map(|(id, _)| *id)
.next() .next()
} }

10
store/src/game_rules_moves.rs
View file

@ -153,7 +153,7 @@ impl MoveRules {
/// ---- moves_allowed : Third of three checks for moves /// ---- moves_allowed : Third of three checks for moves
pub fn moves_allowed(&self, moves: &(CheckerMove, CheckerMove)) -> Result<(), MoveError> { pub fn moves_allowed(&self, moves: &(CheckerMove, CheckerMove)) -> Result<(), MoveError> {
self.check_corner_rules(&moves)?; self.check_corner_rules(moves)?;
if self.is_move_by_puissance(moves) { if self.is_move_by_puissance(moves) {
if self.can_take_corner_by_effect() { if self.can_take_corner_by_effect() {
@ -169,7 +169,7 @@ impl MoveRules {
let mut possible_moves_sequences = self.get_possible_moves_sequences(true); let mut possible_moves_sequences = self.get_possible_moves_sequences(true);
possible_moves_sequences.retain(|moves| self.check_exit_rules(moves).is_ok()); possible_moves_sequences.retain(|moves| self.check_exit_rules(moves).is_ok());
// possible_moves_sequences.retain(|moves| self.check_corner_rules(moves).is_ok()); // possible_moves_sequences.retain(|moves| self.check_corner_rules(moves).is_ok());
if !possible_moves_sequences.contains(&moves) && !possible_moves_sequences.is_empty() { if !possible_moves_sequences.contains(moves) && !possible_moves_sequences.is_empty() {
if *moves == (EMPTY_MOVE, EMPTY_MOVE) { if *moves == (EMPTY_MOVE, EMPTY_MOVE) {
return Err(MoveError::MustPlayAllDice); return Err(MoveError::MustPlayAllDice);
} }
@ -336,7 +336,7 @@ impl MoveRules {
pub fn get_scoring_quarter_filling_moves_sequences(&self) -> Vec<(CheckerMove, CheckerMove)> { pub fn get_scoring_quarter_filling_moves_sequences(&self) -> Vec<(CheckerMove, CheckerMove)> {
let all_seqs = self.get_quarter_filling_moves_sequences(); let all_seqs = self.get_quarter_filling_moves_sequences();
if all_seqs.len() == 0 { if all_seqs.is_empty() {
return vec![]; return vec![];
} }
let missing_fields = self.board.get_quarter_filling_candidate(Color::White); let missing_fields = self.board.get_quarter_filling_candidate(Color::White);
@ -441,7 +441,7 @@ impl MoveRules {
moves_seqs moves_seqs
} }
fn get_direct_exit_moves(&self, state: &GameState) -> Vec<CheckerMove> { fn _get_direct_exit_moves(&self, state: &GameState) -> Vec<CheckerMove> {
let mut moves = Vec::new(); let mut moves = Vec::new();
let (dice1, dice2) = state.dice.values; let (dice1, dice2) = state.dice.values;
@ -918,7 +918,7 @@ mod tests {
#[test] #[test]
fn moves_possible() { fn moves_possible() {
let mut state = MoveRules::default(); let state = MoveRules::default();
// Chained moves // Chained moves
let moves = ( let moves = (

130
store/src/game_rules_points.rs
View file

@ -1,4 +1,4 @@
use crate::board::{Board, Field, EMPTY_MOVE}; use crate::board::{Board, FieldWithCount, EMPTY_MOVE};
use crate::dice::Dice; use crate::dice::Dice;
use crate::game_rules_moves::MoveRules; use crate::game_rules_moves::MoveRules;
use crate::player::Color; use crate::player::Color;
@ -9,6 +9,7 @@ use serde::{Deserialize, Serialize};
use std::cmp; use std::cmp;
use std::collections::HashMap; use std::collections::HashMap;
#[allow(clippy::enum_variant_names)]
#[derive(PartialEq, Eq, Hash, Clone, Debug, Serialize, Deserialize)] #[derive(PartialEq, Eq, Hash, Clone, Debug, Serialize, Deserialize)]
pub enum Jan { pub enum Jan {
FilledQuarter, FilledQuarter,
@ -163,17 +164,16 @@ impl PointsRules {
} }
fn get_jans(&self, board_ini: &Board, dice_rolls_count: u8) -> PossibleJans { fn get_jans(&self, board_ini: &Board, dice_rolls_count: u8) -> PossibleJans {
let dices = &vec![self.dice.values.0, self.dice.values.1]; let dices = &[self.dice.values.0, self.dice.values.1];
let dices_reversed = &vec![self.dice.values.1, self.dice.values.0]; let dices_reversed = &[self.dice.values.1, self.dice.values.0];
let dice1 = self.dice.values.0 as usize; let dice1 = self.dice.values.0 as usize;
let dice2 = self.dice.values.1 as usize; let dice2 = self.dice.values.1 as usize;
// « JAN DE RÉCOMPENSE » // « JAN DE RÉCOMPENSE »
// Battre à vrai une dame située dans la table des grands jans // Battre à vrai une dame située dans la table des grands jans
// Battre à vrai une dame située dans la table des petits jans // Battre à vrai une dame située dans la table des petits jans
let mut jans = self.get_jans_by_ordered_dice(board_ini, dices, None, false); let mut jans = get_jans_by_ordered_dice(board_ini, dices, None, false);
let jans_revert_dices = let jans_revert_dices = get_jans_by_ordered_dice(board_ini, dices_reversed, None, false);
self.get_jans_by_ordered_dice(board_ini, dices_reversed, None, false);
jans.merge(jans_revert_dices); jans.merge(jans_revert_dices);
// Battre à vrai le coin de repos de l'adversaire // Battre à vrai le coin de repos de l'adversaire
@ -184,8 +184,8 @@ impl PointsRules {
let from0 = adv_corner_field - self.dice.values.0 as usize; let from0 = adv_corner_field - self.dice.values.0 as usize;
let from1 = adv_corner_field - self.dice.values.1 as usize; let from1 = adv_corner_field - self.dice.values.1 as usize;
let (from0_count, from0_color) = board_ini.get_field_checkers(from0).unwrap(); let (from0_count, _from0_color) = board_ini.get_field_checkers(from0).unwrap();
let (from1_count, from1_color) = board_ini.get_field_checkers(from1).unwrap(); let (from1_count, _from1_color) = board_ini.get_field_checkers(from1).unwrap();
let hit_moves = vec![( let hit_moves = vec![(
CheckerMove::new(from0, adv_corner_field).unwrap(), CheckerMove::new(from0, adv_corner_field).unwrap(),
CheckerMove::new(from1, adv_corner_field).unwrap(), CheckerMove::new(from1, adv_corner_field).unwrap(),
@ -253,9 +253,9 @@ impl PointsRules {
if dice_rolls_count == 3 { if dice_rolls_count == 3 {
// on devrait avoir 4 cases occupées par une dame chacune // on devrait avoir 4 cases occupées par une dame chacune
let fields_with_single: Vec<&(usize, i8)> = let fields_with_single: Vec<&(usize, i8)> =
checkers.iter().filter(|(f, c)| c == &1).collect(); checkers.iter().filter(|(_, c)| c == &1).collect();
if fields_with_single.len() == 4 { if fields_with_single.len() == 4 {
let checkers_fields: Vec<usize> = checkers.iter().map(|(f, c)| *f).collect(); let checkers_fields: Vec<usize> = checkers.iter().map(|(f, _)| *f).collect();
let mut missing_for_6tables: Vec<usize> = Vec::from([2, 3, 4, 5, 6, 7]) let mut missing_for_6tables: Vec<usize> = Vec::from([2, 3, 4, 5, 6, 7])
.into_iter() .into_iter()
.filter(|f| !checkers_fields.contains(f)) .filter(|f| !checkers_fields.contains(f))
@ -281,8 +281,8 @@ impl PointsRules {
} }
// Jans nécessitant que deux dames uniquement soient sorties du talon // Jans nécessitant que deux dames uniquement soient sorties du talon
let (talon, candidates): (Vec<(usize, i8)>, Vec<(usize, i8)>) = let (talon, candidates): (Vec<FieldWithCount>, Vec<FieldWithCount>) =
checkers.iter().partition(|(field, count)| field == &1); checkers.iter().partition(|(field, _count)| field == &1);
let candidates_fields = candidates.iter().fold(vec![], |mut acc, (f, c)| { let candidates_fields = candidates.iter().fold(vec![], |mut acc, (f, c)| {
acc.extend_from_slice(&vec![*f; *c as usize]); acc.extend_from_slice(&vec![*f; *c as usize]);
acc acc
@ -353,15 +353,48 @@ impl PointsRules {
jans jans
} }
pub fn get_jans_points(&self, jans: HashMap<Jan, Vec<(CheckerMove, CheckerMove)>>) -> (u8, u8) {
let (points, adv_points) = jans
.into_iter()
.fold((0, 0), |acc: (i8, i8), (jan, moves)| {
// println!("get_points : {:?}", jan);
let is_double = if jan == Jan::HelplessMan {
moves[0] == (CheckerMove::default(), CheckerMove::default())
} else {
self.dice.is_double()
};
let points = jan.get_points(is_double) * (moves.len() as i8);
if points < 0 {
(acc.0, acc.1 - points)
} else {
(acc.0 + points, acc.1)
}
});
(points as u8, adv_points as u8)
}
pub fn get_points(&self, dice_rolls_count: u8) -> (u8, u8) {
let jans = self.get_jans(&self.board, dice_rolls_count);
self.get_jans_points(jans)
}
pub fn get_result_jans(&self, dice_rolls_count: u8) -> (PossibleJans, (u8, u8)) {
let jans = self.get_jans(&self.board, dice_rolls_count);
let points_jans = jans.clone();
(jans, self.get_jans_points(points_jans))
}
}
fn get_jans_by_ordered_dice( fn get_jans_by_ordered_dice(
&self,
board_ini: &Board, board_ini: &Board,
dices: &Vec<u8>, // dices: &Vec<u8>,
dices: &[u8],
only_from: Option<usize>, only_from: Option<usize>,
only_false_hit: bool, only_false_hit: bool,
) -> PossibleJans { ) -> PossibleJans {
let mut jans = PossibleJans::default(); let mut jans = PossibleJans::default();
let mut dices = dices.clone(); let mut dices: Vec<u8> = dices.to_vec();
if let Some(dice) = dices.pop() { if let Some(dice) = dices.pop() {
let color = Color::White; let color = Color::White;
let mut board = board_ini.clone(); let mut board = board_ini.clone();
@ -424,9 +457,9 @@ impl PointsRules {
// - use original board before first die move // - use original board before first die move
// - use a virtual dice by adding current dice to remaining dice // - use a virtual dice by adding current dice to remaining dice
// - limit the checker to the current one // - limit the checker to the current one
let next_dice_jan = self.get_jans_by_ordered_dice( let next_dice_jan = get_jans_by_ordered_dice(
&board_ini, board_ini,
&dices.iter().map(|d| d + dice).collect(), &dices.iter().map(|d| d + dice).collect::<Vec<u8>>(),
Some(from), Some(from),
only_falsehit, only_falsehit,
); );
@ -434,8 +467,7 @@ impl PointsRules {
} }
} }
// Second die // Second die
let next_dice_jan = let next_dice_jan = get_jans_by_ordered_dice(board_ini, &dices, None, false);
self.get_jans_by_ordered_dice(&board_ini, &dices, None, false);
jans.merge(next_dice_jan); jans.merge(next_dice_jan);
} }
} }
@ -443,40 +475,6 @@ impl PointsRules {
jans jans
} }
pub fn get_jans_points(&self, jans: HashMap<Jan, Vec<(CheckerMove, CheckerMove)>>) -> (u8, u8) {
let (points, adv_points) = jans
.into_iter()
.fold((0, 0), |acc: (i8, i8), (jan, moves)| {
// println!("get_points : {:?}", jan);
let is_double = if jan == Jan::HelplessMan {
moves[0] == (CheckerMove::default(), CheckerMove::default())
} else {
self.dice.is_double()
};
let points = jan.get_points(is_double) * (moves.len() as i8);
if points < 0 {
(acc.0, acc.1 - points)
} else {
(acc.0 + points, acc.1)
}
});
(points as u8, adv_points as u8)
}
pub fn get_points(&self, dice_rolls_count: u8) -> (u8, u8) {
let jans = self.get_jans(&self.board, dice_rolls_count);
self.get_jans_points(jans)
}
pub fn get_result_jans(&self, dice_rolls_count: u8) -> (PossibleJans, (u8, u8)) {
let jans = self.get_jans(&self.board, dice_rolls_count);
let points_jans = jans.clone();
(jans, self.get_jans_points(points_jans))
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
@ -487,11 +485,11 @@ mod tests {
2, 0, -1, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, -1, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], None, false); let jans = get_jans_by_ordered_dice(&rules.board, &[2, 3], None, false);
assert_eq!(1, jans.len()); assert_eq!(1, jans.len());
assert_eq!(3, jans.get(&Jan::TrueHitSmallJan).unwrap().len()); assert_eq!(3, jans.get(&Jan::TrueHitSmallJan).unwrap().len());
let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 2], None, false); let jans = get_jans_by_ordered_dice(&rules.board, &[2, 2], None, false);
assert_eq!(1, jans.len()); assert_eq!(1, jans.len());
assert_eq!(1, jans.get(&Jan::TrueHitSmallJan).unwrap().len()); assert_eq!(1, jans.get(&Jan::TrueHitSmallJan).unwrap().len());
@ -501,9 +499,8 @@ mod tests {
2, 0, -1, -2, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, -1, -2, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
let mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], None, false); let mut jans = get_jans_by_ordered_dice(&rules.board, &[2, 3], None, false);
let jans_revert_dices = let jans_revert_dices = get_jans_by_ordered_dice(&rules.board, &[3, 2], None, false);
rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 2], None, false);
assert_eq!(2, jans.len()); assert_eq!(2, jans.len());
assert_eq!(1, jans_revert_dices.len()); assert_eq!(1, jans_revert_dices.len());
jans.merge(jans_revert_dices); jans.merge(jans_revert_dices);
@ -513,7 +510,7 @@ mod tests {
2, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], None, false); let jans = get_jans_by_ordered_dice(&rules.board, &[2, 3], None, false);
assert_eq!(1, jans.len()); assert_eq!(1, jans.len());
assert_eq!(2, jans.get(&Jan::TrueHitSmallJan).unwrap().len()); assert_eq!(2, jans.get(&Jan::TrueHitSmallJan).unwrap().len());
@ -521,7 +518,7 @@ mod tests {
2, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], None, false); let jans = get_jans_by_ordered_dice(&rules.board, &[2, 3], None, false);
assert_eq!(1, jans.len()); assert_eq!(1, jans.len());
assert_eq!(1, jans.get(&Jan::TrueHitSmallJan).unwrap().len()); assert_eq!(1, jans.get(&Jan::TrueHitSmallJan).unwrap().len());
@ -529,7 +526,7 @@ mod tests {
2, 0, 1, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 1, 1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], None, false); let jans = get_jans_by_ordered_dice(&rules.board, &[2, 3], None, false);
assert_eq!(1, jans.len()); assert_eq!(1, jans.len());
assert_eq!(3, jans.get(&Jan::TrueHitSmallJan).unwrap().len()); assert_eq!(3, jans.get(&Jan::TrueHitSmallJan).unwrap().len());
@ -540,7 +537,7 @@ mod tests {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
// le premier dé traité est le dernier du vecteur : 1 // le premier dé traité est le dernier du vecteur : 1
let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 1], None, false); let jans = get_jans_by_ordered_dice(&rules.board, &[2, 1], None, false);
// println!("jans (dés bloqués) : {:?}", jans.get(&Jan::TrueHit)); // println!("jans (dés bloqués) : {:?}", jans.get(&Jan::TrueHit));
assert_eq!(0, jans.len()); assert_eq!(0, jans.len());
@ -548,16 +545,15 @@ mod tests {
rules.board.set_positions([ rules.board.set_positions([
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 3], None, false); let jans = get_jans_by_ordered_dice(&rules.board, &[3, 3], None, false);
assert_eq!(1, jans.len()); assert_eq!(1, jans.len());
// premier dé bloqué, mais tout d'une possible en commençant par le second // premier dé bloqué, mais tout d'une possible en commençant par le second
rules.board.set_positions([ rules.board.set_positions([
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]); ]);
let mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 1], None, false); let mut jans = get_jans_by_ordered_dice(&rules.board, &[3, 1], None, false);
let jans_revert_dices = let jans_revert_dices = get_jans_by_ordered_dice(&rules.board, &[1, 3], None, false);
rules.get_jans_by_ordered_dice(&rules.board, &vec![1, 3], None, false);
assert_eq!(1, jans_revert_dices.len()); assert_eq!(1, jans_revert_dices.len());
jans.merge(jans_revert_dices); jans.merge(jans_revert_dices);

1
store/src/player.rs
View file

@ -76,6 +76,7 @@ pub enum CurrentPlayer {
impl CurrentPlayer { impl CurrentPlayer {
/// Returns the other player, i.e. the player who is not the current player. /// Returns the other player, i.e. the player who is not the current player.
#[cfg(test)]
pub fn other(&self) -> Self { pub fn other(&self) -> Self {
match *self { match *self {
CurrentPlayer::Nobody => CurrentPlayer::Nobody, CurrentPlayer::Nobody => CurrentPlayer::Nobody,