Setup skeleton for game playing

src/card.rs

@@ -92,7 +92,17 @@ pub struct Face {
 
 impl Ord for Face {
     fn cmp(&self, face: &Face) -> Ordering {
-        self.symbol.cmp(&face.symbol)
+        match self.symbol.cmp(&face.symbol) {
+            Ordering::Equal => {
+                let result = self.suit.cmp(&face.suit);
+                if result == Ordering::Equal {
+                    println!("Equal cards!");
+                }
+                result
+            }
+            Ordering::Less => Ordering::Less,
+            Ordering::Greater => Ordering::Greater,
+        }
     }
 }
 

src/deck.rs

@@ -1,17 +1,14 @@
 use card;
+use params;
 use rand::{thread_rng, Rng};
 use std::collections::BTreeSet;
 
-pub const DECK_SIZE: usize = 78;
-pub const NUMBER_OF_PLAYERS: usize = 4;
-pub const CARDS_PER_DISTRIBUTION: usize = 3;
-pub type Deck = [card::Card; DECK_SIZE];
-pub type Hand = BTreeSet<card::Card>;
-
+pub type Deck = [card::Card; params::DECK_SIZE];
+pub type Hand = (i32, BTreeSet<card::Card>);
 
 // Creates a deck_size cards tarot deck, shuffled
 pub fn new_deck() -> Deck {
-    let mut deck: [card::Card; DECK_SIZE] = [card::Card::Fool; DECK_SIZE];
+    let mut deck: [card::Card; params::DECK_SIZE] = [card::Card::Fool; params::DECK_SIZE];
     let mut counter = 0;
     for suit in card::Suit::values() {
         for symbol in card::Symbol::values() {
@@ -33,16 +30,18 @@ pub fn new_deck() -> Deck {
 }
 
 // Distributes the deck between the four players and the dog
-pub fn distribute_cards(deck: Deck) -> (Hand, [Hand; 4]) {
-    let mut dog: Hand = BTreeSet::new();
-    let mut hands: [Hand; NUMBER_OF_PLAYERS] =
-        [BTreeSet::new(), BTreeSet::new(), BTreeSet::new(), BTreeSet::new()];
-    for i in 0..(DECK_SIZE - 1) {
-        if i <= 5 {
+pub fn distribute_cards(deck: Deck) -> (Hand, [Hand; params::NUMBER_OF_PLAYERS]) {
+    let (_, mut dog): Hand = (-1, BTreeSet::new());
+    let mut hands: [Hand; params::NUMBER_OF_PLAYERS] =
+        [(0, BTreeSet::new()), (1, BTreeSet::new()), (2, BTreeSet::new()), (3, BTreeSet::new())];
+    for i in 0..params::DECK_SIZE {
+        if i < params::DOG_SIZE {
             dog.insert(deck[i]);
         } else {
-            hands[(i / CARDS_PER_DISTRIBUTION) % NUMBER_OF_PLAYERS].insert(deck[i]);
+            hands[(i / params::CARDS_PER_DISTRIBUTION) % params::NUMBER_OF_PLAYERS]
+                .1
+                .insert(deck[i]);
         }
     }
-    (dog, hands)
+    ((-1, dog), hands)
 }

src/game.rs

@@ -0,0 +1,46 @@
+use params;
+use deck;
+use card;
+use std::collections::BTreeSet;
+
+type Heap = Vec<card::Card>;
+
+pub fn start_game(dog: deck::Hand, hands: [deck::Hand; params::NUMBER_OF_PLAYERS]) {
+    let cards_per_player = hands[0].1.len();
+    //Check if all players have same number of cards
+    for i in 1..params::NUMBER_OF_PLAYERS {
+        if cards_per_player != hands[i].1.len() {
+            panic!("the players don't have the same number of cards")
+        }
+    }
+    //If yes start the game
+    let starting_player = 0;
+    (1..cards_per_player).fold((starting_player, hands), |(starting_player, hands), _| {
+        //For each turn
+        let mut new_hands: [deck::Hand; params::NUMBER_OF_PLAYERS] = [(0, BTreeSet::new()),
+                                                                      (1, BTreeSet::new()),
+                                                                      (2, BTreeSet::new()),
+                                                                      (3, BTreeSet::new())];
+        let end_heap = hands.into_iter().enumerate().fold(Vec::new(), |heap, (i, hand)| {
+            // For each player
+            let (new_hand, new_heap) = play_card(hand.clone(), heap);
+            new_hands[i - starting_player % params::NUMBER_OF_PLAYERS] = new_hand;
+            new_heap
+        });
+        let new_starting_player = winning_card(end_heap);
+        (new_starting_player, hands)
+    });
+}
+
+fn play_card(hand: deck::Hand, cards_played: Heap) -> (deck::Hand, Heap) {
+    (hand, cards_played)
+}
+
+fn valid_cards(hand: deck::Hand, cards_played: Heap) -> (deck::Hand) {
+    //TODO
+    hand
+}
+
+fn winning_card(cards: Heap) -> usize {
+    0
+}

src/main.rs

@@ -1,19 +1,26 @@
 mod card;
 mod deck;
+mod params;
+mod game;
 
 extern crate rand;
 
+pub const DECK_SIZE: usize = 78;
+pub const NUMBER_OF_PLAYERS: usize = 4;
+pub const CARDS_PER_DISTRIBUTION: usize = 3;
+
 fn main() {
     let deck = deck::new_deck();
-    let (dog, hands) = deck::distribute_cards(deck);
+    let ((_, dog), hands) = deck::distribute_cards(deck);
     println!("-> Cartes du chien :");
     for card in dog.iter() {
         println!("{}", card);
     }
-    for i in 0..(deck::NUMBER_OF_PLAYERS) {
-        println!("-> Cartes du joueur {} :", i + 1);
-        for card in hands[i].iter() {
+    for &(number, ref hand) in hands.into_iter() {
+        println!("-> Cartes du joueur {} ({}):", number + 1, hand.len());
+        for card in hand.iter() {
             println!("{}", card);
         }
     }
+    game::start_game((-1, dog), hands);
 }

src/params.rs

@@ -0,0 +1,4 @@
+pub const DECK_SIZE: usize = 78;
+pub const DOG_SIZE: usize = 6;
+pub const NUMBER_OF_PLAYERS: usize = 4;
+pub const CARDS_PER_DISTRIBUTION: usize = 3;