Implemented game mechanics

Heaps of winned cards for defence and attack, dealing with the fool

src/ai.rs

@@ -0,0 +1,82 @@
+use game;
+use deck;
+use card;
+
+// Each player looks at his game and termines if he takes or not, returns the taker's id
+pub fn auctions(players: &Vec<game::Player>) -> i32 {
+    let potentials: Vec<(i32, i32)> = players.iter()
+        .map(|ref player| (player.id, evaluate_hand_potential(&player.hand)))
+        .collect();
+    let &(taker_id, _) = match potentials.iter().max_by_key(|&&(id, _)| id) {
+        None => panic!("no players"),
+        Some(x) => x,
+    };
+    taker_id
+}
+
+pub fn evaluate_hand_potential(hand: &deck::Hand) -> i32 {
+    hand.iter().fold(0, |acc, card| acc + card::potential_value(card))
+}
+
+pub fn exchange_dog(mut players: &mut Vec<game::Player>,
+                    dog: &mut deck::Hand,
+                    game: &mut game::Game) {
+    let ref mut taker = match players.iter_mut().find(|player| player.id == game.taker_id) {
+        None => panic!("cannot find the taker"),
+        Some(player) => player,
+    };
+    // Now we proceed to exchange the cards in the dog
+    // We adopt a simple and naïve strategy
+    // We let the low cards in the dog and exchange useful for random low others
+    let mut new_dog: Vec<(card::Card, i32)> = Vec::new();
+    dog.clone()
+        .iter()
+        .fold((), |_, &card| {
+            let to_exchange = match card {
+                card::Card::Trump(_) => true,
+                card::Card::Face(card::Face { suit: _, symbol }) => {
+                    match symbol {
+                        card::Symbol::Jack | card::Symbol::Knight | card::Symbol::Queen |
+                        card::Symbol::King => true,
+                        _ => false,
+                    }
+                }
+                card::Card::Fool => true,
+            };
+            if to_exchange {
+                // Performs the exchange
+                dog.remove(&card);
+                new_dog.push((card, taker.id));
+            }
+        });
+    // We exchange the remaining cards with cards in the hand of the taker
+    dog.clone().iter().fold((), |_, &dog_card| {
+        let taker_hand = taker.hand.clone();
+        let exchange_card = taker_hand.iter().filter(|&&card| dog_card > card).next();
+        match exchange_card {
+            None => (),
+            Some(&exchange_card) => {
+                dog.remove(&dog_card);
+                taker.hand.insert(dog_card);
+                taker.hand.remove(&exchange_card);
+                new_dog.push((exchange_card, taker.id));
+            }
+        };
+    });
+    //Then for the remaining cards in the dog we simply transfer them to the new dog
+    dog.clone().iter().fold((), |_, &card| {
+        dog.remove(&card);
+        new_dog.push((card, taker.id));
+    });
+
+    // Finaly the new dog goes into the attack's heap
+    game.attack_heap.append(&mut new_dog);
+}
+
+// Select a card to play among the valid cards
+pub fn select_card(_: &game::Player, valid_cards: &deck::Hand, _: &game::Heap) -> card::Card {
+    match valid_cards.iter().next() {
+        None => panic!("no valid card to play"),
+        Some(card) => card.clone(),
+    }
+}

src/card.rs

@@ -210,3 +210,41 @@ impl Ord for Card {
         }
     }
 }
+
+pub fn potential_value(&card: &Card) -> i32 {
+    match card {
+        Card::Fool => 100,
+        Card::Trump(Trump::One) => 100,
+        Card::Trump(Trump::TwentyOne) => 100,
+        Card::Face(Face { suit: _, symbol: Symbol::Jack }) => 10,
+        Card::Face(Face { suit: _, symbol: Symbol::Knight }) => 20,
+        Card::Face(Face { suit: _, symbol: Symbol::Queen }) => 30,
+        Card::Face(Face { suit: _, symbol: Symbol::King }) => 40,
+        Card::Trump(trump) => {
+            10 +
+            match trump {
+                Trump::Two => 2,
+                Trump::Three => 3,
+                Trump::Four => 4,
+                Trump::Five => 5,
+                Trump::Six => 6,
+                Trump::Seven => 7,
+                Trump::Eight => 8,
+                Trump::Nine => 9,
+                Trump::Ten => 10,
+                Trump::Eleven => 11,
+                Trump::Twelve => 12,
+                Trump::Thirteen => 13,
+                Trump::Fourteen => 14,
+                Trump::Fifteen => 15,
+                Trump::Sixteen => 16,
+                Trump::Seventeen => 17,
+                Trump::Eighteen => 18,
+                Trump::Nineteen => 19,
+                Trump::Twenty => 20,
+                _ => 100,
+            }
+        }
+        _ => 0,
+    }
+}

src/game.rs

@@ -1,8 +1,9 @@
 use params;
 use deck;
 use card;
+use ai;
 
-type Heap = Vec<(card::Card, i32)>;
+pub type Heap = Vec<(card::Card, i32)>;
 
 #[derive(Clone)]
 pub struct Player {
@@ -11,6 +12,12 @@ pub struct Player {
     pub hand: deck::Hand,
 }
 
+pub struct Game {
+    pub taker_id: i32,
+    pub attack_heap: Heap,
+    pub defense_heap: Heap,
+}
+
 // 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() {}
@@ -35,33 +42,105 @@ pub fn initialize_players(hands: &mut Vec<deck::Hand>, names: &mut Vec<String>)
     players
 }
 
-pub fn start_game(_: &deck::Hand, mut players: &mut Vec<Player>) {
+pub fn start_game(mut dog: &mut deck::Hand, mut players: &mut Vec<Player>) {
     let cards_per_player = players[0].hand.len();
-    //Check if all players have same number of cards
+    // Check if all players have same number of cards
     for i in 1..params::NUMBER_OF_PLAYERS {
         if cards_per_player != players[i].hand.len() {
             panic!("the players don't have the same number of cards")
         }
     }
+
+    // Determine the attack and defense
+    let taker_id = ai::auctions(&players);
+    let mut game = Game {
+        taker_id: taker_id,
+        attack_heap: Vec::new(),
+        defense_heap: Vec::new(),
+    };
+    println!(">>>> {} prend le chien <<<<<",
+             match players.iter().find(|player| player.id == taker_id) {
+                 None => panic!("cannot find the player who won the round"),
+                 Some(player) => &player.name,
+             });
+
+    ai::exchange_dog(&mut players, &mut dog, &mut game);
+
     let mut starting_player_id = 0;
+    let mut fool_on_standby: Option<(card::Card, i32)> = None;
     println!("===== Début de la partie ! =====");
     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
+            // Each player plays a card
             play_card(player, &mut cards_played)
         }
         // Decide who has won
         starting_player_id = winning_player(&mut cards_played);
-        let last_card_played = match cards_played.first() {
-            None => panic!("no card played this round"),
-            Some(card) => card,
-        };
-        println!(">>>>> Le joueur {} remporte le pli avec la carte {} ! <<<<<",
-                 last_card_played.1,
-                 last_card_played.0);
+        {
+            // Printing winner
+            let last_card_played = match cards_played.first() {
+                None => panic!("no card played this round"),
+                Some(card) => card,
+            };
+            println!(">>>>> {} remporte le pli avec la carte {} ! <<<<<",
+                     match players.iter().find(|player| player.id == last_card_played.1) {
+                         None => panic!("cannot find the player who won the round"),
+                         Some(player) => &player.name,
+                     },
+                     last_card_played.0);
+        }
+
+        // Before giving cards to the winner's heap, must first apply special rule for the fool
+        match fool_on_standby {
+            None => (),
+            Some(fool) => {
+                // The player who played the fool couldn't exchange cards in a prior tour,
+                // trying now to do so
+                cards_played.push(fool)
+            }
+        }
+        fool_on_standby = deal_with_fool(&mut cards_played, &mut game, starting_player_id);
+
+        // Giving cards to the winner's heap
+        if starting_player_id == game.taker_id {
+            game.attack_heap.append(&mut cards_played);
+        } else {
+            game.defense_heap.append(&mut cards_played);
+        }
+    }
+    // End of game
+    match fool_on_standby {
+        None => (),
+        Some((fool, id)) => {
+            // The player never could exchange his fool, we return it to him
+            if id == game.taker_id {
+                game.attack_heap.push((fool, id));
+            } else {
+                game.defense_heap.push((fool, id));
+            }
+        }
+    }
+
+    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,
+                 });
     }
 }
 
@@ -79,10 +158,10 @@ fn sort_by_playing_order(mut players: &mut Vec<Player>, starting_player_id: i32)
 
 fn play_card(player: &mut Player, cards_played: &mut Heap) {
     let valid_cards = valid_cards(&player, cards_played);
-    let card = select_card(player, &valid_cards, cards_played);
+    let card = ai::select_card(player, &valid_cards, cards_played);
     player.hand.remove(&card);
     cards_played.push((card, player.id));
-    println!("Le joueur {} joue {}.", player.id, card);
+    println!("{} joue {}.", player.name, card);
 }
 
 fn valid_cards(player: &Player, cards_played: &Heap) -> deck::Hand {
@@ -186,7 +265,7 @@ fn valid_cards(player: &Player, cards_played: &Heap) -> deck::Hand {
     }
 }
 
-// Returns the max trump in a heap of played cards, panics if no trump
+// Returns the max trump in a heap of played cards
 fn max_trump(cards_played: &Heap) -> Option<card::Trump> {
     let mut max_trump: Option<card::Trump> = None;
     for &(card, _) in cards_played.iter() {
@@ -207,14 +286,6 @@ fn max_trump(cards_played: &Heap) -> Option<card::Trump> {
     max_trump
 }
 
-// Select a card to play among the valid cards
-fn select_card(_: &Player, valid_cards: &deck::Hand, _: &Heap) -> card::Card {
-    match valid_cards.iter().next() {
-        None => panic!("no valid card to play"),
-        Some(card) => card.clone(),
-    }
-}
-
 // Determine who won the round
 fn winning_player(cards: &mut Heap) -> i32 {
     cards.sort_by(|&(card1, _), &(card2, _)| card2.cmp(&card1));
@@ -223,3 +294,79 @@ fn winning_player(cards: &mut Heap) -> i32 {
         None => panic!("no cards have been played"),
     }
 }
+
+// Proceeds to exchange the fool against a lower card of the opponent's heap if necessary
+fn deal_with_fool(mut cards_played: &mut Heap,
+                  mut game: &mut Game,
+                  winning_player_id: i32)
+                  -> Option<(card::Card, i32)> {
+    let mut fool_index: Option<usize> = None;
+    let mut fool_on_standby: Option<(card::Card, i32)> = None;
+    for (index, &(card_played, _)) in cards_played.iter().enumerate() {
+        if card_played == card::Card::Fool {
+            fool_index = Some(index);
+            break;
+        }
+    }
+    match fool_index {
+        None => (),
+        Some(index) => {
+            let fool = cards_played.remove(index);
+            if fool.1 == game.taker_id && winning_player_id != game.taker_id {
+                // The attack played the fool and lost => exchange
+                let attack_copy = game.attack_heap.clone();
+                let card_to_exchange = attack_copy.iter()
+                    .enumerate()
+                    .filter(|&(_, &(card, _))| match card {
+                        card::Card::Trump(_) => false,
+                        card::Card::Face(card::Face { suit: _, symbol }) => {
+                            match symbol {
+                                card::Symbol::Jack | card::Symbol::Knight |
+                                card::Symbol::Queen | card::Symbol::King => false,
+                                _ => true,
+                            }
+                        }
+                        card::Card::Fool => false,
+                    })
+                    .next();
+                match card_to_exchange {
+                    Some((index, &card_to_exchange)) => {
+                        game.attack_heap.remove(index);
+                        game.defense_heap.push(card_to_exchange);
+                        game.attack_heap.push(fool);
+                    }
+                    None => fool_on_standby = Some(fool),
+                };
+            } else if fool.1 != game.taker_id && winning_player_id == game.taker_id {
+                // The defense played the fool and lost => exchange
+                let defense_copy = game.defense_heap.clone();
+                let card_to_exchange = defense_copy.iter()
+                    .enumerate()
+                    .filter(|&(_, &(card, _))| match card {
+                        card::Card::Trump(_) => false,
+                        card::Card::Face(card::Face { suit: _, symbol }) => {
+                            match symbol {
+                                card::Symbol::Jack | card::Symbol::Knight |
+                                card::Symbol::Queen | card::Symbol::King => false,
+                                _ => true,
+                            }
+                        }
+                        card::Card::Fool => false,
+                    })
+                    .next();
+                match card_to_exchange {
+                    Some((index, &card_to_exchange)) => {
+                        game.defense_heap.remove(index);
+                        game.attack_heap.push(card_to_exchange);
+                        game.defense_heap.push(fool);
+                    }
+                    None => fool_on_standby = Some(fool),
+                };
+            } else {
+                // Normal case, the fool shouldn't be exchanged
+                cards_played.insert(index, fool);
+            }
+        }
+    };
+    fool_on_standby
+}

src/main.rs

@@ -2,6 +2,7 @@ mod card;
 mod deck;
 mod params;
 mod game;
+mod ai;
 
 extern crate rand;
 
@@ -13,17 +14,17 @@ 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 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 player in players.iter() {
-        println!("-> Cartes du joueur {}:", player.id);
+        println!("-> Cartes du joueur {}:", player.name);
         for card in player.hand.iter() {
             println!("{}", card);
         }
     }
-    game::start_game(&dog, &mut players);
+    game::start_game(&mut dog, &mut players);
 }