def main():
usage_msg = "Usage: python %s player_balance [ number_of_card_decks ]" % __file__
num_argv = len(sys.argv)
if num_argv not in (2, 3):
print usage_msg
sys.exit()
else:
is_valid, num = check_int(sys.argv[1])
if is_valid:
player_balance = num
else:
print "Invalid parameter: %s" % sys.argv[1]
print usage_msg
sys.exit()
num_decks = None
if num_argv == 3:
is_valid, num = check_int(sys.argv[2])
if is_valid:
num_decks = num
else:
print "Invalid parameter: %s" % sys.argv[2]
print usage_msg
sys.exit()
player = Player(player_balance)
dealer = Dealer(num_decks) if num_decks else Dealer()
game = Game(dealer, player)
while game.run():
pass
def test_get_values_akqj(self):
hands = [Card('Spades', 'Ace'),
Card('Hearts', 'King'),
Card('Diamonds', 'Queen'),
Card('Clubs', 'Jack')]
dealer = Dealer()
self.assertEqual(31, dealer.get_values(hands))
def __init__(self):
self.deck_value = {
card: min(1 + self.rank.index(card[0]), 10)
for card in self.deck
}
self.hand_value = 0
self.dealer = Dealer()
def four_splits():
game = Game()
game.console = Console()
game.deck = Deck()
game.deck.cards[2:14] = [
Card("9", "Spades", False),
Card("9", "Clubs", False),
Card("9", "Hearts", False),
Card("9", "Diamonds", False),
Card("9", "Spades", False),
Card("2", "Clubs", False),
Card("3", "Hearts", False),
Card("4", "Diamonds", False),
Card("5", "Spades", False),
Card("6", "Clubs", False),
Card("7", "Hearts", False),
Card("8", "Diamonds", False)
]
game.dealer = Dealer("Table", [])
game.dealer.hit(game.deck)
game.dealer.hit(game.deck)
game.player = Player("Player 0", 10, [[]])
game.player.hit(game.deck, 0)
game.player.hit(game.deck, 0)
game.console.print_table(game.dealer, game.player)
game.player_turn(game.player, 0)
def start(self):
#self.delay(100)
if DEBUG:
print "------- start -----------"
self.state['e'] = Dealer(self.magic_page)
self.state['e'].add_players(CONFIG['PLAYER_COUNT'])
self.state['e'].gen_ok()
def __init__(self):
self.deck = Deck()
self.dealer = Dealer()
self.points = {}
self.players = self.set_players()
self.bet = {1: 0, 5: 0, 25: 0}
self.play_game()
def main():
print('---Blackjack 0.5---\n')
table = Table(doubleOn=[9, 10, 11])
dealer = Dealer('Dealer', 1000000)
dealer.sit(table)
#
# Deck Stacking:
#
dealer._shoe.append(Card('ace', 'spades'))
dealer._shoe.append(Card('ace', 'hearts'))
#
#
#
numberOfPlayers = get_integer_between(1, 7, 'How many players?')
for number in range(1, numberOfPlayers + 1):
name = get_string(f"What is player {number}'s name?")
player = HumanPlayer(name, 100)
player.sit(table)
dealer.take_bets()
while table.has_players():
dealer.deal()
dealer.offer_insurance()
dealer.play_hands()
dealer.play_own_hand()
dealer.payout_hands()
dealer.take_bets()
print('\n---There are no more players. Game Over.---')
def __init__(self):
self.deck = Deck()
self.players = []
i = 0
for i in range(1, 5):
self.players.append(Player(i, "Player " + str(i)))
self.dealer = Dealer(self.deck, self.players)
def test_second_dealer_card_face_down(self):
deck = Deck()
player = Player(deck)
dealer = Dealer(deck)
blackjack = BlackJack(player, dealer)
blackjack.deal()
self.assertFalse(dealer.hand[1].face_up)
def test_dealer_score_over_21_with_ace(self):
d = Dealer()
d.hand = [
self.diamond_ace, self.spade_eight, self.hearts_queen,
self.spade_five
]
self.assertEqual(d.score(), 24)
def __init__(self):
self.chairs = []
self.shoe = Shoe(6)
self.dealer = Dealer()
self.insurance = True
self.blackjack_payout = 1.5
self.shoe_size = 6
def run():
print "Starting the game. Enter the number of players"
num_players = stdin.readline()
players = []
# create the set of players
for num in range(int(num_players)):
player = Player(0)
players.append(player)
dealer = Dealer(players)
print 'Press enter key to shuffle the cards.'
shuffle = stdin.readline()
dealer.shuffle()
run_game(num_players, dealer)
while True:
print "\nPlay another game? YES/NO"
cmd = str(stdin.readline().strip())
if cmd == 'YES':
run_game(num_players, dealer)
continue
elif cmd == 'NO':
break
else:
print "Unknown command " + cmd
continue
def generate_dealer(players, cards_per_game):
"""
Instantiates the dealer which will take over the game
:return: Dealer
"""
points = [(0) for i in range(len(players))]
return Dealer(players, points, cards_per_game)
def generate_dealer(players: List(Player), cards_per_game: Int) -> Dealer:
"""
Instantiates the dealer which will take over the game
:return: Dealer
"""
points = [0 for i in range(len(players))]
return Dealer(players, points, cards_per_game)
def main():
c8_dealer = Dealer()
c8_opponent = Game()
c8_opponent.add_cards(c8_dealer.deal_cards(7))
c8_player = Player()
c8_player.add_cards(c8_dealer.deal_cards(7))
print("...Setup Complete. Enjoy the game!...\n")
while (c8_player.count() > 0 and c8_opponent.count() > 0):
#clear_output(wait=True)
print("\nCard In Play Is:", in_play(c8_dealer), "\n")
stat = player_play(c8_player, c8_dealer)
if (stat == "empty"):
print("...Deck is empty. Exiting...")
break
elif (stat == "quit"):
print("...Quiting...")
break
stat = game_play(c8_opponent, c8_dealer)
if stat == "empty":
print("...Deck is empty. Exiting...")
break
if (c8_player.count() == 0):
print("Yay! You won!")
elif (c8_opponent.count() == 0):
print("Computer won. Better luck next time!")
def test_stands_on_hard_17(self):
dealer = Dealer('test', 100)
hand = Hand(100)
hand.hit(Card('king', 'diamonds').flip())
hand.hit(Card('7', 'diamonds').flip())
dealer.play(hand, None)
self.assertTrue(hand.isStanding)
def runGame(p1, p2):
p1.resetForNewGame()
p2.resetForNewGame()
d1 = Dealer(5)
p1.cards = d1.dealCards()[0]
p2.cards = d1.dealCards()[0]
gameState = GameState(p1, p2)
aqlearnScore = 0
gameLoop = True
while gameLoop:
p1.pickCard()
p2.pickCard()
roundWinner = gameState.judgeRound(p1, p2)
#? generating successor
if roundWinner == p1:
p1.accumulatedCards[p1.playedCard[1]] += 1
if roundWinner == p2:
p2.accumulatedCards[p2.playedCard[1]] += 1
if gameState.judgeGameOver(p1, p2) == p1:
return p1.name
elif gameState.judgeGameOver(p1, p2) == p2:
return p2.name
p1.cards.append(d1.generateRandomCard())
p2.cards.append(d1.generateRandomCard())
def main():
players_list = []
number_of_players = input('Number of players: ')
if number_of_players in range(2, 10):
card_dealer = Dealer()
for player in range(number_of_players):
card_player = Player()
players_list.append(card_player)
card_dealer.deal_hand_to_player(card_player)
for player in players_list:
print 'Cards for player ' + str(players_list.index(player) +
1) + ':'
for card in player.get_cards_in_hand():
print card
print '-------------------------------'
print ''
print 'Table hand of 5 cards: '
card_dealer.deal_hand_to_board()
else:
print 'Invalid number of players.'
def __init__(self, player_card_labels, dealer_card_labels,
player_score_label, dealer_score_label, instruction_label,
b_deal, b_hit, b_stand, player_money_label,
dealer_money_label, bets_label, red_chip_label,
blue_chip_label, green_chip_label):
self.player_card_labels = player_card_labels
self.dealer_card_labels = dealer_card_labels
self.player_score_label = player_score_label
self.dealer_score_label = dealer_score_label
self.instruction_label = instruction_label
self.player_money_label = player_money_label
self.dealer_money_label = dealer_money_label
self.b_deal = b_deal
self.b_hit = b_hit
self.b_stand = b_stand
# cards
self.deck_of_cards = Deck(card_path)
# players
self.player = Player()
self.dealer = Dealer()
self.bets_label = bets_label
self.bet = int(bets_label.cget("text")[1])
self.red_chip_label = red_chip_label
self.blue_chip_label = blue_chip_label
self.green_chip_label = green_chip_label
def winner_with_split_hand():
# Testing winner function when player has multiple hands
console = Console()
dealer = Dealer("Table", [
Card("A", "Spades", False),
Card("3", "Spades", False),
Card("4", "Spades", False)
])
dealer.points = 18
player_test = Player(
"Player 0", 2,
[[Card("J", "Spades", False),
Card("7", "Spades", False)],
[
Card("10", "Spades", False),
Card("4", "Spades", False),
Card("9", "Spades", False)
], [Card("A", "Spades", False),
Card("Q", "Spades", False)],
[
Card("2", "Spades", False),
Card("8", "Spades", False),
Card("8", "Spades", False)
]])
player_test.bet = [2, 2, 2, 2]
player_test.points = [17, 23, 21, 18]
print(" Chips: \t" + str(player_test.chips) + "\t")
dealer.check_winner(player_test)
print(" Chips: \t" + str(player_test.chips) + "\t")
def reset(self):
self.turn = 0
self.hand = Hand()
self.hands = []
self.hands.append(self.hand)
self.game_over = False
self.dealer = Dealer()
def __init__(self):
self.DECKS = 8
self.shoe = Shoe(8)
self.p1 = Player("Complete_Strategy", 10000)
self.p2 = Player("Basic_Strategy", 10000)
self.dealer = Dealer(self.shoe)
self.sims = 0
def setUp(self):
# Traits (Trait, Food-value)
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 4)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 6)
self.cooperation = TraitCard(COOPERATION, 1)
self.scavenger = TraitCard(SCAVENGER, 2)
# Species (Population, Food, Body, Traits, Fat-Storage)
self.species1 = Species(1, 0, 2, [self.cooperation])
self.species2 = Species(6, 2, 1, [self.carnivore])
self.species3 = Species(3, 3, 3, [self.fattissue], 0)
self.species4 = Species(5, 5, 5, [self.burrowing])
self.species5 = Species(5, 3, 4, [self.foraging])
self.species6 = Species(
2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
self.species7 = Species(7, 1, 6, [self.horns])
self.player1_species = [self.species1, self.species2]
self.player2_species = [self.species3, self.species4, self.species5]
self.player3_species = [self.species6, self.species7]
# Players (Name, Bag, Hand, Species)
self.player1 = PlayerState(1, 0, [self.fattissue],
self.player1_species)
self.player2 = PlayerState(2, 3, [self.fattissue, self.carnivore],
self.player2_species)
self.player3 = PlayerState(3, 6, [self.burrowing],
self.player3_species)
self.public_player1 = PlayerState(1, False, False,
self.player1_species)
self.public_player2 = PlayerState(2, False, False,
self.player2_species)
self.public_player3 = PlayerState(3, False, False,
self.player3_species)
self.list_of_players = [self.player1, self.player2, self.player3]
# Dealer (List of Players, Watering Hole, Deck)
self.dealer1 = Dealer(self.list_of_players, 10, [])
# Actions
self.food_card_action1 = FoodCardAction(0)
self.food_card_action2 = FoodCardAction(1)
self.grow_action_pop = GrowAction(POPULATION, 0, 0)
self.grow_action_body = GrowAction(BODY, 1, 1)
self.add_species_action1 = AddSpeciesAction(0, [1])
self.add_species_action2 = AddSpeciesAction(0, [])
self.replace_trait_action1 = ReplaceTraitAction(0, 0, 0)
self.replace_trait_action2 = ReplaceTraitAction(2, 0, 1)
self.replace_trait_action3 = ReplaceTraitAction(0, 2, 0)
# Action4
self.action4_1 = Action4(self.player1, [self.food_card_action1])
self.action4_2 = Action4(
self.player2, [self.food_card_action2, self.grow_action_pop])
def test_doesnt_deal_when_0_bet(self):
dealer = Dealer('test', 100)
player = self.deal_in_player(dealer)
player.bet_or_leave = MagicMock(return_value=0)
dealer.take_bets()
player.add_hand = MagicMock()
dealer.deal()
player.add_hand.assert_not_called()
def test_can_play_under_limit(self):
""" Branch coverage """
dealer = Dealer()
card1 = Card('Hearts', ('2', 2))
card2 = Card('Hearts', ('3', 3))
dealer.add_card(card1)
dealer.add_card(card2)
self.assertTrue(dealer.can_play())
def test_hits_on_soft_17(self):
dealer = Dealer('test', 100)
hand = Hand(100)
hand.hit(Card('ace', 'diamonds').flip())
hand.hit(Card('7', 'diamonds').flip())
dealer.play(hand, None)
self.assertEqual(len(hand), 3)
self.assertFalse(hand.isStanding)
def test_no_natural_with_face_down(self):
deck = []
dealer = Dealer(deck)
c1 = Card("Hearts", "A", 11, True)
c2 = Card("Spades", "3", 3, False)
dealer.hand.append(c1)
dealer.hand.append(c2)
self.assertFalse(dealer.check_naturals())
def test_deals_to_self(self):
dealer = Dealer('test', 100)
dealer.add_hand = MagicMock()
dealer.deal()
# Expect add_hand to have been called with a hand
# that has two cards
hand = dealer.add_hand.call_args[0][0]
self.assertEqual(len(hand), 2)
def __init__(self, num_players, chips):
self.dealer = Dealer()
self.players = [None] * num_players
self.num_players = num_players
self.deck = CardDeck()
for i in range(self.num_players):
self.players[i] = Player(i, chips)
def __init__(self, name='None'):
self.player = BlackJackPlayer(name)
self.dealer = Dealer('Oberyn')
self.deck = Deck()
self.deck.create_deck()
self.deck.shuffle()
self.hidden_card = None
self.turns = []
