+use std::cmp::{ Ordering, PartialOrd };
+use rand::{thread_rng, Rng};
+use rand::distributions::{Distribution, Uniform};
+
+#[derive(PartialEq, Debug, Clone)]
+enum Card {
+ As,
+ King,
+ Queen,
+ Jack,
+ Value(u8) // 2 to 10.
+}
+
+impl PartialOrd for Card {
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ if self == other {
+ return Some(Ordering::Equal);
+ }
+
+ let figures = vec![Card::As, Card::King, Card::Queen, Card::Jack];
+
+ for figure in figures {
+ if self == &figure {
+ return Some(Ordering::Greater);
+ }
+ if other == &figure {
+ return Some(Ordering::Less);
+ }
+ }
+
+ match (self, other) {
+ (Card::Value(self_val), Card::Value(other_val)) => self_val.partial_cmp(other_val),
+ _ => None
+ }
+ }
+
+}
+
+fn create_deck() -> Vec<Card> {
+ let mut deck: Vec<Card> = vec![];
+ for i in 0..4 {
+ deck.push(Card::As);
+ deck.push(Card::King);
+ deck.push(Card::Queen);
+ deck.push(Card::Jack);
+ for v in 2..=10 {
+ deck.push(Card::Value(v));
+ }
+ }
+ deck
+}
+
+fn shuffle_deck(deck: &mut Vec<Card>) {
+ let mut rng = thread_rng();
+ let deck_range = Uniform::new(0, deck.len());
+
+ for _ in 0 .. deck.len() * 100 {
+ let a = deck_range.sample(&mut rng);
+ let b = deck_range.sample(&mut rng);
+ if a != b {
+ deck.swap(a, b);
+ }
+ }
+}
+
+struct Deck {
+ main: Vec<Card>,
+ captured: Vec<Card>
+}
+
+fn play() -> u32 {
+ let mut current_turn = 0u32;
+
+ let mut deck = create_deck();
+ shuffle_deck(&mut deck);
+
+ let mut player1_deck = deck[0..deck.len() / 2].to_vec();
+ let mut player1_captured = Vec::<Card>::new();
+
+ let mut player2_deck = deck[deck.len() / 2 .. deck.len()].to_vec();
+ let mut player2_captured = Vec::<Card>::new();
+
+ while player1_deck.len() + player1_captured.len() > 0 && player2_deck.len() + player2_captured.len() > 0 {
+ current_turn += 1;
+
+ if player1_deck.len() == 0 {
+ player1_deck.clone_from_slice(&player1_captured);
+ shuffle_deck(&mut player1_deck);
+ player1_captured.clear();
+ }
+
+ if player2_deck.len() == 0 {
+ player2_deck.clone_from_slice(&player2_captured);
+ shuffle_deck(&mut player2_deck);
+ player2_captured.clear();
+ }
+
+ let c1 = player1_deck.pop().unwrap()
+ let c2 = player1_deck.pop().unwrap()
+
+/*
+ if {
+ return current_turn;
+ }*/
+ }
+
+ //dbg!(deck);
+
+ current_turn
+}
+
+fn main() {
+ println!("Bataille simulator");
+
+ let n = 1;
+ for i in 0..n {
+ let nb_of_turns = play();
+ dbg!(nb_of_turns);
+ }
+}
+
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_card_comparisons() {
+ assert!(Card::As == Card::As);
+ assert!(Card::King == Card::King);
+ assert!(Card::Queen == Card::Queen);
+ assert!(Card::Jack == Card::Jack);
+ assert!(Card::Value(10) == Card::Value(10));
+ assert!(Card::Value(2) == Card::Value(2));
+ assert!(Card::As > Card::King);
+ assert!(Card::As > Card::Queen);
+ assert!(Card::As > Card::Jack);
+ assert!(Card::As > Card::Value(10));
+ assert!(Card::King > Card::Queen);
+ assert!(Card::King > Card::Jack);
+ assert!(Card::King > Card::Value(10));
+ assert!(Card::Queen > Card::Jack);
+ assert!(Card::Queen > Card::Value(10));
+ assert!(Card::Jack > Card::Value(10));
+ assert!(Card::Value(10) > Card::Value(9));
+ }
+}