def test_if_splits():
# Test if we can split each duplicate hand
for card in cards:
temp = Hand()
temp.add(Card(card))
temp.add(Card(card))
assert temp.can_be_split()
def __init__(self, balance, name=None, strategy=no_strategy):
self.hand = Hand()
self.starting_balance = balance
self.balance = balance
self.name = name
self.strategy = strategy
self.score = 0
self.dealer_card = None
def __init__(self,
starting_chips=1000,
number_decks=6,
percent_to_use=0.8):
self.player_chips = starting_chips
self.shoe = Shoe(number_decks=number_decks,
percent_to_use=percent_to_use)
self.player_hand = Hand()
self.dealer_hand = Hand()
def deal(self, bet):
if bet > self.player_chips:
raise Exception(f'Insufficient chips to place bet of {bet} chips.')
self.player_hand = Hand(bet=bet)
self.dealer_hand = Hand()
self.player_hand.add_card(self.shoe.deal_card())
self.dealer_hand.add_card(self.shoe.deal_card())
self.player_hand.add_card(self.shoe.deal_card())
self.dealer_hand.add_card(self.shoe.deal_card())
def deal_start_cards(game_deck):
"""
Deals the starting cards for the game.
Sets the global HAND list for both dealer and player.
Dealer's HAND has a hidden card at the start.
:param game_deck: the current game deck
:type game_deck: a list of Card objects
"""
global HAND
HAND = Hand([game_deck.pop(), game_deck.pop()], hidden=True)
player.HAND = Hand([game_deck.pop(), game_deck.pop()])
def reveal_cards():
"""
Recreates the dealer's cards so that the first is no longer hidden.
"""
global HAND
HAND = Hand(HAND.cards)
def test_soft_hand():
hand = Hand([
Card('A', 'H'),
Card('5', 'D'),
])
assert_equal(hand.value, 16)
assert_true(hand.soft)
assert_false(hand.blackjack)
def test_blackjack():
hand = Hand([
Card('A', 'H'),
Card('Q', 'D'),
])
assert_equal(hand.value, 21)
assert_true(hand.soft)
assert_true(hand.blackjack)
def test_hard_hand():
hand = Hand([
Card('7', 'H'),
Card('2', 'D'),
Card('K', 'S'),
])
assert_equal(hand.value, 19)
assert_false(hand.soft)
assert_false(hand.blackjack)
def test_hand_manipulation_methods(self):
p = Player("Ivan")
self.assertEqual(p.hand, None)
hand = Hand()
p.give_cards(hand)
self.assertEqual(p.hand, hand)
p.game_over()
self.assertEqual(p.hand, None)
def test_values_return_possible_hand_values(self):
h = Hand()
h.add((10, Deck.CLUBS))
h.add((Deck.ACE, Deck.CLUBS))
values = h.values()
values.sort()
self.assertEqual(values, [11, 21])
def test_bet_strategy_streak_mixed_streak(self):
streak_rates = {-2: 2, -1: 1, 0: 1, 1: 2, 2: 3}
settings = {
'game_settings': BetStrategyTest.game_settings,
'strategy_type': BetStrategyType.STREAK,
'streak_rates': streak_rates
}
strategy = BetStrategy(settings)
strategy.last_hand = Hand()
strategy.last_hand.result = HandResult.LOSE
streak_count = 2
for _ in range(streak_count):
strategy.last_hand = Hand()
strategy.last_hand.result = HandResult.WIN
self.assertEqual(BetStrategyTest.game_settings.min_bet * streak_rates[streak_count], strategy.bet())
def test_hand_string_representation(self):
h = Hand()
h.add((2, Deck.CLUBS))
h.add((Deck.ACE, Deck.CLUBS))
self.assertEqual(f"A{Deck.CLUBS} 2{Deck.CLUBS}", str(h))
def test_bet_strategy_series_reset_on_lose(self):
settings = {
'game_settings': BetStrategyTest.game_settings,
'strategy_type': BetStrategyType.SERIES,
'series': [1, 2, 3]
}
strategy = BetStrategy(settings)
strategy.last_hand = Hand()
strategy.last_hand.result = HandResult.LOSE
self.assertEqual(BetStrategyTest.game_settings.min_bet, strategy.bet())
def test_bet_strategy_parlay(self):
settings = {
'game_settings': BetStrategyTest.game_settings,
'strategy_type': BetStrategyType.PARLAY
}
strategy = BetStrategy(settings)
self.assertEqual(BetStrategyTest.game_settings.min_bet, strategy.bet())
strategy.last_hand = Hand()
strategy.last_hand.result = HandResult.WIN
strategy.last_hand.winnings = BetStrategyTest.game_settings.min_bet
self.assertEqual(BetStrategyTest.game_settings.min_bet * 2, strategy.bet())
class Player(metaclass=abc.ABCMeta):
"""
Base class for all players
"""
default_bet = 1
def __init__(self, balance, name=None, strategy=no_strategy):
self.hand = Hand()
self.starting_balance = balance
self.balance = balance
self.name = name
self.strategy = strategy
self.score = 0
self.dealer_card = None
def __str__(self):
if self.name:
return self.name
return self.__class__.__name__
@abc.abstractmethod
def will_hit(self):
pass
def on_card_dealt(self, card, is_dealer):
if is_dealer:
self.dealer_card = card
self.score += self.strategy.get_count(card)
def on_shuffle(self):
self.score = 0
def get_bet(self):
return self.strategy.get_bet(self.score)
def has_natural(self):
return self.hand.get_score() == 21
def pay(self, player, bet):
logger.info('[BET] {0} gave {1} chips to {2}.'.format(
self, bet, player))
self.balance -= bet
player.balance += bet
def reset(self):
self.hand = Hand()
def reset_balance(self):
self.balance = self.starting_balance
def test_bet_strategy_martingale(self):
settings = {
'game_settings': BetStrategyTest.game_settings,
'strategy_type': BetStrategyType.MARTINGALE
}
strategy = BetStrategy(settings)
self.assertEqual(BetStrategyTest.game_settings.min_bet, strategy.bet())
strategy.last_hand = Hand()
strategy.last_hand.result = HandResult.PUSH
self.assertEqual(BetStrategyTest.game_settings.min_bet, strategy.bet())
strategy.last_hand.result = HandResult.LOSE
self.assertEqual(BetStrategyTest.game_settings.min_bet * 2, strategy.bet())
def new_hand(self, bet=None):
hand_number = len(self.hands) + 1
if self.bankroll < self.game_settings.min_bet:
return None
if not self.dealer:
if not bet:
bet = self.bet_strategy.bet()
self.bankroll -= bet
hand = Hand(bet=bet, number=hand_number)
self.hands.append(hand)
return hand
def test_bet_strategy_series(self):
settings = {
'game_settings': BetStrategyTest.game_settings,
'strategy_type': BetStrategyType.SERIES
}
strategy = BetStrategy(settings)
with self.assertRaises(ValueError):
strategy.bet()
settings['series'] = [1, 2, 3]
strategy = BetStrategy(settings)
for multiplier in settings['series']:
self.assertEqual(BetStrategyTest.game_settings.min_bet * multiplier, strategy.bet())
strategy.last_hand = Hand()
strategy.last_hand.result = HandResult.WIN
self.assertEqual(BetStrategyTest.game_settings.min_bet, strategy.bet())
def start(self, deck=None):
if self.winner != None:
raise RuntimeError("Game is over")
enough_money = True
for p in self.players:
enough_money = p.has_enough_money(self.stake)
if not enough_money:
raise RuntimeError("One of the players does not have enought money to make a stake!")
for p in self.players:
p.make_stake(self.stake)
p.give_cards(Hand())
self.bank += self.stake
if deck == None:
self.deck = Deck()
self.deck.shuffle()
else:
self.deck = deck
for _ in range(0, 2):
for p in self.players:
p.hand.add(self.deck.pop())
def test_empty_hand():
temp = Hand()
assert temp.list() == "[]"
assert temp.value() == 0
def build_hand(hand_type):
hand = Hand()
for card in HANDS[hand_type]['cards']:
hand.deal(card)
return hand
def play_blackjack(chips=Account('Chris', 500)):
"""
Play BlackJack
:param chips: object
:return:
"""
# request a name be entered if one isn't present
while not len(chips.name):
try:
named = input('What\'s your name? ')
if named.isalpha():
chips.name = named
break
else:
print(
f"{named} is not a valid name, please enter a valid name")
continue
except:
print(
'Sorry something went wrong, please try and input your name again'
)
continue
# Add fund to account if none is present
if not chips.has_funds():
chips.add_funds()
# Add bet if none has been placed
while not chips.has_bet():
chips.make_bet()
# Build deck and shuffle
deck = Deck()
deck.shuffle()
deal_count = 1
player = Hand()
dealer = Hand()
player.cards = []
dealer.cards = []
# Start first phase of the dealing
while deal_count <= 4:
deal_count += 1
if deal_count % 2 == 0:
if deal_count == 4:
the_fourth_card = deck.deal()
the_fourth_card.hide_card()
dealer.add_card(the_fourth_card)
else:
dealer.add_card(deck.deal())
else:
player.add_card(deck.deal())
# Second phase of the dealing
while True:
# display cards
clear()
print(chips.name + ': ')
print(player)
print('Dealers: ')
print(dealer)
if player.bust():
break
if player.next_move():
player.add_card(deck.deal())
continue
else:
break
# change view permissions
for card in dealer.cards:
card.show_card()
# Once player finishes turn continue to deal dealers hand
while True:
# display cards
clear()
print(chips.name + ': ')
print(player)
print('Dealers: ')
print(dealer)
if dealer.bust():
break
if player.bust():
break
if dealer.total() > player.total():
break
else:
dealer.add_card(deck.deal())
continue
# display results and finalise transaction
if player.bust():
clear()
chips.subtract()
print(
f"{chips.name} you lost this one\n\nYour new Balance {chips.balance()}\n"
f"{chips.name}: {player}"
f"Dealers: {dealer}"
f"\nYour Score {player.total()}\nDealers Score {dealer.total()}")
elif player.total() < dealer.total() and not dealer.bust():
clear()
chips.subtract()
print(
f"{chips.name} the dealer beat your score\n\nYour new Balance {chips.balance()}\n"
f"{chips.name}: {player}"
f"Dealers: {dealer}"
f"\nYour Score {player.total()}\nDealers Score {dealer.total()}")
else:
clear()
chips.add()
print(f"{chips.name} you won!\n\nYour new Balance {chips.balance()}\n"
f"{chips.name}: {player}"
f"Dealers: {dealer}"
f"\nYour Score {player.total()}\nDealers Score {dealer.total()}")
# Do they want to replay
while True:
try:
replay = input('Do you want to play again? ').upper()
if replay == 'YES':
play_blackjack()
break
elif replay == 'NO':
print(
f'{chips.name} thank you for playing and we look forward to seeing you again'
)
break
else:
print(
'We didn\'t understand your request, a YES or NO is desired'
)
continue
except ValueError:
print(
'Invalid Input: We didn\'t recognise your request please try again YES or No'
)
continue
def test_add_card(self):
h = Hand()
card = (10, Deck.CLUBS)
h.add(card)
self.assertEqual(h.cards, [card])
def test_best_value_returns_best_blackjack_hand_value(self):
h = Hand()
h.add((2, Deck.CLUBS))
self.assertEqual(2, h.best_value())
h.add((Deck.ACE, Deck.CLUBS))
self.assertEqual(13, h.best_value())
h.add((Deck.ACE, Deck.HEARTS))
self.assertEqual(14, h.best_value())
class State:
def __init__(self,
starting_chips=1000,
number_decks=6,
percent_to_use=0.8):
self.player_chips = starting_chips
self.shoe = Shoe(number_decks=number_decks,
percent_to_use=percent_to_use)
self.player_hand = Hand()
self.dealer_hand = Hand()
def deal(self, bet):
if bet > self.player_chips:
raise Exception(f'Insufficient chips to place bet of {bet} chips.')
self.player_hand = Hand(bet=bet)
self.dealer_hand = Hand()
self.player_hand.add_card(self.shoe.deal_card())
self.dealer_hand.add_card(self.shoe.deal_card())
self.player_hand.add_card(self.shoe.deal_card())
self.dealer_hand.add_card(self.shoe.deal_card())
def inspect_dealers_hand(self):
return self.dealer_hand.inspect_card()
def hit(self):
self.player_hand.add_card(self.shoe.deal_card())
def dealer_play(self):
print(f'Dealer shows {self.dealer_hand.get_cards()}')
while self.dealer_hand.get_value() <= 17:
# Dealer hits soft 17
if self.dealer_hand.get_value() == 17 \
and len(self.dealer_hand.get_cards()) == 2 \
and 'A' in self.dealer_hand.get_cards():
break
self.dealer_hand.add_card(self.shoe.deal_card())
print(
f'Dealer ends up with {self.dealer_hand.get_cards()}. (Total={self.dealer_hand.get_value()})'
)
def play(self, bet):
if not self.shoe.is_shoe_open():
self.shoe.reset_shoe()
print('Shuffling shoe.')
self.deal(bet)
dealer_card = self.inspect_dealers_hand()
action = 'bj' if self.player_hand.get_value() == 21 else None
while action not in ['stand', 'bust', 'bj']:
print(f'Dealer is showing: {dealer_card}.')
player_cards = self.player_hand.get_cards()
print(
f'You have: {player_cards}. (Total={self.player_hand.get_value()})'
)
action = input('Hit or Stand?')
if action == 'hit':
self.hit()
if self.player_hand.get_value() > 21:
action = 'bust'
if action != 'bust':
self.dealer_play()
# Check result
if action == 'bust':
print('You busted!')
chip_diff = self.player_hand.bet * -1
elif action == 'bj':
print('Blackjack!')
chip_diff = self.player_hand.bet * 1.5
else:
result = self.player_hand.check_hand(self.dealer_hand)
if result > 0:
print('You won!')
chip_diff = self.player_hand.bet
elif result == 0:
print('Push.')
chip_diff = 0
else:
print('You lost.')
chip_diff = self.player_hand.bet * -1
self.player_chips += chip_diff
return chip_diff
def test_splitting():
# Test splitting each hand into two separate ones
for card in cards:
temp = Hand()
temp.add(Card(card))
temp.add(Card(card))
first = Hand()
second = Hand()
first.add(temp.cards.pop())
second.add(temp.cards.pop())
assert first.value() == second.value()
# Make sure split hand is empty
assert len(temp.cards) == 0
def test_for_soft_values():
temp = Hand()
temp.add(Card("4"))
temp.add(Card("A"))
assert temp.is_soft_value()
temp.add(Card("A"))
assert temp.is_soft_value()
temp.add(Card("4"))
assert temp.is_soft_value()
temp.add(Card("5"))
assert not temp.is_soft_value()
def test_ace_calculation():
temp = Hand()
temp.add(Card("A"))
assert temp.has_ace()
assert temp.value() == 11
temp.add(Card("A"))
assert temp.value() == 12
temp = Hand()
temp.add(Card("9"))
temp.add(Card("A"))
assert temp.value() == 20
temp.add(Card("A"))
assert temp.value() == 21
temp.add(Card("A"))
assert temp.value() == 12
def test_blackjack():
temp = Hand()
temp.add(Card("A"))
temp.add(Card("K"))
assert temp.is_blackjack()
