cards/lib/src/game_master.rs

// use anyhow::Result;
// use rand::prelude::IteratorRandom;
// use rand::thread_rng;
//
// use crate::models::*;
//
// impl Game {
//     /// Build game decks from input data for game start.
//     /// This should only run once and at startup.
//     fn _build_decks(&mut self, cards_json: Vec<CardSet>) -> Result<()> {
//         for pack in cards_json {
//             if let Some(white) = pack.white {
//                 self.white.extend(white)
//             }
//             if let Some(black) = pack.black {
//                 self.black.extend(black)
//             }
//         }
//
//         Ok(())
//     }
//
//     pub fn new(request: NewGameRequest) -> Result<Self> {
//         let mut game = Game {
//             ..Default::default()
//         };
//         tracing::debug!("Creating game {}", &request.name);
//         game.name = request.name;
//
//         // game.build_decks(request.packs)?;
//         game.create_player(request.host)?;
//         game.deal_black()?;
//
//         Ok(game)
//     }
//
//     // pub fn join(request:GameJoinRequest)
//
//     /// Log counts of current drawable cards
//     /// For testing
//     pub fn deck_counts(&self) {
//         tracing::debug!(
//             "Deck Counts:\n {} White cards\n {} Black cards",
//             self.white.len(),
//             self.black.len()
//         );
//     }
//
//     /// Draw one white card at random from play deck.
//     fn draw_one_white(&mut self) -> Result<CardWhite> {
//         let deck = &mut self.white;
//
//         // this feels sloppy
//         if let Some(index) = (0..deck.len()).choose(&mut thread_rng()) {
//             Ok(deck.swap_remove(index))
//         } else {
//             Ok(CardWhite {
//                 text: "Error.\n\nbtw if you see this tell me I'm lazy :)".to_string(),
//                 pack: 0,
//             })
//         }
//     }
//
//     /// Draw one black card at random from play deck.
//     fn draw_one_black(&mut self) -> Result<CardBlack> {
//         let deck = &mut self.black;
//
//         // this feels sloppy
//         if let Some(index) = (0..deck.len()).choose(&mut thread_rng()) {
//             Ok(deck.swap_remove(index))
//         } else {
//             Ok(CardBlack {
//                 text: "Error.\n\nbtw if you see this tell me I'm lazy :)".to_string(),
//                 pick: 0,
//                 pack: 0,
//             })
//         }
//     }
//
//     /// Deal a black card and use it for the current round
//     fn deal_black(&mut self) -> Result<()> {
//         self.current_black = Some(self.draw_one_black()?);
//
//         Ok(())
//     }
//
//     /// Create a new player and add them to the game.
//     pub fn create_player(&mut self, mut player: Player) -> Result<()> {
//         tracing::debug!("Creating player {} as {:?}", &player.name, &player.role);
//
//         let mut hand_buf = vec![];
//         for _ in 0..10 {
//             hand_buf.push(self.draw_one_white()?);
//         }
//         tracing::debug!("Dealing hand to {}", &player.name);
//         player.white.extend(hand_buf);
//
//         self.players.push(player);
//
//         Ok(())
//     }
//
//     pub fn game_start(&mut self) -> Result<()> {
//         self.game_active = true;
//         tracing::debug!("Game Active!");
//
//         if let Some(black) = &self.current_black {
//             tracing::debug!("{}", black.text);
//         } else {
//             tracing::debug!("YOU DONE FUCKED UP (no current black card)");
//         }
//
//         Ok(())
//     }
// }