def play(self, hand_size=3):
"""Starts a card game between two players.
Args:
hand_size: An int representing the number of cards a player will draw.
"""
self.playing = True
while self.playing:
cards = Deck()
cards.shuffle_deck()
p1 = Player(input("\nPLAYER 1 NAME: "))
p2 = Player(input("\nPLAYER 2 NAME: "))
for _ in range(hand_size):
p1.draw_card(cards.deck)
p2.draw_card(cards.deck)
p1.sort_hand(cards.suits, cards.suit_cards)
p2.sort_hand(cards.suits, cards.suit_cards)
p1.score_hand(cards.suits, cards.suit_cards)
p2.score_hand(cards.suits, cards.suit_cards)
self.show_hands(p1, p2)
self.declare_winner(p1, p2)
play_again = input("\nPlay again? [y/N] ")
if not strtobool(play_again):
self.playing = False
def __init__(self):
"""Initialize."""
self.deck = Deck()
self.deck.shuffle()
self.player_hand = []
self.dealer_hand = []
self.player_bet = 0
self.player_money = 0
self.rounds_played = 0
def __init__(self, purse):
#store the new deck
self.game_deck = Deck()
#initialize player with a purse
self.Player = Player(purse)
#initialize computer player with a purse
self.Computer = Player(purse)
def __init__(self, players=None, num_rounds=9, verbose=True):
if not players:
players = [('AI1', PlayerType.Computer),
('AI1', PlayerType.Computer)]
self.verbose = verbose
self.players = []
for player in players:
name, type_ = player
self.players.append(Player(name, type_))
self.round = 1
self.num_rounds = num_rounds
self.deck = Deck()
self.top = None
self.first_player = 0
def __init__(self):
self.__deck = Deck()
self.__a_Team = []
self.__b_Team = []
# players 1-3 on team A
# players 4-6 on team B
self.__current_player_id = 1
self.__score = [0, 0]
# create players
for i in range(1, 4):
self.__a_Team.append(Player(i, i))
self.__b_Team.append(Player(i, i + 3))
# deal cards to players
i = 0
for card in self.__deck.get_cards():
if i < 3:
self.__a_Team[i].receive_card(card)
else:
self.__b_Team[i - 3].receive_card(card)
i = (i + 1) % 6
class blackjack_game:
def __init__(self, purse):
#store the new deck
self.game_deck = Deck()
#initialize player with a purse
self.Player = Player(purse)
#initialize computer player with a purse
self.Computer = Player(purse)
def play_game(self, user_ante):
"""
function used to implement game play.
"""
#flag indicating game has started
user_play = 1
while ((self.Player.get_purse() > 0) and
(self.Computer.get_purse() > 0)) and (user_play != 0):
#create deck
self.game_deck.create_deck()
#shuffle deck
self.game_deck.shuffle_deck()
#add bet before game start
self.Player.add_bet(user_ante)
self.Computer.add_bet(user_ante)
#deal first 2 card to player and computer
self.deal_hand_initial(self.Player)
self.deal_hand_initial(self.Computer)
print("Player: ")
self.Player.player_show_hand()
print("CPU: ")
self.Computer.player_show_hand()
#print current purse and ante
self.Player.player_stats()
self.Computer.player_stats()
#determine if we have a black jack winner
if self.blackjack_payout(self.Player, self.Computer) == True:
continue
user_raise = int(input("Player, how much do you want to raise?"))
#add ante to the current bet
self.Player.add_bet(user_raise)
self.Computer.add_bet(user_raise)
user_choice = int(input("Player, hit (1) or stay (0)?"))
while user_choice == 1:
self.Player.draw_card(self.game_deck.deal_card())
print("Player: ")
self.Player.player_show_hand()
user_choice = int(input("Player, hit (1) or stay (0)?"))
#cpu keeps drawing cards until hand score > 16
cpu_hand_score = self.calc_hand_score(self.Computer.get_hand())
while cpu_hand_score < 16:
#draw card
self.Computer.draw_card(self.game_deck.deal_card())
print("CPU: ")
self.Computer.player_show_hand()
#update hand score
cpu_hand_score = self.calc_hand_score(self.Computer.get_hand())
#calculate total value of hand
player_hand_score = self.calc_hand_score(self.Player.get_hand())
self.Player.set_hand_score(player_hand_score)
self.Computer.set_hand_score(cpu_hand_score)
#identify the winner of the round
self.calc_winner_round()
user_play = int(
input("Do you want to continue? 1 = Continue, 0 = Quit"))
def blackjack_payout(self, player, computer):
"""Calculates payout for player if the first 2 cards is 21."""
if self.determine_black_jack(player) == True:
if self.determine_black_jack(computer) == False:
#add the bet to the game
computer.add_bet(computer.get_current_bet() * 1.5)
#add computers bet to player
player.add_to_purse(computer.get_current_bet())
player.reset_bet()
computer.reset_bet()
player.reset_hand()
computer.reset_hand()
return True
else:
if self.determine_black_jack(computer) == True:
#add the bet to the game
player.add_bet(computer.get_current_bet() * 1.5)
#add players bet to computer
computer.add_to_purse(player.get_current_bet())
player.reset_bet()
computer.reset_bet()
player.reset_hand()
computer.reset_hand()
return True
def determine_black_jack(self, player):
"""determines if player or computer gets 21 with first 2 cards."""
return self.calc_hand_score(player.get_hand()) == 21
def deal_hand_initial(self, Player):
"""Deal the first 2 cards to the player."""
Player.set_hand(self.game_deck.deal_card())
Player.set_hand(self.game_deck.deal_card())
def calc_winner_round(self):
"""
Determine the winner for each round.
"""
player_score = self.Player.get_hand_score()
cpu_score = self.Computer.get_hand_score()
print("Player Hand: ", player_score)
print("CPU hand: ", cpu_score)
if player_score > 21:
print("Player 1 Loss: ", self.Player.get_current_bet())
#add to Players purse
self.Computer.add_to_purse(self.Player.get_current_bet())
elif cpu_score > 21:
print("Computer Loss: ", self.Player.get_current_bet())
#add to Players purse
self.Player.add_to_purse(self.Computer.get_current_bet())
#if player and cpu does not bankrupt
else:
if player_score > cpu_score:
print("Computer Loss: ", player_score, cpu_score,
self.Computer.get_current_bet())
#add to Players purse
self.Player.add_to_purse(self.Computer.get_current_bet())
else:
print("Player 1 Loss: ", player_score, cpu_score,
self.Player.get_current_bet())
#add to Players purse
self.Computer.add_to_purse(self.Player.get_current_bet())
#reset bet for new round
self.Player.reset_bet()
self.Computer.reset_bet()
#reset hand for new round
self.Player.reset_hand()
self.Computer.reset_hand()
def calc_hand_score(self, list_of_cards):
hand_score = 0
ace = " "
for card in list_of_cards:
#get value of card
current_card = card.get_card()[3]
#check if adding an ace makes the player bust
if current_card == 'A':
if hand_score + 11 < 22:
hand_score += 11
#skip everything else in the loop
continue
#this case looks at all face cards including A, A is treated as 1
if type(current_card) == str:
#convert K,Q,J,A
hand_score += self.facecard_to_int(current_card)
else:
hand_score += current_card
return hand_score
def facecard_to_int(self, current_card):
face_cards = {"K": 10, "Q": 10, "J": 10, "A": 1}
try:
#if K,Q,J or A
return face_cards.get(current_card)
except:
#if numeric card
return current_card
def setUp(self):
self.sample_deck = Deck()
class DeckTests(unittest.TestCase):
def setUp(self):
self.sample_deck = Deck()
def test_init(self):
self.assertIsInstance(self.sample_deck.cards, list)
self.assertEqual(len(self.sample_deck.cards), 52)
def test_repr(self):
self.assertEqual(repr(self.sample_deck), "Deck of 52 cards")
def test_iter(self):
self.assertTrue(iter(self.sample_deck))
def test_count(self):
self.assertEqual(self.sample_deck.count(), 52)
self.sample_deck.cards.pop()
self.assertEqual(self.sample_deck.count(), 51)
def test_deal_cards(self):
self.sample_deck._deal(10)
self.assertEqual(len(self.sample_deck.cards), 42)
self.assertEqual(len(self.sample_deck._new_hand), 10)
def test_deal_last(self):
self.sample_deck._deal(56)
self.assertEqual(len(self.sample_deck.cards), 0)
self.assertEqual(len(self.sample_deck._new_hand), 52)
def test_deal_no_cards(self):
self.sample_deck.cards.clear()
with self.assertRaises(ValueError):
self.sample_deck._deal(2)
def test_deal_card(self):
result = self.sample_deck.deal_card()
self.assertIsInstance(result, Card)
self.assertEqual(result, self.sample_deck._new_hand[0])
self.assertEqual(len(self.sample_deck.cards), 51)
self.assertEqual(len(self.sample_deck._new_hand), 1)
def test_deal_hand(self):
result = self.sample_deck.deal_hand(15)
self.assertIsInstance(result, list)
self.assertEqual(len(self.sample_deck.cards), 37)
self.assertEqual(len(self.sample_deck._new_hand), 15)
def test_shuffle_invalid(self):
"""shuffle raises a ValueError if the card deck is not full"""
self.sample_deck.cards.pop()
with self.assertRaises(ValueError):
self.sample_deck.shuffle()
def test_shuffle_valid(self):
"""shuffle shuffles a full deck in place"""
original = self.sample_deck.cards[:] #making a new copy b/c lists are mutable!
self.sample_deck.shuffle()
result = self.sample_deck.cards
self.assertEqual(len(result), 52)
self.assertFalse(original == result)
class BlackJack:
"""Play black jack."""
def __init__(self):
"""Initialize."""
self.deck = Deck()
self.deck.shuffle()
self.player_hand = []
self.dealer_hand = []
self.player_bet = 0
self.player_money = 0
self.rounds_played = 0
def checkDeck(self):
"""Check card amount in deck."""
if len(self.deck.cards) < 20:
self.deck.build()
self.deck.shuffle()
def roundBet(self):
"""Get bet for current round."""
while True:
if self.player_bet > 0 and self.player_bet < self.player_money:
return self.player_bet
else:
continue
def natural21(self, hand):
"""Check for a natural 21."""
self.hand = hand
if ((self.hand[0].rank == 14 or self.hand[1].rank == 14)
and (self.hand[0].rank in range(10, 14)
or self.hand[1].rank in range(10, 14))):
if self.dealer_hand != 21:
self.player_bet *= 1.5
self.endRound(self.player_hand)
def insurance(self, ins_bet):
"""Insure round per user input."""
self.ins_bet = ins_bet
if self.dealer_hand[1].rank in range(10, 14):
self.ins_bet *= 2
self.player_money -= self.player_bet
self.player_money += self.ins_bet
else:
self.player_money -= self.ins_bet
def splitPairs(self):
"""Split pairs."""
self.split_hand = []
self.split_bet = self.player_bet
self.split_hand.append(self.player_hand.pop())
self.split_hand.append(self.deck.drawCard())
self.player_hand.append(self.deck.drawCard())
def doubleDown(self):
self.player_bet += self.player_bet
def playerHit(self, hand):
"""Append cards to player's hand."""
self.hand = hand
self.hand.append(self.deck.drawCard())
def dealerHit(self):
while self.cardSum(self.dealer_hand) < 17:
self.dealer_hand.append(self.deck.drawCard())
def cardSum(self, hand):
"""Count card values in hand."""
self.hand = hand
self.card_total = 0
self.ace_total = 0
for c in self.hand:
if c.rank == 14:
self.card_total += 11
self.ace_total += 1
elif c.rank in range(10, 14):
self.card_total += 10
else:
self.card_total += c.rank
while self.card_total > 21 and self.ace_total > 0:
self.card_total -= 10
self.ace_total -= 1
return self.card_total
def startRound(self):
"""Deal cards at start of round."""
self.checkDeck()
self.player_hand.append(self.deck.drawCard())
self.player_hand.append(self.deck.drawCard())
self.dealer_hand.append(self.deck.drawCard())
self.dealer_hand.append(self.deck.drawCard())
def endRound(self, ehand):
"""End round."""
self.ehand = ehand
if (self.cardSum(self.ehand) <= 21) and (self.cardSum(self.dealer_hand)
> 21):
self.player_money += self.player_bet
elif (self.cardSum(self.ehand) > self.cardSum(
self.dealer_hand)) and (self.cardSum(self.ehand) <= 21):
self.player_money += self.player_bet
elif self.cardSum(self.ehand) == self.cardSum(self.dealer_hand):
pass
else:
self.player_money -= self.player_bet
class GolfGame:
def __init__(self, num_rounds_per_episode=10):
self.deck = Deck()
self.reset()
self.rounds_per_episode = num_rounds_per_episode
def reset(self):
self.round = -1
self.new_hand()
return self._get_state()
def new_hand(self):
self.deck.shuffle()
self.hand = self.deck.draw_n(6)
self.top_card = self.deck.draw()
self.mask = [0, 0, 0, 0, 0, 0]
flip = sample(range(0, 5), 2)
self.mask[flip[0]] = 1
self.mask[flip[1]] = 1
self.round += 1
def step(self, action):
initial_score = self._get_hand_score()
# Make sure we dont run out of cards
if len(self.deck.deck) == 0:
self.deck.shuffle()
if action == 0: # Put card back
self.top_card = self.deck.draw()
else: # Replace card
self.hand[action - 1] = self.top_card
self.mask[action - 1] = 1
next_state = self._get_state()
reward = initial_score - self._get_hand_score()
if all(self.mask): # Every card is flipped over, restart
self.new_hand()
done = (self.round >= self.rounds_per_episode)
return next_state, reward, done
def _get_state(self):
state = [self.top_card.value[1]]
for i, card in enumerate(self.hand):
if self.mask[i]:
state.append(card.value[1])
else:
state.append(-1)
return np.array(state)
def _get_hand_score(self):
hand_score = 0
if not self.hand:
return None
for column in range(3):
card1 = self.hand[column]
card2 = self.hand[3 + column]
if card1 != card2 and card1 != Card.Joker and card2 != Card.Joker:
hand_score += card1.value[0] + card2.value[0]
return hand_score
def __init__(self, channel):
self._channel = channel
self.deck = Deck()
self.dealt_this_phase = False
class Dealer():
def __init__(self, channel):
self._channel = channel
self.deck = Deck()
self.dealt_this_phase = False
#region game
async def deal_this_phase(self,
players,
state,
round_number,
community_cards=[]):
print('Dealing.')
#region deal
if state == 'deal':
# shuffle
self.deck.shuffle(grab_discard=True,
community_cards=community_cards)
await self._channel.send('Deck shuffled.', delete_after=120)
# alert players of dealing
await self._channel.send(
f'Round {round_number}: Dealing to players...',
delete_after=120)
# deal, add cards to player hands, and dm them their cards
for player in players:
cards = []
cards.append(self.deck.deal())
cards.append(self.deck.deal())
player.hand = cards
await self._channel.send(
f'Dealing cards to {player.user.display_name}...',
delete_after=120)
await player.user.send(
content=
f'{cards[0].suit}{cards[0].value} {cards[1].suit}{cards[1].value}'
)
print('Cards sent.')
# cleanup
self.dealt_this_phase = True
await self._channel.send('Dealt.', delete_after=120)
#endregion deal
#region flop
elif state == 'flop':
# alert players
await self._channel.send(
f'Round {round_number}: Revealing the flop...')
# deal
cards = []
self.deck.burn() # burn one
for i in range(0, 3):
card = self.deck.deal()
cards.append(card)
community_cards.append(card)
# reveal to players
await self._channel.send(' '.join(
[f'{card.suit}{card.value}' for card in community_cards]))
# cleanup
self.dealt_this_phase = True
return community_cards
#endregion flop
#region turn
elif state == 'turn':
await self._channel.send(
f'Round {round_number}: Revealing the turn...')
self.deck.burn()
card = self.deck.deal()
community_cards.append(card)
await self._channel.send(
f"{' '.join([card.suit + card.value for card in community_cards])}"
)
self.dealt_this_phase = True
return community_cards
#endregion turn
#region river
elif state == 'river':
await self._channel.send(
f'Round {round_number}: Revealing the river...')
self.deck.burn()
card = self.deck.deal()
community_cards.append(card)
await self._channel.send(
f"{' '.join([card.suit + card.value for card in community_cards])}"
)
self.dealt_this_phase = True
return community_cards
#endregion river
else:
return
def move_blinds(self, players):
small_index = 0
big_index = 0
end = len(players) - 1
for i in range(0, len(players)):
if players[i].is_small_blind:
small_index = i
players[i].is_small_blind = False
elif players[i].is_big_blind:
big_index = i
players[i].is_big_blind = False
if end == small_index:
small_index = 0
else:
small_index = small_index + 1
if end == big_index:
big_index = 0
else:
big_index = big_index + 1
players[small_index].is_small_blind = True
players[big_index].is_big_blind = True
#endregion game
#region messaging
async def send_betting_alert(self, next_bet, call, who_raised):
check = ''
if call == 0:
check = "> n!holdem check\n"
await self._channel.send(
f"It is your turn, {next_bet.user.display_name}", delete_after=60)
await self._channel.send(
f"Minimum bet to stay: ${call - next_bet.bet_this_round} ({who_raised} raised)\n"
+ "Your options are:\n" +
"> n!holdem bet [*a number (no dollar sign)*]\n" +
"> n!holdem call\n" + f"{check}" + "> n!holdem fold",
delete_after=60)
await next_bet.user.send(f"It is your turn, {next_bet.user.mention}")
async def send_betting_order(self, betting_order):
await self._channel.send('The betting order is currently:\n',
delete_after=45)
for player in betting_order:
blind = ''
if player.is_small_blind:
blind = ' (small blind)'
elif player.is_big_blind:
blind = ' (big blind)'
await self._channel.send(f'{player.user.display_name}{blind}',
delete_after=45)
async def send_call_message(self, player, call, num, pot):
await self._channel.send(
f'{player.user.display_name} called the ${call} bet with ${num}.\n'
+
f"The pot is now ${pot}. ${player.bet_this_round} of that is {player.user.display_name}'s money.\n"
+ f"*{player.user.display_name} has ${player.money} left.*")
async def send_card_reveal_messages(self):
pass
async def send_current_pot(self, pot):
await self._channel.send(f"Current pot is ${pot}.", delete_after=120)
async def send_money_message(self, player):
await self._channel.send(
f"{player.user.mention}, you have {player.money}.",
delete_after=45)
async def send_raise_message(self, player, call, num, pot):
await self._channel.send(
f"{player.user.display_name} raised the bet to ${call} with ${num}.\n"
+
f"The pot is now ${pot}. ${player.bet_this_round} of that is {player.user.display_name}'s money.\n"
+ f"{player.user.display_name} has ${player.money} left.")
def cards_for_tests():
cards = Deck()
return cards
class Game:
def __init__(self, players=None, num_rounds=9, verbose=True):
if not players:
players = [('AI1', PlayerType.Computer),
('AI1', PlayerType.Computer)]
self.verbose = verbose
self.players = []
for player in players:
name, type_ = player
self.players.append(Player(name, type_))
self.round = 1
self.num_rounds = num_rounds
self.deck = Deck()
self.top = None
self.first_player = 0
def run(self):
while self.round <= self.num_rounds:
if self.verbose:
print('Round {}\n'.format(self.round))
self._new_round()
# Flip over initial cards
for player in self.players:
player.flip_cards()
player.display_hand()
# Go around the table until someone flips all of their cards over
current_player = self.first_player
playing = True
while playing:
if self.verbose:
print('{}\'s Turn'.format(
self.players[current_player].name))
self.top = self.players[current_player].move(
self.deck, self.top, self.verbose)
if self.players[current_player].is_done():
playing = False
current_player = (current_player + 1) % len(self.players)
# When round is over, add hand score to player scores and increment starting player
for player in self.players:
player.score += player.get_hand_score()
self.first_player = (self.first_player + 1) % len(self.players)
self.round += 1
lowest_score = 10000
winner = ''
if self.verbose:
print('Final Hands: ')
for player in self.players:
player.mask = [1, 1, 1, 1, 1, 1]
if self.verbose:
print('Player: {}'.format(player.name))
player.display_hand()
if self.verbose:
print('Final Scores:')
avg_score = 0
for player in self.players:
if self.verbose:
print('\t {}: {}'.format(player.name, player.score))
avg_score += player.score
if player.score < lowest_score:
winner = player.name
lowest_score = player.score
elif player.score == lowest_score:
winner += ' and ' + player.name
if self.verbose:
print('The winner is... {}!'.format(winner))
avg_score /= (len(self.players) * self.num_rounds)
return avg_score
def _new_round(self):
self.deck.shuffle()
for player in self.players:
player.new_hand(self.deck.draw_n(6))
self.top = self.deck.draw()
class DeckTests(unittest.TestCase):
def setUp(self):
self.deck = Deck()
def test_init(self):
'''deck should have 52 cards'''
self.assertTrue(isinstance(self.deck.cards, list))
self.assertEqual(len(self.deck.cards), 52)
def test_repr(self):
"""repr should return a string in the form of 'deck of cards'"""
self.assertEqual(repr(self.deck), "Deck of 52 cards")
def test_count(self):
"""count should return a count of the number of cards"""
self.assertEqual(self.deck.count(), 52)
self.deck.cards.pop()
self.assertEqual(self.deck.count(), 51)
def test_deal_sufficient_cards(self):
"""deal should deal the number of cards specified"""
cards = self.deck._deal(10)
self.assertEqual(len(cards), 10)
self.assertEqual(self.deck.count(), 42)
def test_deal_insufficient_cards(self):
cards = self.deck._deal(100)
self.assertEqual(len(cards), 52)
self.assertEqual(self.deck.count(), 0)
def test_deal_no_cards(self):
self.deck._deal(self.deck.count())
with self.assertRaises(ValueError):
self.deck._deal(1)
def test_deal_card(self):
card = self.deck.cards[-1]
dealt_card = self.deck.deal_card()
self.assertEqual(card, dealt_card)
self.assertEqual(self.deck.count(), 51)
def test_deal_hand(self):
cards = self.deck.deal_hand(20)
self.assertEqual(len(cards),20)
self.assertEqual(self.deck.count(),32)
def test_shuffle_full_deck(self):
cards = self.deck.cards[:]
self.deck.shuffle()
self.assertNotEqual(cards, self.deck.cards)
self.assertEqual(self.deck.count(), 52)
def test_shuffle_not_full_deck(self):
self.deck._deal(1)
with self.assertRaises(ValueError):
self.deck.shuffle()
class TestingDeckClass(unittest.TestCase):
def setUp(self):
self.deck = Deck()
def test_init(self):
"""decks should have a cards attibute which is a list"""
self.assertTrue(isinstance(self.deck.cards, list))
self.assertEqual(len(self.deck.cards), 52)
def test_deck_repr(self):
"""Test that repr returns a deck of 52 cards when first initialized, no more no less"""
self.assertEqual(str(self.deck), "Deck of 52 cards")
def test_count(self):
""" count should return a count of the number of cards"""
self.assertEqual(self.deck.count(), 52)
self.deck.cards.pop()
self.assertEqual(self.deck.count(), 51)
def test_deal_sufficient_cards(self):
"""_deal should deal the number of cards specified"""
cards = self.deck._deal(10)
self.assertEqual(len(cards), 10)
self.assertEqual(self.deck.count(), 42)
def test_deal_insufficient_cards(self):
"""_deal should deal the number of cards left in the deck"""
cards = self.deck._deal(100)
self.assertEqual(len(cards), 52)
self.assertEqual(self.deck.count(), 0)
def test_deal_no_cards(self):
"""_deal should throw a ValueError if the deck is empty"""
self.deck._deal(self.deck.count())
with self.assertRaises(ValueError):
self.deck._deal(1)
def test_deal_card(self):
""" deal_card whould deal a single card from the deck"""
card = self.deck.cards[-1]
dealt_card = self.deck.deal_card()
self.assertEqual(card, dealt_card)
self.assertEqual(self.deck.count(), 51)
def test_deal_hand(self):
"""deal_hand should deal the number of cards passed"""
cards = self.deck.deal_hand(20)
self.assertEqual(len(cards), 20)
self.assertEqual(self.deck.count(), 32)
def test_shuffle_full_deck(self):
"""shuffle should shuffle the deck if the deck is full"""
cards = self.deck.cards[:]
self.deck.shuffle()
self.assertNotEqual(cards, self.deck.cards)
self.assertEqual(self.deck.count(), 52)
def test_shuffle_not_full_deck(self):
"""shuffle should throw a ValueError if the deck isn't full"""
self.deck._deal(1)
with self.assertRaises(ValueError):
self.deck.shuffle()
def setUp(self):
self.deck = Deck()
def run():
print(
"Welcome to Blackjack! Get as close to 21 as you can without going bust! Dealer hits until they reach 17 or over. Aces count as 1 or 11 depending on your current hand value.\n"
)
player_chips = Chips(
) # Initialise player's chip pool. It is outside of the main loop so it carries between hands
while True:
playing = True # used for the player's turn
card_deck = Deck()
card_deck.shuffle_deck() # setting up the deck
betting = input("Player, would you like to bet on this round? (y/n) "
) # asks if the player wants to bet
if betting == "y":
set_up_bet(player_chips)
# intialising the player's and dealer's hands
player = Hand()
dealer = Hand()
deal_cards(player, dealer, card_deck)
# player's turn; the loop will continue until the player stands or goes bust
while playing:
show_some_cards(player, dealer)
# runs if the player is bust
if player.total_card_value > 21:
player_busts(player_chips)
break
playing = hit_or_stand(
player, card_deck) # asks if the player wants to hit or stand
if player.total_card_value <= 21:
# the dealer hits until their hand value is greater than 17
while dealer.total_card_value < 17:
hit(dealer, card_deck)
show_cards(player, dealer) # shows players and dealers cards
# checks the outcome of the game and calls the respective method (which sorts the bet outcome if there was one)
if dealer.total_card_value > 21:
dealer_busts(player_chips)
elif dealer.total_card_value > player.total_card_value:
dealer_wins(player_chips)
elif dealer.total_card_value < player.total_card_value:
player_wins(player_chips)
else:
print("Dealer and Player tie! It's a push.")
# checks if the player wants to play another hand
play_again = input("\nWould you like to play another hand? y/n: ")
if play_again.lower() == "y":
playing = True
print("\n" * 100)
else:
print("Thanks for playing! You have left the table with {} chips.".
format(player_chips.chips_pool))
break
def __init__(self, num_rounds_per_episode=10):
self.deck = Deck()
self.reset()
self.rounds_per_episode = num_rounds_per_episode
class Game:
def __init__(self):
self.__deck = Deck()
self.__a_Team = []
self.__b_Team = []
# players 1-3 on team A
# players 4-6 on team B
self.__current_player_id = 1
self.__score = [0, 0]
# create players
for i in range(1, 4):
self.__a_Team.append(Player(i, i))
self.__b_Team.append(Player(i, i + 3))
# deal cards to players
i = 0
for card in self.__deck.get_cards():
if i < 3:
self.__a_Team[i].receive_card(card)
else:
self.__b_Team[i - 3].receive_card(card)
i = (i + 1) % 6
# ----------------------------------------------------------------
# Here we return the requested player object, defaulting to the
# current player if none specified
def get_player(self, player_id=None):
if player_id is None or player_id not in range(1, 7):
player_id = self.__current_player_id
if player_id < 4:
return self.__a_Team[player_id - 1]
else:
return self.__b_Team[player_id - 4]
# ----------------------------------------------------------------
# return the id of the current player
def get_current_player_id(self):
return self.__current_player_id
# ----------------------------------------------------------------
# set a new current player
def set_current_player(self, player_id):
if player_id > 0 and player_id < 7:
self.__current_player_id = player_id
# ----------------------------------------------------------------
# This facilitates the current player asking for a card.
# If the askee has the card, they lose said card
# and the current player gets another turn.
# Else, the current player loses there turn and
# the askee is the new current player.
def player_inquiry(self, askee_id, suit, number):
card = Card(suit, number)
asker = self.get_player()
askee = self.get_player(askee_id)
message = ""
success = True
if askee.has_card(card):
askee.lose_card(card)
asker.receive_card(card)
# if the player has a completed suit, said player declares
if asker.can_declare():
self.__current_player_declares()
message = 'You recieved the %s' % (card.get_verbose_name())
else:
self.set_current_player(askee_id)
message = 'This player does not have the %s. You lose your turn.' % (
card.get_verbose_name())
# return message indicates success or failure
return json.dumps({'success': success, 'message': message})
# ----------------------------------------------------------------
# the current player declares a suit
def __current_player_declares(self):
player = self.get_player()
declaration = player.declare()
self.__score[0 if self.__current_player_id < 4 else 1] += (
declaration[1] + 1)
# ----------------------------------------------------------------
# return the status of the game as json
def get_json(self):
game_over = (self.__score[0] + self.__score[1]) == 12
current_team = 0 if self.__current_player_id < 4 else 1
return json.dumps({
'current_player': self.get_player().get_info(),
'current_team': current_team,
'score': self.__score,
'game_over': game_over
})
# --------------------------------------------------------------------
# ---------------- end class Game ------------------------------------
# --------------------------------------------------------------------
