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

wip battage à faux

Browse source
This commit is contained in:
Henri Bourcereau 2024-09-19 18:19:34 +02:00
parent 4f118319ed
commit 5bf3a3ec91
1 changed files with 98 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

121
store/src/game_rules_points.rs
View file

@ -83,7 +83,42 @@ impl PossibleJansMethods for PossibleJans {
fn merge(&mut self, other: Self) { fn merge(&mut self, other: Self) {
for (jan, cmoves_list) in other { for (jan, cmoves_list) in other {
for cmoves in cmoves_list { for cmoves in cmoves_list {
self.push(jan.clone(), cmoves); // pour un même mouvement, le battage à vrai est prioritaire sur le battage à faux.
match jan {
Jan::FalseHitBigJan => {
let mut has_true_hit = false;
if let Some(true_moves) = self.get(&Jan::TrueHitBigJan) {
has_true_hit = true_moves.contains(&cmoves);
}
if !has_true_hit {
self.push(jan.clone(), cmoves);
}
}
Jan::FalseHitSmallJan => {
let mut has_true_hit = false;
if let Some(true_moves) = self.get(&Jan::TrueHitSmallJan) {
has_true_hit = true_moves.contains(&cmoves);
}
if !has_true_hit {
self.push(jan.clone(), cmoves);
}
}
Jan::TrueHitBigJan => {
if let Some(false_moves) = self.get_mut(&Jan::FalseHitBigJan) {
false_moves.retain(|fmoves| *fmoves != cmoves);
}
self.push(jan.clone(), cmoves);
}
Jan::TrueHitSmallJan => {
if let Some(false_moves) = self.get_mut(&Jan::FalseHitSmallJan) {
false_moves.retain(|fmoves| *fmoves != cmoves);
}
self.push(jan.clone(), cmoves);
}
_ => {
self.push(jan.clone(), cmoves);
}
}
} }
} }
} }
@ -133,8 +168,8 @@ impl PointsRules {
// « 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); let mut jans = self.get_jans_by_ordered_dice(board_ini, dices, false);
let jans_revert_dices = self.get_jans_by_ordered_dice(board_ini, dices_reversed); let jans_revert_dices = self.get_jans_by_ordered_dice(board_ini, dices_reversed, 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
@ -294,7 +329,12 @@ impl PointsRules {
jans jans
} }
fn get_jans_by_ordered_dice(&self, board_ini: &Board, dices: &Vec<u8>) -> PossibleJans { fn get_jans_by_ordered_dice(
&self,
board_ini: &Board,
dices: &Vec<u8>,
only_false_hit: bool,
) -> PossibleJans {
let mut jans = PossibleJans::default(); let mut jans = PossibleJans::default();
let mut dices = dices.clone(); let mut dices = dices.clone();
if let Some(dice) = dices.pop() { if let Some(dice) = dices.pop() {
@ -326,15 +366,20 @@ impl PointsRules {
// dice, adv_corner_field, from, to, corner_count // dice, adv_corner_field, from, to, corner_count
// ); // );
let mut can_try_toutdune = true; let mut can_try_toutdune = true;
let mut only_falsehit = false;
match board.move_checker(&color, cmove) { match board.move_checker(&color, cmove) {
Err(Error::FieldBlockedByOne) => { Err(Error::FieldBlockedByOne) => {
let jan = if Board::is_field_in_small_jan(to) { let jan = match (Board::is_field_in_small_jan(to), only_false_hit) {
Jan::TrueHitSmallJan (true, false) => Jan::TrueHitSmallJan,
} else { (true, true) => Jan::FalseHitSmallJan,
Jan::TrueHitBigJan (false, false) => Jan::TrueHitBigJan,
(false, true) => Jan::FalseHitBigJan,
}; };
jans.push(jan, (cmove, EMPTY_MOVE)); jans.push(jan, (cmove, EMPTY_MOVE));
} }
Err(Error::FieldBlocked) => {
only_falsehit = true;
}
Err(_) => { Err(_) => {
can_try_toutdune = false; can_try_toutdune = false;
// let next_dice_jan = self.get_jans(&board, &dices); // let next_dice_jan = self.get_jans(&board, &dices);
@ -350,12 +395,13 @@ impl PointsRules {
let next_dice_jan = self.get_jans_by_ordered_dice( let next_dice_jan = self.get_jans_by_ordered_dice(
&board_ini, &board_ini,
&dices.iter().map(|d| d + dice).collect(), &dices.iter().map(|d| d + dice).collect(),
only_falsehit,
); );
jans.merge(next_dice_jan); jans.merge(next_dice_jan);
} }
} }
// Second die // Second die
let next_dice_jan = self.get_jans_by_ordered_dice(&board_ini, &dices); let next_dice_jan = self.get_jans_by_ordered_dice(&board_ini, &dices, false);
jans.merge(next_dice_jan); jans.merge(next_dice_jan);
} }
} }
@ -392,11 +438,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]); let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], 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]); let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 2], 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());
@ -406,9 +452,9 @@ 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]); let mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], false);
let jans_revert_dices = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 2]); let jans_revert_dices = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 2], false);
assert_eq!(1, 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);
assert_eq!(2, jans.get(&Jan::TrueHitSmallJan).unwrap().len()); assert_eq!(2, jans.get(&Jan::TrueHitSmallJan).unwrap().len());
@ -417,7 +463,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]); let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], 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());
@ -425,7 +471,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]); let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], 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());
@ -433,7 +479,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]); let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3], 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());
@ -444,7 +490,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]); let jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 1], 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());
@ -452,15 +498,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 mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 3]); let mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 3], 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]); let mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 1], false);
let jans_revert_dices = rules.get_jans_by_ordered_dice(&rules.board, &vec![1, 3]); let jans_revert_dices = rules.get_jans_by_ordered_dice(&rules.board, &vec![1, 3], 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);
@ -489,6 +535,13 @@ mod tests {
]); ]);
rules.set_dice(Dice { values: (2, 4) }); rules.set_dice(Dice { values: (2, 4) });
assert_eq!(4, rules.get_points().0); assert_eq!(4, rules.get_points().0);
// Battre à vrai une dame située dans la table des grands jans : 2
let mut rules = PointsRules::default();
rules.update_positions([
2, 0, -2, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]);
rules.set_dice(Dice { values: (2, 4) });
assert_eq!((2, 0), rules.get_points());
// Battre à vrai le coin adverse par doublet : 6 // Battre à vrai le coin adverse par doublet : 6
rules.update_positions([ rules.update_positions([
@ -606,8 +659,30 @@ mod tests {
assert_eq!((0, 6), rules.get_points()); assert_eq!((0, 6), rules.get_points());
// ---- JANS QUI NE PEUT // ---- JANS QUI NE PEUT
// Battre à faux une dame située dans la table des grands jans // Battre à faux une dame située dans la table des petits jans
// Battre à faux une dame située dans la table des petits jans let mut rules = PointsRules::default();
rules.update_positions([
2, 0, -2, -2, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]);
rules.set_dice(Dice { values: (2, 3) });
assert_eq!((0, 4), rules.get_points());
// Battre à faux une dame située dans la table des grands jans
let mut rules = PointsRules::default();
println!("------------------------------");
rules.update_positions([
2, 0, -2, -1, -2, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]);
rules.set_dice(Dice { values: (2, 4) });
assert_eq!((0, 2), rules.get_points());
println!("------------------------------");
// Pour chaque dé non jouable (dame impuissante) // Pour chaque dé non jouable (dame impuissante)
let mut rules = PointsRules::default();
rules.update_positions([
2, 0, -2, -2, -2, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]);
rules.set_dice(Dice { values: (2, 4) });
assert_eq!((0, 4), rules.get_points());
} }
} }