Added scoring system

src/game.rs

     players
 }
 
-pub fn start_game(mut dog: &mut deck::Hand, mut players: &mut Vec<Player>) {
+//Plays the game and returns the tuple (attack_heap,defense_heap)
+pub fn play_game(mut dog: &mut deck::Hand, mut players: &mut Vec<Player>) -> Game {
     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 {
             }
         }
     }
-
-    println!("-> Cartes gagnées par l'attaque");
-    for &(card, id) in game.attack_heap.iter() {
-        println!("{} ({})",
-                 card,
-                 match players.iter().find(|player| player.id == id) {
-                     None => panic!("cannot find the player who won the round"),
-                     Some(player) => &player.name,
-                 });
-    }
-    println!("-> Cartes gagnées par la défense");
-    for &(card, id) in game.defense_heap.iter() {
-        println!("{} ({})",
-                 card,
-                 match players.iter().find(|player| player.id == id) {
-                     None => panic!("cannot find the player who won the round"),
-                     Some(player) => &player.name,
-                 });
-    }
+    game
 }
 
 // Keeps the order of the game but puts starting player first

src/main.rs

 mod params;
 mod game;
 mod ai;
+mod scoring;
 
 extern crate rand;
 
             println!("{}", card);
         }
     }
-    game::start_game(&mut dog, &mut players);
+    let game = game::play_game(&mut dog, &mut players);
+    println!("===== Fin de la partie ! =====");
+    let game_scores = scoring::compute_game_scores(&game);
+    println!("Score de l'attaque ({}) : {} ({} bouts), score de la défense : {}",
+             match players.iter().find(|player| player.id == game.taker_id) {
+                 None => panic!("cannot find the player who won the round"),
+                 Some(player) => &player.name,
+             },
+             game_scores.attack_score,
+             game_scores.attack_bouts_number,
+             game_scores.defense_score);
 }

src/scoring.rs

+use game;
+use card;
+
+pub struct GameScores {
+    pub attack_score: f32,
+    pub defense_score: f32,
+    pub attack_bouts_number: i32,
+}
+
+pub fn compute_game_scores(game: &game::Game) -> GameScores {
+    let mut game_scores: GameScores = GameScores {
+        attack_score: 0 as f32,
+        defense_score: 0 as f32,
+        attack_bouts_number: 0,
+    };
+    for &(card, _) in game.attack_heap.iter() {
+        game_scores.attack_score += card_score(&card);
+        match card {
+            card::Card::Fool |
+            card::Card::Trump(card::Trump::One) |
+            card::Card::Trump(card::Trump::TwentyOne) => game_scores.attack_bouts_number += 1,
+            _ => (),
+        }
+    }
+    for &(card, _) in game.defense_heap.iter() {
+        game_scores.defense_score += card_score(&card);
+    }
+    game_scores
+}
+
+fn card_score(&card: &card::Card) -> f32 {
+    match card {
+        card::Card::Face(card::Face { suit: _, symbol }) => {
+            match symbol {
+                card::Symbol::Jack => 1.5,
+                card::Symbol::Knight => 2.5,
+                card::Symbol::Queen => 3.5,
+                card::Symbol::King => 4.5,
+                _ => 0.5,
+            }
+        }
+        card::Card::Fool |
+        card::Card::Trump(card::Trump::One) |
+        card::Card::Trump(card::Trump::TwentyOne) => 4.5,
+        _ => 0.5,
+    }
+}