refactor: Implement main game loop

Deal cards outside of user object decleration

src/main.rs

@@ -1,5 +1,5 @@
 use rand::prelude::*;
-use std::{io, thread::current, vec};
+use std::{io, vec};
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
 enum CardSuit {
@@ -15,21 +15,13 @@ struct Card {
     suit: CardSuit,
 }
 
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Clone, Copy)]
 enum PlayerType {
     Human,
     Cpu,
 }
 
-enum PlayerActions {
-    Fold,
-    Bet,
-    Call,
-    Raise,
-    Check,
-}
-
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Clone)]
 struct Player {
     name: String,
     player_type: PlayerType,
@@ -37,7 +29,7 @@ struct Player {
     cards: Vec<Card>,
 }
 
-fn convert_number(card_number: i32) -> String {
+fn convert_number(card_number: &i32) -> String {
     match card_number {
         9 => String::from("Jack"),
         10 => String::from("Queen"),
@@ -82,15 +74,20 @@ fn generate_card(seen_cards: &mut Vec<Card>) -> Card {
     }
 }
 
-fn action_fold(mut player: &mut Player) {
+fn display_card(card: &Card) {
+    println!("{} of {:#?}", convert_number(&card.number), card.suit);
+}
+
+fn action_fold(player: &mut Player) {
     player.cards.clear();
     println!("{name} Folds their turn", name = player.name);
 }
 
-fn action_bet(mut player: &mut Player, mut pool: &mut i32, mut current_bet: &mut i32) {
+fn action_bet(player: &mut Player, pool: &mut i32, current_bet: &mut i32) {
     let mut rng = rand::rng();
     let amount: i32 = match player.player_type {
         PlayerType::Human => {
+            println!("You have {} chips", player.score);
             println!("Enter your bet amount: ");
             read_int()
         }
@@ -106,77 +103,119 @@ fn action_bet(mut player: &mut Player, mut pool: &mut i32, mut current_bet: &mut
 
 fn main() {
     let mut rng = rand::rng();
-    let mut seen_cards: Vec<Card> = Vec::new();
-    let mut pool = 0;
+    let mut community_cards: [Option<Card>; 6] = [None; 6];
+    let mut pot = 0;
 
     let mut user = Player {
         name: String::from("sortedcord"),
         player_type: PlayerType::Human,
         score: 50,
-        cards: vec![
-            generate_card(&mut seen_cards),
-            generate_card(&mut seen_cards),
-        ],
+        cards: vec![],
     };
 
     let mut cpu: Player = Player {
         name: String::from("computer"),
         player_type: PlayerType::Cpu,
         score: 50,
-        cards: vec![
-            generate_card(&mut seen_cards),
-            generate_card(&mut seen_cards),
-        ],
+        cards: vec![],
     };
 
-    let big_blind: &Player = [&user, &cpu].choose(&mut rng).unwrap();
-    println!("Selected bigblind as {name} ", name = big_blind.name);
+    // Round starts
+    loop {
+        let mut seen_cards: Vec<Card> = Vec::new();
 
-    // Put money in the pot
-    if *big_blind == user {
-        let bet = rng.random_range(25..=45);
-        pool += bet;
-        cpu.score -= pool;
+        //Blind selection
+        let big_blind: &Player = [&user, &cpu].choose(&mut rng).unwrap();
+        println!("Selected bigblind as {name} ", name = big_blind.name);
 
-        println!("CPU bet {pool} ");
+        // Put money in the pot
+        if *big_blind == user {
+            let bet = rng.random_range(25..=45);
+            pot += bet;
+            cpu.score -= pot;
 
-        pool = loop {
-            println!("Enter your big blind: ");
+            println!("CPU bet {pot} ");
+
+            pot = loop {
+                println!("Enter your big blind: ");
+                let bet: i32 = read_int();
+
+                if bet > user.score {
+                    println!("Needs to be less or equal to your current holdings, try again!");
+                    continue;
+                }
+
+                if bet <= pot {
+                    println!("Needs to be greater than the small blind");
+                    continue;
+                }
+
+                user.score -= bet;
+                pot += bet;
+                break pot;
+            };
+        } else {
+            println!("Enter your small blind: ");
             let bet: i32 = read_int();
-
-            if bet > user.score {
-                println!("Needs to be less or equal to your current holdings, try again!");
-                continue;
-            }
-
-            if bet <= pool {
-                println!("Needs to be greater than the small blind");
-                continue;
-            }
-
             user.score -= bet;
-            pool += bet;
-            break pool;
+            pot += bet;
+            let bet = rng.random_range(pot..=50);
+            println!("CPU sets big blind as: {bet}");
+            cpu.score -= bet;
+            pot += bet;
+        }
+
+        println!("Pool size is now: {pot}");
+
+        // Deal hole cards
+        for player in [&mut user, &mut cpu] {
+            player.cards.push(generate_card(&mut seen_cards));
+        }
+
+        println!("Your Hand: ");
+
+        for card in &user.cards {
+            display_card(card);
+        }
+
+        // Start preflop betting round
+        let mut current_bet = 0;
+        loop {
+            println!("Enter the action (bet, fold): ");
+            let mut user_action = String::new();
+            io::stdin()
+                .read_line(&mut user_action)
+                .expect("Wrong input");
+
+            match user_action.trim() {
+                "bet" => action_bet(&mut user, &mut pot, &mut current_bet),
+                "fold" => action_fold(&mut user),
+                _ => {
+                    println!("Not a valid action, try again");
+                    continue;
+                }
+            };
+
+            break;
+        }
+
+        // CPU plays
+        let cpu_action = ["bet", "fold"].choose(&mut rng).unwrap();
+
+        match *cpu_action {
+            "bet" => action_bet(&mut cpu, &mut pot, &mut current_bet),
+            "fold" => action_fold(&mut cpu),
+            _ => panic!("CPU performed invalid action"),
         };
-    } else {
-        println!("Enter your small blind: ");
-        let bet: i32 = read_int();
-        user.score -= bet;
-        pool += bet;
-        let bet = rng.random_range(pool..=50);
-        println!("CPU sets big blind as: {bet}");
-        cpu.score -= bet;
-        pool += bet;
+
+        //Dealer reveal the cards
+        //
+        println!("Dealer dealt: ");
+
+        for slot in community_cards[..3].iter_mut() {
+            let n_card = generate_card(&mut seen_cards);
+            display_card(&n_card);
+            *slot = Some(n_card);
+        }
     }
-
-    println!("Pool size is now: {pool}");
-
-    println!("Your Hand: ");
-
-    for card in user.cards {
-        println!("{} of {:#?}", convert_number(card.number), card.suit);
-    }
-
-    // Start preflop betting round
-    let mut current_bet = 0;
 }