cdez/CS396-Projects
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Finish assignment 6. This commit is pre-clean up. Next push will have cleaned up code.

Browse source
This commit is contained in:
Charles Descamps 2024-11-25 00:59:10 -07:00
parent 6cb5c48af1
commit 5bdbe09523
11 changed files with 211 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

240
assignmentSix/src/main.rs
View file

@ -223,11 +223,20 @@ impl Deck
self.card_deck.shuffle(&mut thread_rng());
return self;
}
fn draw(mut self) -> Card
fn draw(&mut self) -> Card
{
// return Card{cardRank: Rank::TWO, cardSuit: Suit::CLUBS};
let pull_card = self.card_deck.pop().unwrap();
return pull_card;
if !self.card_deck.is_empty()
{
// let pull_card = self.card_deck.pop().unwrap();
// println!("Num cards left: {}", self.card_deck.len());
return self.card_deck.pop().unwrap();
}
else
{
panic!("Card ran out somehow");
}
// return pull_card;
}
fn is_empty(&self) -> bool
{
@ -267,7 +276,7 @@ impl Player
// append the card vector to the player's hand.
self.player_hand.append(&mut card_vec);
}
fn has_rank(mut self, in_card_rank: Rank) -> Vec<Card>
fn has_rank(&mut self, in_card_rank: &Rank) -> Vec<Card>
{
// check to see if the rank matches any of the items in vector
// if they do match, remove from hand, place into temp vector,
@ -277,12 +286,12 @@ impl Player
loop
{
//
if self.player_hand.is_empty() || self.player_hand.len() > card_counter
if self.player_hand.is_empty() || self.player_hand.len() - 1 < card_counter
{
//
break;
}
if self.player_hand.get(card_counter).unwrap().card_rank == in_card_rank
if self.player_hand.get(card_counter).unwrap().card_rank == *in_card_rank
{
//
let current_card = Card
@ -350,11 +359,170 @@ impl Player
struct Game
{
// data
full_card_deck: Deck,
human_player: Player,
computer_player: Player,
human_score: u32,
computer_score: u32
}
impl Game
{
// methods
fn new() -> Game
{
let mut full_game = Game
{
full_card_deck: Deck::new(),
human_player: Player::new(),
computer_player: Player::new(),
human_score: 0,
computer_score: 0
};
// deal seven cards to each player.
let mut card_count = 0;
let mut human_cards_vec = vec![];
let mut computer_cards_vec = vec![];
loop
{
if card_count > 6
{
break;
}
// full_game.human_player.add_cards(full_game.full_card_deck.draw());
human_cards_vec.push(full_game.full_card_deck.draw());
computer_cards_vec.push(full_game.full_card_deck.draw());
card_count = card_count + 1;
}
full_game.human_player.add_cards(human_cards_vec);
full_game.computer_player.add_cards(computer_cards_vec);
return full_game;
}
fn human_turn(&mut self)
{
print!("Human's Turn: ");
for card in &*self.human_player.player_hand
{
print!("{} ", card);
}
println!("");
print!("Your turn. Enter a rank (2-10, A/1, J/11, Q/12, K/13): ");
let _=io::stdout().flush();
let mut rank_enter = String::new();
let mut rank_num: i32 = 0;
let mut rank_exit: Rank;
io::stdin().read_line(&mut rank_enter).expect("String wrong");
rank_num = rank_enter.trim().parse().unwrap();
rank_exit = number_to_rank(rank_num);
// check if the computer has the rank requested.
let mut temp_vec = self.computer_player.has_rank(&rank_exit);
if !temp_vec.is_empty()
{
println!("Computer has {}s.", rank_exit);
// add the cards from the temp_vec.
self.human_player.add_cards(temp_vec);
}
else
{
println!("Computer does not have {}s. Go fish.", rank_exit);
// draw a card.
let mut new_card_vec = vec![];
new_card_vec.push(self.full_card_deck.draw());
// self.human_player.player_hand.push(self.full_card_deck.draw());
self.human_player.add_cards(new_card_vec)
}
if self.human_player.check_set()
{
self.human_score = self.human_score + 1;
}
}
fn computer_turn(&mut self)
{
print!("Computer's Turn... ");
// unneeded
// for card in &*self.computer_player.player_hand
// {
// print!("{} ", card);
// }
println!("");
// substitute picking a rank here
// print!("Computer's turn. Enter a rank (2-10, A/1, J/11, Q/12, K/13): ");
// let _=io::stdout().flush();
// let mut rank_enter = String::new();
// let mut rank_num: i32 = 0;
// let mut rank_exit: Rank;
// io::stdin().read_line(&mut rank_enter).expect("String wrong");
// rank_num = rank_enter.trim().parse().unwrap();
// rank_exit = number_to_rank(rank_num);
// end substitute
let rank_pick = rand::thread_rng().gen_range(1..=13);
// check if the computer has the rank requested.
let mut temp_vec = self.human_player.has_rank(&number_to_rank(rank_pick));
if !temp_vec.is_empty()
{
//
println!("Human has {}s.", number_to_rank(rank_pick));
// add the cards from the temp_vec.
self.computer_player.add_cards(temp_vec);
}
else
{
//
println!("Human does not have {}s. Computer goes fish.", number_to_rank(rank_pick));
// draw a card.
let mut new_card_vec = vec![];
new_card_vec.push(self.full_card_deck.draw());
self.computer_player.add_cards(new_card_vec)
}
if self.computer_player.check_set()
{
//
self.computer_score = self.computer_score + 1;
}
}
fn play(&mut self)
{
//
loop
{
// CURRENTLY, cards run out somehow without ever actually checking?
if self.full_card_deck.card_deck.len() == 0
{
//
println!("Game Over.");
self.print_scores();
self.winner();
break;
}
self.human_turn();
self.computer_turn();
}
}
fn print_scores(&mut self)
{
//
println!("Human Score: {}", self.human_score);
println!("Computer Score: {}", self.computer_score);
}
fn winner(&mut self)
{
//
if self.human_score > self.computer_score
{
//
println!("Human Wins with a score of: {}", self.human_score);
}
else if self.human_score < self.computer_score
{
//
println!("Computer Wins with a score of: {}", self.computer_score);
}
else
{
//
println!("It's a tie!");
}
}
}
fn main()
@ -374,35 +542,35 @@ fn main()
// card_vec.push(Card{card_rank: Rank::NINE, card_suit: Suit::DIAMONDS});
// card_vec.push(Card{card_rank: Rank::FIVE, card_suit: Suit::CLUBS});
// card_vec.push(Card{card_rank: Rank::NINE, card_suit: Suit::SPADES});
let mut current_player = Player::new();
current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::HEARTS});
current_player.player_hand.push(Card{card_rank: Rank::THREE, card_suit: Suit::CLUBS});
current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::DIAMONDS});
current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::HEARTS});
current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::SPADES});
current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::CLUBS});
current_player.player_hand.push(Card{card_rank: Rank::ACE, card_suit: Suit::HEARTS});
current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::DIAMONDS});
current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::CLUBS});
current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::SPADES});
// let mut current_player = Player::new();
// current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::HEARTS});
// current_player.player_hand.push(Card{card_rank: Rank::THREE, card_suit: Suit::CLUBS});
// current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::DIAMONDS});
// current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::HEARTS});
// current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::SPADES});
// current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::CLUBS});
// current_player.player_hand.push(Card{card_rank: Rank::ACE, card_suit: Suit::HEARTS});
// current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::DIAMONDS});
// current_player.player_hand.push(Card{card_rank: Rank::FIVE, card_suit: Suit::CLUBS});
// current_player.player_hand.push(Card{card_rank: Rank::NINE, card_suit: Suit::SPADES});
// current_player.add_cards(card_vec);
for card in &current_player.player_hand
{
//
println!("After deal: {}", card);
}
current_player.check_set();
for card in &current_player.player_hand
{
//
println!("After set check: {}", card);
}
current_player.check_set();
for card in &current_player.player_hand
{
//
println!("After 2nd set check: {}", card);
}
// for card in &current_player.player_hand
// {
// //
// println!("After deal: {}", card);
// }
// current_player.check_set();
// for card in &current_player.player_hand
// {
// //
// println!("After set check: {}", card);
// }
// current_player.check_set();
// for card in &current_player.player_hand
// {
// //
// println!("After 2nd set check: {}", card);
// }
// println!("{}{}", Rank::TWO, Suit::DIAMONDS);
// let tempCard = Card
// {
@ -429,8 +597,8 @@ fn main()
// println!("Drawn Card: {}", tempDeck.draw()); // verified works.
// tempDeck = tempDeck.shuffle(); // verified works
// TEMP END
// let mut game = Game::new();
// game.play();
let mut game = Game::new();
game.play();
// game.print_scores();
// println!("The winner is: {}", game.winner());
}