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) {
for (jan, cmoves_list) in other {
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 »
// Battre à vrai une dame située dans la table des grands 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 jans_revert_dices = self.get_jans_by_ordered_dice(board_ini, dices_reversed);
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, false);
jans.merge(jans_revert_dices);
// Battre à vrai le coin de repos de l'adversaire
@ -294,7 +329,12 @@ impl PointsRules {
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 dices = dices.clone();
if let Some(dice) = dices.pop() {
@ -326,15 +366,20 @@ impl PointsRules {
// dice, adv_corner_field, from, to, corner_count
// );
let mut can_try_toutdune = true;
let mut only_falsehit = false;
match board.move_checker(&color, cmove) {
Err(Error::FieldBlockedByOne) => {
let jan = if Board::is_field_in_small_jan(to) {
Jan::TrueHitSmallJan
} else {
Jan::TrueHitBigJan
let jan = match (Board::is_field_in_small_jan(to), only_false_hit) {
(true, false) => Jan::TrueHitSmallJan,
(true, true) => Jan::FalseHitSmallJan,
(false, false) => Jan::TrueHitBigJan,
(false, true) => Jan::FalseHitBigJan,
};
jans.push(jan, (cmove, EMPTY_MOVE));
}
Err(Error::FieldBlocked) => {
only_falsehit = true;
}
Err(_) => {
can_try_toutdune = false;
// 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(
&board_ini,
&dices.iter().map(|d| d + dice).collect(),
only_falsehit,
);
jans.merge(next_dice_jan);
}
}
// 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);
}
}
@ -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,
]);
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!(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.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,
]);
let mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![2, 3]);
let jans_revert_dices = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 2]);
assert_eq!(1, jans.len());
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], false);
assert_eq!(2, jans.len());
assert_eq!(1, jans_revert_dices.len());
jans.merge(jans_revert_dices);
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,
]);
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!(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,
]);
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.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,
]);
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!(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,
]);
// 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));
assert_eq!(0, jans.len());
@ -452,15 +498,15 @@ mod tests {
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,
]);
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());
// premier dé bloqué, mais tout d'une possible en commençant par le second
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,
]);
let mut jans = rules.get_jans_by_ordered_dice(&rules.board, &vec![3, 1]);
let jans_revert_dices = rules.get_jans_by_ordered_dice(&rules.board, &vec![1, 3]);
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], false);
assert_eq!(1, jans_revert_dices.len());
jans.merge(jans_revert_dices);
@ -489,6 +535,13 @@ mod tests {
]);
rules.set_dice(Dice { values: (2, 4) });
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
rules.update_positions([
@ -606,8 +659,30 @@ mod tests {
assert_eq!((0, 6), rules.get_points());
// ---- 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)
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());
}
}