src/main.rs

   1 use std::cmp::{ Ordering, PartialOrd };
   2 use rand::{thread_rng, Rng};
   3 use rand::distributions::{Distribution, Uniform};
   4
   5 #[derive(PartialEq, Debug, Clone)]
   6 enum Card {
   7     As,
   8     King,
   9     Queen,
  10     Jack,
  11     Value(u8) // 2 to 10.
  12 }
  13
  14 impl PartialOrd for Card {
  15     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  16         if self == other {
  17             return Some(Ordering::Equal);
  18         }
  19
  20         let figures = vec![Card::As, Card::King, Card::Queen, Card::Jack];
  21
  22         for figure in figures {
  23             if self == &figure {
  24                 return Some(Ordering::Greater);
  25             }
  26             if other == &figure {
  27                 return Some(Ordering::Less);
  28             }
  29         }
  30
  31         match (self, other) {
  32             (Card::Value(self_val), Card::Value(other_val)) => self_val.partial_cmp(other_val),
  33             _ => None
  34         }
  35     }
  36
  37 }
  38
  39 fn create_deck() -> Vec<Card> {
  40     let mut deck: Vec<Card> = vec![];
  41     for i in 0..4 {
  42         deck.push(Card::As);
  43         deck.push(Card::King);
  44         deck.push(Card::Queen);
  45         deck.push(Card::Jack);
  46         for v in 2..=10 {
  47             deck.push(Card::Value(v));
  48         }
  49     }
  50     deck
  51 }
  52
  53 fn shuffle_deck(deck: &mut Vec<Card>) {
  54     let mut rng = thread_rng();
  55     let deck_range = Uniform::new(0, deck.len());
  56
  57     for _ in 0 .. deck.len() * 100 {
  58         let a = deck_range.sample(&mut rng);
  59         let b = deck_range.sample(&mut rng);
  60         if a != b {
  61             deck.swap(a, b);
  62         }
  63     }
  64 }
  65
  66 struct Deck {
  67     main: Vec<Card>,
  68     captured: Vec<Card>
  69 }
  70
  71 fn play() -> u32 {
  72     let mut current_turn = 0u32;
  73
  74     let mut deck = create_deck();
  75     shuffle_deck(&mut deck);
  76
  77     let mut player1_deck = deck[0..deck.len() / 2].to_vec();
  78     let mut player1_captured = Vec::<Card>::new();
  79
  80     let mut player2_deck = deck[deck.len() / 2 .. deck.len()].to_vec();
  81     let mut player2_captured = Vec::<Card>::new();
  82
  83     while player1_deck.len() + player1_captured.len() > 0 && player2_deck.len() + player2_captured.len() > 0 {
  84         current_turn += 1;
  85
  86         if player1_deck.len() == 0 {
  87             player1_deck.clone_from_slice(&player1_captured);
  88             shuffle_deck(&mut player1_deck);
  89             player1_captured.clear();
  90         }
  91
  92         if player2_deck.len() == 0 {
  93             player2_deck.clone_from_slice(&player2_captured);
  94             shuffle_deck(&mut player2_deck);
  95             player2_captured.clear();
  96         }
  97
  98         let c1 = player1_deck.pop().unwrap()
  99         let c2 = player1_deck.pop().unwrap()
 100
 101 /*
 102         if  {
 103             return current_turn;
 104         }*/
 105     }
 106
 107     //dbg!(deck);
 108
 109     current_turn
 110 }
 111
 112 fn main() {
 113     println!("Bataille simulator");
 114
 115     let n = 1;
 116     for i in 0..n {
 117         let nb_of_turns = play();
 118         dbg!(nb_of_turns);
 119     }
 120 }
 121
 122
 123 #[cfg(test)]
 124 mod tests {
 125     use super::*;
 126
 127     #[test]
 128     fn test_card_comparisons() {
 129         assert!(Card::As == Card::As);
 130         assert!(Card::King == Card::King);
 131         assert!(Card::Queen == Card::Queen);
 132         assert!(Card::Jack == Card::Jack);
 133         assert!(Card::Value(10) == Card::Value(10));
 134         assert!(Card::Value(2) == Card::Value(2));
 135         assert!(Card::As > Card::King);
 136         assert!(Card::As > Card::Queen);
 137         assert!(Card::As > Card::Jack);
 138         assert!(Card::As > Card::Value(10));
 139         assert!(Card::King > Card::Queen);
 140         assert!(Card::King > Card::Jack);
 141         assert!(Card::King > Card::Value(10));
 142         assert!(Card::Queen > Card::Jack);
 143         assert!(Card::Queen > Card::Value(10));
 144         assert!(Card::Jack > Card::Value(10));
 145         assert!(Card::Value(10) > Card::Value(9));
 146     }
 147 }