def setUp(self):
self.hand = blackjack.Hand(blackjack.Deck())
self.dealer_hand = blackjack.DealerHand(blackjack.Deck())
self.example_hard_cards = [blackjack.Card(
13, 'Diamonds'), blackjack.Card(4, 'Clubs')]
self.example_soft_cards = [blackjack.Card(1, 'Hearts'),
blackjack.Card(6, 'Diamonds')]
self.example_blackjack_cards = [blackjack.Card(1, 'Spades'),
blackjack.Card(13, 'Hearts')]
def test_deck(self):
"""Check the deck class"""
deck = blackjack.Deck()
deck_2 = blackjack.Deck()
deck_2.shuffle()
self.assertIn("The deck has: ", str(deck))
self.assertNotEqual(deck, deck_2)
self.assertIn(" of ", str(deck.deal()))
return deck_2
def initiate_game():
dealer = blackjack.Player()
player1 = blackjack.Player()
player1.bank_roll = 500
deck = blackjack.Deck()
deck.shuffle(5)
player1.show_bank_roll()
player1.wager()
for i in range(2):
player1.hand.append(deck.cards.pop())
dealer.hand.append(deck.cards.pop())
player1.reorder()
dealer.reorder()
print("You were dealt...")
player1.show_hand()
player1.total()
print("\nThe dealer is showing...")
dealer.show_card()
player1.hit_or_stay(deck)
def test_unique_deck(self):
deck = blackjack.Deck(jokers=0)
print(deck)
player = blackjack.Player(100, deck)
print(player.hand)
print(deck)
self.assertEqual(len(deck.cards), 50)
def main():
card = namedtuple("card", "rank suit")
deck = blackjack.Deck()
deck.build_deck(card)
deck.shuffle()
dealer = blackjack.Hand("dealer", 80, 200)
player = blackjack.Hand("player", 80, 500)
width = 1500
height = 1500
pygame.init()
screen = pygame.display.set_mode((width, height))
hand_tuple = namedtuple("hand_tuple", "player dealer")
hands = hand_tuple(player=player, dealer=dealer)
pygame_tuple = namedtuple("pygame_tuple", "pygame screen")
PYGAME = pygame_tuple(pygame=pygame, screen=screen)
width_height = namedtuple("width_height", "width height")
DISPLAY = width_height(width=width, height=height)
colours = namedtuple("colours", "black green red yellow background")
COLOURS = colours(black=(0, 0, 0),
green=(0, 255, 0),
red=(255, 0, 0),
yellow=(255, 255, 0),
background=(152, 198, 195))
button = namedtuple("button", " x y width height colour text text_colour")
hit = button(x=80,
y=700,
width=100,
height=80,
colour=COLOURS.green,
text="hit",
text_colour=COLOURS.black)
stand = button(x=200,
y=700,
width=100,
height=80,
colour=COLOURS.yellow,
text="stand",
text_colour=COLOURS.black)
buttons = namedtuple("button", "hit stand")
BUTTONS = buttons(hit=hit, stand=stand)
game_loop(PYGAME, COLOURS, BUTTONS, DISPLAY, card, deck, hands)
def test_deal_and_reset_hands(self):
"""
Make sure deal() gives each player 2 cards and
that it removes 2 cards from the deck for each player.
Make sure reset_hands clears each players hands.
"""
# create 3 gamblers
players = []
total_players = 4
for i in range(total_players - 1):
gambler = bj.Gambler(f'Player {i+1}')
gambler.money = 500
players.append(gambler)
# create dealer
dealer = bj.Dealer()
players.append(dealer)
# create, shuffle, & deal deck
num_decks = 1
deck = bj.Deck(num_decks=num_decks)
deck.create()
deck.shuffle()
bj.deal(players, deck, test=True)
# check that each player got 2 cards
for i in range(total_players):
self.assertEqual(len(players[i].hands[0].cards), 2)
# check that Deck.deal() removed 2*num_players cards from deck
self.assertEqual(num_decks * 52 - total_players * 2, len(deck.cards))
# reset hands & check for accuracy
bj.reset_hands(players)
result = False
for p in players:
if p.hands:
result = True
self.assertFalse(result)
def __init__(self, strategy_name):
self.strategy_name = strategy_name
print("Player strategy:", self.strategy_name)
this_table = blackjack.Table(4, # 4 Decks in the shoe.
0.75) # Shoe replenished when 75% penetration reached.
# Force some test cards on to the front of the shoe.
this_table.shoe.cards = [("6♥", [6], "6")]
this_table.shoe.cards.append(("3♥", [3], "3"))
this_table.shoe.cards.append(("6♥", [6], "6"))
this_table.shoe.cards.append(("9♥", [9], "9"))
# Because more cards may be needed to play a game, add some normal cards to the end of the shoe.
new_deck = blackjack.Deck()
new_deck.shuffle()
this_table.shoe.cards = this_table.shoe.cards + new_deck.cards
if blackjack.verbose:
this_table.shoe.print()
this_table.play_one_round(self.strategy_name) # Play a game.
def setUp(self):
self.deck = blackjack.Deck()
self.hand = blackjack.Hand(self.deck)
self.card = blackjack.Card(12, 'Any suit')
def setUp(self):
'''
Create a deck object at the beginning of each test
'''
self.card_deck = blackjack.Deck()
import blackjack
deck = blackjack.Deck()
dealer = blackjack.Player(blackjack.deal_card(deck), blackjack.deal_card(deck))
# Processes a human player; dealer remains hidden
while True:
# Holds all player instances to be used as arguments for functions
player_pool = []
# Gets how many players are playing
number_of_players = input("How many people are playing? ")
if int(number_of_players) == 0:
print("Goodbye")
break
# Creates specified number of players and appends them to list
for number in range(int(number_of_players)):
player_pool.append(
blackjack.Player(blackjack.deal_card(deck),
blackjack.deal_card(deck)))
# For loop goes through the list of players and plays game for each
for i in range(len(player_pool)):
print("\nNow playing player " + str(i + 1))
blackjack.play_hand(player_pool[i], deck)
# Add in the dealer and play its turn
player_pool.append(dealer)
def test_shuffle_deck(self):
deck = blackjack.Deck(jokers=1)
desc = str(deck)
self.assertNotEqual(desc, str(deck.shuffle()))
def test_call_shuffle_on_deck(self, mock_random):
self.assertFalse(mock_random.shuffle.called)
blackjack.Deck()
self.assertTrue(mock_random.shuffle.called)
def test_create_deck_without_joker(self):
deck = blackjack.Deck(jokers=0)
self.assertEqual(52, len(deck.cards))
def setUp(self):
self.deck = blackjack.Deck()
def test_place_invalid_bet(self):
deck = blackjack.Deck(jokers=0)
player = blackjack.Player(100, deck)
self.assertRaises(ValueError, player.place_bet, 120)
def test_place_valid_bet(self):
deck = blackjack.Deck(jokers=0)
player = blackjack.Player(100, deck)
player.place_bet(12)
self.assertEqual(88, player.balance)
def test_player_cration(self):
deck = blackjack.Deck(jokers=0)
player = blackjack.Player(100, deck)
self.assertEqual(len(player.hand.cards), 2)
def test_create_empty_deck(self):
deck = blackjack.Deck(empty=True)
self.assertEqual([], deck.cards)
def setUp(self):
self.deck = blackjack.Deck()
self.dealer_hand = blackjack.DealerHand(blackjack.Deck())
async def play_game(channel, playing, new_game='n'):
while True:
# Print an opening statement
await channel.send(p.messages['blackjack'][0])
# Create & shuffle the deck, deal two cards to each player
deck = bj.Deck()
print(deck)
deck.shuffle()
player_hand = bj.Hand()
player_hand.add_card(deck.deal())
player_hand.add_card(deck.deal())
dealer_hand = bj.Hand()
dealer_hand.add_card(deck.deal())
dealer_hand.add_card(deck.deal())
# Set up the Player's chips
# if new_game != 'y':
if new_game != 's':
player_chips = bj.Chips()
# Prompt the Player for their bet
await take_bet(player_chips, channel) # function not working
# Show cards (but keep one dealer card hidden)
await show_some(player_hand, dealer_hand, channel)
while playing: # recall this variable from our hit_or_stand function
# Prompt for Player to Hit or Stand
playing = await hit_or_stand(deck, player_hand, channel)
# Show cards (but keep one dealer card hidden)
await show_some(player_hand, dealer_hand, channel)
# If player's hand exceeds 21, run player_busts() and break out of loop
if player_hand.value > 21:
await player_busts(player_hand, dealer_hand, player_chips,
channel)
break
# If Player hasn't busted, play Dealer's hand until Dealer reaches 17
if player_hand.value <= 21:
while dealer_hand.value < 17:
hit(deck, dealer_hand)
# Show all cards
await show_all(player_hand, dealer_hand, channel)
# Run different winning scenarios
if dealer_hand.value > 21:
await dealer_busts(player_hand, dealer_hand, player_chips,
channel)
elif dealer_hand.value > player_hand.value:
await dealer_wins(player_hand, dealer_hand, player_chips,
channel)
elif dealer_hand.value < player_hand.value:
await player_wins(player_hand, dealer_hand, player_chips,
channel)
else:
await push(player_hand, dealer_hand, player_chips, channel)
# Inform Player of their chips total
await channel.send(p.messages['blackjack'][1] +
str(player_chips.total))
print(p.messages['blackjack'][1], player_chips.total)
# Ask to play again
# new_game = input("would you like to play again? Enter 'y' or 'n'")
info = await ask_new_game(channel, p.messages['blackjack'][15])
playing = info[0]
new_game = info[1]