def test_calculate_hand_results(self):
player = Player({'game_settings': PlayerTest.game_settings})
hands = [
build_hand('blackjack'),
build_hand('hard'),
build_hand('bust')
]
player.hands = hands
dealer_hand = build_hand('hard_pair')
bankroll_start = player.bankroll
player.calculate_hand_results(dealer_hand)
self.assertEqual(player.hands[0].bet * PlayerTest.game_settings.blackjack_payout,
player.hands[0].winnings)
self.assertEqual(PlayerTest.game_settings.min_bet, player.hands[1].winnings)
self.assertEqual(0, player.hands[2].winnings)
self.assertEqual(bankroll_start +
player.hands[0].bet * 2 +
player.hands[1].bet +
player.hands[1].bet * PlayerTest.game_settings.blackjack_payout,
player.bankroll)
def test_player_standing():
p = Player('Fooman')
p.hand_list.append(Hand())
p.stand(p.hand_list[0])
assert_true(p.hand_list[0].final_hand)
def test_action_basic_strategy_low_bankroll_split_soft(self):
player = Player({'bankroll': 0, 'game_settings': PlayerTest.game_settings})
hand = build_hand('soft_pair')
hand.bet = 1
self.assertEqual(PlayerAction.HIT, player.action(hand, Card('5', 5, 'clubs')))
def test_player_standing():
p = Player('Fooman')
p.hand_list.append(Hand())
p.stand(p.hand_list[0])
assert_true(p.hand_list[0].final_hand)
def __init__(self):
self.deck = Deck()
self.player = Player()
self.dealer = Dealer()
self.player.chips.take_bet()
self.initialize_player()
self.initialize_dealer()
Play.show_some(self.player, self.dealer)
def test_make_bet(self, _print_mock, get_answer_mock):
budget = 100
bet = 20
get_answer_mock.return_value = bet
player = Player(_, budget)
player.make_bet()
get_answer_mock.assert_called()
self.assertEqual(player.current_bet, bet)
def test_new_hand(self):
bankroll = 100
player = Player({'bankroll': bankroll, 'game_settings': PlayerTest.game_settings})
hand = player.new_hand(bet=PlayerTest.game_settings.min_bet)
self.assertEqual(bankroll - PlayerTest.game_settings.min_bet, player.bankroll)
self.assertEqual(1, len(player.hands))
self.assertEqual(1, hand.number)
self.assertEqual(PlayerTest.game_settings.min_bet, hand.bet)
def test_player_betting():
p = Player('Fooman')
h = Hand()
p.hand_list.append(h)
p.bet(10)
# balance should now be -10 and bet of the hand 10.
assert_true(p.balance == -10 and h.bet == 10)
def test_player_betting():
p = Player('Fooman')
h = Hand()
p.hand_list.append(h)
p.bet(10)
# balance should now be -10 and bet of the hand 10.
assert_true(p.balance == -10 and h.bet == 10)
def test_budget_below_zero(self):
budget = 500
debt = 1000
player = Player(_, budget)
with self.assertRaises(RuntimeError):
player.budget -= debt
def test_make_move(self, _print_mock, get_answer_mock):
player = Player(_, _)
hit = 'hit'
stand = 'stand'
get_answer_numbers = [0, 1]
def get_answer_select(value_list):
return value_list[get_answer_numbers.pop(0)]
get_answer_mock.side_effect = get_answer_select
moves = [player.make_move() for _ in range(2)]
self.assertEqual(moves, [hit, stand])
def main_game():
players = [Player('Bob', 500), AiPlayer('Sam', 500)]
dealer = AiPlayer('Dealer', 5000)
game = Game(players, dealer)
print('\nWelcome!\n')
game.game_loop()
print('\nThanks for playing!')
def test_player_hitting():
p = Player('Fooman')
h = Hand()
pack = Pack()
# length = len(pack)
init_pack(pack)
p.hand_list.append(h)
p.hit(pack)
assert_true(len(p.hand_list[0]) == 1 and len(pack) == 51)
hit_20_cards(p, pack)
# Should bust from hitting 20 cards.
assert_true(busted(p.hand_list[0], Rules()))
def test_expose_cards(self):
exposed = False
first_values = [1, 2]
second_values = [3, 4]
hidden_cards = [
Card(_, first_values, _, exposed),
Card(_, second_values, _, exposed)
]
exposed_cards = hidden_cards.copy()
exposed_cards = [card.expose() for card in exposed_cards]
player = Player(_, _)
player.cards.extend(hidden_cards)
player.expose_cards()
self.assertEqual(player.cards, exposed_cards)
def test_budget(self):
budget = 500
prize = 100
player = Player(_, budget)
player.budget += prize
self.assertEqual(player.budget, budget + prize)
def test_player_hitting():
p = Player('Fooman')
h = Hand()
pack = Pack()
# length = len(pack)
init_pack(pack)
p.hand_list.append(h)
p.hit(pack)
assert_true(len(p.hand_list[0]) == 1 and len(pack) == 51)
hit_20_cards(p, pack)
# Should bust from hitting 20 cards.
assert_true(busted(p.hand_list[0], Rules()))
def __init__(self):
self.p = Player()
self.actions = { 1 : self.p.hit,
2 : self.p.stand,
3 : self.p.double,
4 : self.p.split,
}
self.Q = np.empty([0,5],dtype=object)
def test_balance_operations_and_check(self):
p = Player("Ivan", 500)
p.give_money(42)
self.assertEqual(p.balance, 542)
p.make_stake(442)
self.assertEqual(p.balance, 100)
self.assertTrue(p.has_enough_money(100))
self.assertFalse(p.has_enough_money(101))
def test_player_init():
p = Player('Fooman')
# Players should init with 0 balance and an empty hand list.
print p.balance
assert_equal(p.balance, 0)
assert_equal(p.hand_list, [])
assert_equal(p.name, 'Fooman')
assert_equal(p.current_hand, 0)
class TestPlayer(unittest.TestCase):
def setUp(self):
self.player = Player()
@unittest.mock.patch('blackjack.player.Player.Q')
def test_action(self, mock_Q):
player_cards = ['As', 'Qh']
house_cards = ['Kd']
action = self.player.action(player_cards, house_cards)
self.assertIn(action, ['stand', 'hit'])
def test_deal_card(self):
dealt_card = Card(1, SUIT_SPADES)
card_in_deck = Card(13, SUIT_SPADES)
with patch.object(Game, 'shuffle_deck', autospec=True):
game = Game([dealt_card, card_in_deck])
player = Player()
game.deal(player)
self.assertEqual([card_in_deck], game.card_pool)
self.assertEqual([dealt_card], player.hand.cards)
def test_reset_hands(self):
player = Player({'game_settings': PlayerTest.game_settings})
self.assertEqual(0, len(player.hands))
player.new_hand()
player.reset_hands()
self.assertEqual(0, len(player.hands))
def test_determine_points(self, _print_mock, get_answer_mock):
exposed = True
first_values = [1, 2]
second_values = [3, 4]
cards = [
Card(_, first_values, _, exposed),
Card(_, second_values, _, exposed)
]
def get_answer_select(value_list):
return value_list[0]
get_answer_mock.side_effect = get_answer_select
player = Player(_, _)
player.cards.extend(cards)
player.determine_points()
self.assertEqual(
get_answer_mock.mock_calls,
[call(first_values), call(second_values)])
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_game_loop_out_of_budget(self, _print_mock,
single_game_mock):
budget = 500
player = Player('Bob', budget)
players = [player]
dealer = AiPlayer('Dealer', 5000)
def single_game(self):
for player in self.players:
player.budget = 0
single_game_mock.side_effect = single_game
game = Game(players, dealer)
game.game_loop()
self.assertFalse(game.players)
def test___init___(self):
player_settings = {
'bankroll': 10000,
'bet_limit': 1000,
'dealer': True,
'game_settings': PlayerTest.game_settings,
'number': 10,
'unknown': False
}
player = Player(player_settings.copy())
self.assertEqual(player_settings['bankroll'], player.bankroll)
self.assertEqual(player_settings['bet_limit'], player.bet_limit)
self.assertEqual(player_settings['dealer'], player.dealer)
self.assertEqual(player_settings['number'], player.number)
self.assertEqual(player_settings['unknown'], player.extra_settings['unknown'])
def test_undetermined_cards(self):
exposed = True
values = [_]
cards = [Card(_, values, _, exposed), Card(_, values, _, exposed)]
undetermined_values = [1, 2]
undetermined_cards = [
Card(_, undetermined_values, _, exposed),
Card(_, undetermined_values, _, exposed)
]
player = Player(_, _)
player.cards.extend(cards + undetermined_cards)
for card in undetermined_cards:
self.assertTrue(
all(card == undetermined_card
for undetermined_card in player.undetermined_cards))
def test_game_loop_no_continue(self, _print_mock,
get_answer_mock,
single_game_mock):
budget = 500
player = Player('Bob', budget)
players = [player]
dealer = AiPlayer('Dealer', 5000)
def single_game(self):
for player in self.players:
player.budget = 0
single_game_mock.side_effect = single_game
get_answer_mock.return_value = 'n'
game = Game(players, dealer)
game.game_loop()
self.assertFalse(game.players)
def test_add_card(self):
player = Player()
ace_of_spades = Card(1, SUIT_SPADES)
two_of_spades = Card(2, SUIT_SPADES)
player.add_card(ace_of_spades)
self.assertEqual(
[ace_of_spades],
player.hand.cards,
)
player.add_card(two_of_spades)
self.assertEqual(
[ace_of_spades, two_of_spades],
player.hand.cards,
)
def __load_players_from_file(self, player_file):
"""
Load the players from file `player_file`
"""
try:
with open(player_file) as f:
for line in f:
[nume, prenume, varsta, tara,
jetoane] = line.replace('\n', '').split('\t')
tmp = Player(nume, prenume, int(varsta), tara,
int(jetoane))
self.players.append(tmp)
except FileNotFoundError as err:
log_and_print("FATAL ERROR - File %s not found" % player_file,
log_f=logging.error)
log_and_print(err, log_f=logging.error)
exit(1)
except TypeError as err:
log.error("FATAL ERROR - File %s is not properly formatted" %
player_file)
log.error(err)
exit(1)
def test_player_loses(self, _print_mock,
ai_player_make_move_mock, player_make_move_mock,
player_make_bet_mock, deal_start_cards_mock):
player_cards = [
Card('One', [1], '♣', exposed=True),
Card('One', [1], '♦', exposed=True),
]
dealer_cards = [
Card('Ten', [10], '♣', exposed=True),
Card('Ten', [10], '♦', exposed=False),
]
def deal(self):
for player in self.players:
player.cards.extend(player_cards)
self.dealer.cards.extend(dealer_cards)
deal_start_cards_mock.side_effect = deal
budget = 500
player = Player('Bob', budget)
players = [player]
dealer = AiPlayer('Dealer', 5000)
bet = 100
def make_bet(self):
self.current_bet = bet
player_make_bet_mock.side_effect = make_bet
stand = 'stand'
player_make_move_mock.return_value = stand
ai_player_make_move_mock.return_value = stand
game = Game(players, dealer)
game.single_game()
self.assertEqual(player.budget, budget - bet)
def create_stuff():
o = Player('Barman')
o.balance = 200
o.hand_list.append(Hand())
o.hand_list[o.current_hand].put_card(Card(2,'heart'))
p = Player('Fooman')
p.balance = 150
p.hand_list.append(Hand())
p.hand_list[p.current_hand].put_card(Card(1,'spade'))
# Stats not yet implemented.
# q = Game()
r = Rules()
return o, p, r
class Agent:
def __init__(self):
self.p = Player()
self.actions = { 1 : self.p.hit,
2 : self.p.stand,
3 : self.p.double,
4 : self.p.split,
}
self.Q = np.empty([0,5],dtype=object)
def choose_action(self,s,epsilon):
possibleActions = np.where(s!=-np.inf)[0][1:]
if (np.random.rand()) <= epsilon:
action = np.random.choice(possibleActions)
else:
action = np.argmax(s[1:]) + 1
return action
def add_state(self,s):
"""
Q-matrix:
0 | 1 | 2 | 3 | 4 |
|(Hit)|(Stand)|(Double)|(Split)|
states |
. |
. |
"""
Qrow = np.hstack((s,np.array((0.,0.,0.,0.),dtype=object)))
if s[1] == "1": # Doubling is not allowed after hitting
Qrow[-2] = -np.inf
else:
Qrow[-2] = np.random.rand(1)[0]*0.1
if s[2] == "0":
Qrow[-1] = -np.inf
else:
Qrow[-1] = np.random.rand(1)[0]*0.1
# Randomly initialize Q's available actions
Qrow[1:3] = np.random.rand(2)*0.1
self.Q = np.vstack((self.Q,Qrow))
def get_reward(self,p):
if p.gameState == "Lost":
return -1.0
elif p.gameState == "Won":
return 1.0
elif p.gameState == "InPlay":
return 0.1
elif p.gameState == "Push":
return 0.5
elif p.gameState == "Natural":
return 0.0
def update_Q(self,Q,p,s,a,ns,na,r,mu,gamma):
if p.gameState != "InPlay":
return mu*(r + gamma*(r - Q[s,a]))
else:
return mu*(r + gamma*Q[ns,na]-Q[s,a])
def learn(self,mu,gamma,epsilon,nGames,plots=False):
x = []
# Episodic epsilon-greedy algorithm
for i in range(nGames):
print("game number %s " % i)
reward = 0
if len(self.p.table.splitHand)==0:
self.p.bet(1)
if self.p.gameState == "Natural": self.p.bet(1)
else:
self.p.table.hand = self.p.table.splitHand.pop()
self.p.table.hand.is_split = False
self.p.gameState = "InPlay"
while self.p.gameState == "InPlay":
stateKey = encode_state(self.p.table.hand,self.p.table.dealer_hand)
# If we haven't seen this state before, extend Q
if stateKey not in self.Q[:,0]:
self.add_state(stateKey)
stateIndex = np.where(stateKey==self.Q[:,0])[0][0]
state = self.Q[stateIndex]
a = self.choose_action(state,epsilon)
self.actions[a]()
nextStateKey = encode_state(self.p.table.hand,self.p.table.dealer_hand)
if nextStateKey not in self.Q[:,0]:
self.add_state(nextStateKey)
nextStateIndex = np.where(nextStateKey==self.Q[:,0])[0][0]
nextState = self.Q[nextStateIndex]
na = self.choose_action(nextState,epsilon)
reward += self.get_reward(self.p)
self.Q[stateIndex,a] += self.update_Q(self.Q,
self.p,
stateIndex,
a,
nextStateIndex,
na,
reward,
mu=mu,
gamma=gamma)
# x.append((1-self.p.losses/(i+1)))*100
yield (1-self.p.losses/(i+1))*100
# print("Wins: ",self.p.wins)
# print("Losses: ", self.p.losses)
# print("Pushes: ",self.p.pushes)
# print("Naturals: ",self.p.naturals)
# pcnt = 1.0 - (self.p.losses/nGames)
# print("Percent not lost: ",pcnt*100,"%")
#
# # if plots:
# plt.plot(x)
# plt.ylabel("Percent won/drawn")
# plt.xlabel("Games played")
# plt.show()
def save(self,filename):
dump(self.Q,open(filename,"wb"))
def load(self,filename):
Q = load(open(filename,"rb"))
self.Q = Q
def play(self,nGames):
# Episodic epsilon-greedy algorithm
for i in range(nGames):
self.p.bet(1)
if self.p.gameState != "InPlay": self.p.bet(1)
while self.p.gameState == "InPlay":
stateKey = encode_state(self.p.table.hand,self.p.table.dealer_hand)
stateIndex = np.where(stateKey==self.Q[:,0])[0][0]
state = self.Q[stateIndex]
a = self.choose_action(state,epsilon=-np.inf)
self.actions[a]()
print("Wins: ",self.p.wins)
print("Losses: ", self.p.losses)
print("Pushes: ",self.p.pushes)
print("Naturals: ",self.p.naturals)
pcnt = 1.0 - (self.p.losses/nGames)
print("Percent not lost: ",pcnt*100,"%")
class Play:
def __init__(self):
self.deck = Deck()
self.player = Player()
self.dealer = Dealer()
self.player.chips.take_bet()
self.initialize_player()
self.initialize_dealer()
Play.show_some(self.player, self.dealer)
def initialize_player(self):
self.player.hand.add_card(self.deck.draw())
self.player.hand.add_card(self.deck.draw())
def initialize_dealer(self):
self.dealer.hand.add_card(self.deck.draw())
self.dealer.hand.add_card(self.deck.draw())
def play(self):
while input('Hit or stand (h/s)? ') == 'h':
self.hit(self.player.hand)
if self.evaluate():
break
else:
self.evaluate()
while self.dealer.hand.value <= 17:
self.hit(self.dealer.hand)
if self.dealer.hand.value > 21:
Play.dealer_busts()
self.player.chips.win_bet()
elif self.dealer.hand.value > self.player.hand.value:
Play.dealer_wins()
self.player.chips.lose_bet()
elif self.dealer.hand.value < self.player.hand.value:
Play.player_wins()
self.player.chips.win_bet()
else:
Play.push()
print(f'You have {self.player.chips.total} chips')
if 'y' == input('Do you want to play one more? (y/n)'):
self.deck = Deck()
self.player.reset()
self.dealer.reset()
self.initialize_player()
self.initialize_dealer()
Play.show_some(self.player, self.dealer)
self.play()
else:
print('That was a pleasure. Good bye!')
def evaluate(self):
if self.player.hand.value > 21:
Play.player_bust()
self.player.chips.lose_bet()
return True
else:
return False
def hit(self, hand):
hand.add_card(self.deck.draw())
Play.show_some(self.player, self.dealer)
@staticmethod
def show_some(player, dealer):
print('Dealer\'s cards:')
print(*dealer.hand.cards[1:])
print('First card is hidden...')
print('Total value:' + str(dealer.hand.value))
print('\n---------------------------\n')
print('Player\'s cards')
print(*player.hand.cards, sep=", ")
print('Total value:' + str(player.hand.value))
@staticmethod
def show_all(player, dealer):
print('Dealer\'s cards:')
print(*dealer.hand.cards, sep=", ")
print('First card is hided...')
print('Total value:' + str(dealer.hand.value))
print('\n---------------------------\n')
print('Player\'s cards')
print(*player.hand.cards, sep=", ")
print('Total value:' + str(player.hand.value))
@staticmethod
def player_bust():
print('You loose!')
@staticmethod
def player_wins():
print('You won!')
@staticmethod
def dealer_busts():
print('Dealer busts, you won!')
@staticmethod
def dealer_wins():
print('Dealer won!')
@staticmethod
def push():
print('Push!')
import os
from blackjack.deck import Deck
from blackjack.dealer import Dealer
from blackjack.player import Player
from blackjack.util import hand_total
dealer = Dealer()
player = Player()
while True:
print('*** Starting a new game...')
playing = True
player.hand = []
dealer.hand = []
dealer.show_hand = False
deck = Deck()
deck.shuffle()
player.place_bet()
player.get_card(deck.deal())
dealer.get_card(deck.deal())
player.get_card(deck.deal())
dealer.get_card(deck.deal())
print(dealer)
print(player)
while playing:
