Starting to implement game

src/deck.rs

 pub fn distribute_cards(deck: &Deck) -> (Hand, Vec<Hand>) {
     let mut dog: Hand = BTreeSet::new();
     let mut hands: Vec<Hand> = Vec::new();
+    for _ in 0..(params::NUMBER_OF_PLAYERS) {
+        hands.push(BTreeSet::new())
+    }
     for i in 0..deck.len() {
         if i < params::DOG_SIZE {
             dog.insert(deck[i]);

src/game.rs

 use params;
 use deck;
 use card;
-use std::collections::BTreeSet;
 
-type Heap = Vec<card::Card>;
+type Heap = Vec<(card::Card, i32)>;
+
+#[derive(Clone)]
 pub struct Player {
     pub id: i32,
     pub name: String,
     pub hand: deck::Hand,
 }
 
+// Empty the hands and names vector and creates a player vector instead
 pub fn initialize_players(hands: &mut Vec<deck::Hand>, names: &mut Vec<String>) -> Vec<Player> {
     if hands.len() != names.len() {}
     let mut counter = 0;
     let mut players = Vec::new();
-    for i in 0..hands.len() {
+    for _ in 0..hands.len() {
         let name = match names.pop() {
             Some(name) => name,
             None => panic!("the number of hands is different from the number of players"),
     players
 }
 
-pub fn start_game(dog: &deck::Hand, players: &mut Vec<Player>) {
+pub fn start_game(_: &deck::Hand, mut players: &mut Vec<Player>) {
     let cards_per_player = players[0].hand.len();
     //Check if all players have same number of cards
     for i in 1..params::NUMBER_OF_PLAYERS {
             panic!("the players don't have the same number of cards")
         }
     }
-    for i in 0..cards_per_player {
-        for player in players.iter_mut() {}
+    let mut starting_player_id = 1;
+    for _ in 0..cards_per_player {
+        // For each round of the game
+        let mut cards_played: Heap = Vec::new();
+        sort_by_playing_order(&mut players, starting_player_id);
+        for player in players.iter_mut() {
+            // For each player
+            play_card(player, &mut cards_played)
+        }
+        // Decide who has won
+        starting_player_id = winning_player(&cards_played);
     }
-    unimplemented!();
+}
+
+fn sort_by_playing_order(mut players: &mut Vec<Player>, starting_player_id: i32) {
+    players.sort_by(|p1, p2| {
+        (p1.id + starting_player_id % params::NUMBER_OF_PLAYERS as i32)
+            .cmp(&(p2.id + starting_player_id % params::NUMBER_OF_PLAYERS as i32))
+    });
 }
 
 fn play_card(player: &mut Player, cards_played: &mut Heap) {
     unimplemented!();
 }
 
-fn winning_card(cards: &Heap) -> usize {
+fn winning_player(cards: &Heap) -> i32 {
     unimplemented!();
 }

src/main.rs

 pub const CARDS_PER_DISTRIBUTION: usize = 3;
 
 fn main() {
+    let mut names: Vec<String> =
+        vec!["A".to_string(), "B".to_string(), "C".to_string(), "D".to_string()];
     let deck = deck::new_deck();
     let (dog, mut hands) = deck::distribute_cards(&deck);
+    let mut players = game::initialize_players(&mut hands, &mut names);
     println!("-> Cartes du chien :");
     for card in dog.iter() {
         println!("{}", card);
     }
-    for hand in hands.iter() {
-        println!("-> Cartes du joueur {}:", 0);
-        for card in hand.iter() {
+    for player in players.iter() {
+        println!("-> Cartes du joueur {}:", player.id);
+        for card in player.hand.iter() {
             println!("{}", card);
         }
     }
-    let mut names: Vec<String> =
-        vec!["A".to_string(), "B".to_string(), "C".to_string(), "D".to_string()];
-    let mut players = game::initialize_players(&mut hands, &mut names);
     game::start_game(&dog, &mut players);
 }