Trying to play

src/card.rs

 use std::fmt;
 use std::cmp::Ordering;
 
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Suit {
     Clubs,
     Diamonds,
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Symbol {
     Ace,
     Two,
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd)]
 pub struct Face {
     pub suit: Suit,
     pub symbol: Symbol,
 impl Ord for Face {
     fn cmp(&self, face: &Face) -> Ordering {
         match self.symbol.cmp(&face.symbol) {
-            Ordering::Equal => {
-                let result = self.suit.cmp(&face.suit);
-                if result == Ordering::Equal {
-                    println!("Equal cards!");
-                }
-                result
-            }
+            Ordering::Equal => self.suit.cmp(&face.suit),
             Ordering::Less => Ordering::Less,
             Ordering::Greater => Ordering::Greater,
         }
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum Trump {
     One,
     Two,
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd)]
 pub enum Card {
     Face(Face),
     Trump(Trump),

src/game.rs

             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)
+        let new_starting_player = winning_card(end_heap.clone());
+        println!("Les joueurs ont joué : {:?}", end_heap);
+        (new_starting_player, new_hands)
     });
 }
 
-fn play_card(hand: deck::Hand, cards_played: Heap) -> (deck::Hand, Heap) {
-    (hand, cards_played)
+fn play_card((player, hand): deck::Hand, cards_played: Heap) -> (deck::Hand, Heap) {
+    let valid_cards = valid_cards((player, hand.clone()), cards_played.clone());
+    let card_to_play = select_card(valid_cards, cards_played.clone());
+    println!("Card to play: {:?}", card_to_play.clone());
+    let mut new_hand = hand.clone();
+    new_hand.take(&card_to_play);
+    let mut new_cards_played = cards_played.clone();
+    new_cards_played.push(card_to_play);
+    ((player, new_hand), new_cards_played)
 }
 
-fn valid_cards(hand: deck::Hand, cards_played: Heap) -> (deck::Hand) {
-    //TODO
+fn valid_cards(hand: deck::Hand, cards_played: Heap) -> deck::Hand {
     hand
 }
 
+fn select_card((player, valid_cards): deck::Hand, cards_played: Heap) -> card::Card {
+    match valid_cards.into_iter().next() {
+        Some(card) => card,
+        None => panic!("there is no valid card to play"),
+    }
+}
+
 fn winning_card(cards: Heap) -> usize {
     0
 }

src/main.rs

         println!("{}", card);
     }
     for &(number, ref hand) in hands.into_iter() {
-        println!("-> Cartes du joueur {} ({}):", number + 1, hand.len());
+        println!("-> Cartes du joueur {}:", number + 1);
         for card in hand.iter() {
             println!("{}", card);
         }