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_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_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_budget_below_zero(self):
budget = 500
debt = 1000
player = Player(_, budget)
with self.assertRaises(RuntimeError):
player.budget -= debt
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 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
def test_budget(self):
budget = 500
prize = 100
player = Player(_, budget)
player.budget += prize
self.assertEqual(player.budget, budget + prize)
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 __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_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)
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_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_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_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_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_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 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_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 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_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_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_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_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 __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_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_new_hand_low_bankroll(self):
bankroll = PlayerTest.game_settings.min_bet - 1
player = Player({'bankroll': bankroll, 'game_settings': PlayerTest.game_settings})
self.assertIsNone(player.new_hand(bet=PlayerTest.game_settings.min_bet))
Remember to you are free to use any resources you want and as always:
HAVE FUN!
'''
from blackjack.deck import Deck
from blackjack.card import Card #dont know if needed (deck.py is importhing card and comenting in isn't causing an error)
from blackjack.player import Player
from blackjack.thegame import TheGame
#====================================================
#▒█▀█▀█░▐█░▐█░▐█▀▀ ░▐█▀▀▀──░▄█▀▄─▒▐██▄▒▄██▌░▐█▀▀
#░░▒█░░░▐████░▐█▀▀ ░▐█░▀█▌░▐█▄▄▐█░▒█░▒█░▒█░░▐█▀▀
#░▒▄█▄░░▐█░▐█░▐█▄▄ ░▐██▄█▌░▐█─░▐█▒▐█░░░░▒█▌░▐█▄▄
#====================================================
game = TheGame()
player1 = Player('Player1') #player 1 is human
player2 = Player('Computer') #player 2 is a computer
#Before we start, we need to create deck
mydeck = Deck()
mydeck.shuffle()
#THis will be repeated until player decide to stop playing
while True:
if player1.balance <= 0:
print('Player have not money anymore. Game is finished!')
break
#in case it is not first round we have to discard all cards from hand
player1.discard_hand()
player2.discard_hand()
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:
