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 test_end_turn(self):
species1 = Species(3, 4, 5, [TraitCard(CARNIVORE)])
species2 = Species(3, 3, 3)
species3 = Species(0, 2, 3)
species4 = Species(1, 2, 3)
species5 = Species(0, 3, 3)
speciesList1 = [species1, species2]
speciesList2 = [species3, species4, species5]
dealer_hand = [TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL)]
player1 = PlayerState(1, 0, speciesList1, [], Player(1))
player2 = PlayerState(2, 2, speciesList2, [], Player(2))
new_player1 = copy.deepcopy(player1)
new_player1.species = [Species(0, 4, 3, [TraitCard(CARNIVORE)]), Species(0, 3, 3)]
new_player1.foodbag = 6
new_player2 = copy.deepcopy(player2)
new_player2.species = [Species(0, 2, 1)]
new_player2.trait_cards = [TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL)]
new_player2.foodbag = 3
dealer = Dealer([player1, player2], 4, dealer_hand)
new_dealer = copy.deepcopy(dealer)
new_dealer.playerStates = [new_player1, new_player2]
new_dealer.hand = []
dealer.end_turn()
self.assertEquals(dealer, new_dealer)
class Game(object): def __init__(self): self.player = Player() self.deck = Deck() self.dealer = Dealer() self.isFirstDeal = True def dealToPlayer(self): if self.isFirstDeal: card1 = self.deck.randomDraw() card2 = self.deck.randomDraw() self.player.hand.extend([card1, card2]) self.isFirstDeal = False else: card = self.deck.randomDraw() self.player.hand.append(card) pass print "Your Hand: ", self.player.hand def play_round(self): while self.player.play_action().low() == "h": #returns Hit or Stand" if self.player.choice.low() == "h": self.player.dealToPlayer() else: # end of the game self.player.hand self.dealer.play_action() def play_game(self):
def test_step1(self):
species1 = Species(3, 4, 5)
species2 = Species(3, 3, 3)
speciesList1 = [species1, species2]
dealer_hand = [TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL), TraitCard(LONG_NECK),
TraitCard(CARNIVORE), TraitCard(AMBUSH), TraitCard(WARNING_CALL), TraitCard(LONG_NECK),
TraitCard(CARNIVORE), TraitCard(AMBUSH)]
play_strat1 = Player(1)
play_strat2 = Player(2)
player1 = PlayerState(1, 0, [], [], play_strat1)
player2 = PlayerState(2, 2, speciesList1, [], play_strat2)
expected_player1 = copy.deepcopy(player1)
expected_player1.species.append(Species(0, 0, 1))
expected_player1.trait_cards = [TraitCard(AMBUSH), TraitCard(CARNIVORE),
TraitCard(LONG_NECK), TraitCard(WARNING_CALL)]
expected_player2 = copy.deepcopy(player2)
expected_player2.trait_cards = [TraitCard(AMBUSH), TraitCard(CARNIVORE), TraitCard(CARNIVORE),
TraitCard(LONG_NECK), TraitCard(WARNING_CALL)]
dealer = Dealer([player1, player2], 4, dealer_hand)
dealer.step1()
self.assertEquals(player1.player_reference.playerState, expected_player1)
self.assertEquals(player2.player_reference.playerState, expected_player2)
self.assertEquals(dealer.hand, [TraitCard(AMBUSH)])
def testFeedAllSpeciesWithTrait(self):
# Species(food, body, population, traits, fatfood)
species1 = Species(3, 4, 5, [TraitCard(SCAVENGER)]) # will feed
species2 = Species(3, 3, 3, [TraitCard(SCAVENGER)]) # won't feed
species3 = Species(1, 5, 4, [TraitCard(SCAVENGER), TraitCard(FORAGING)]) # will feed
species4 = Species(1, 2, 6, [TraitCard(SCAVENGER)]) # can't feed (watering hole empty)
speciesList1 = [species1, species2]
speciesList2 = [species3, species4]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, speciesList2, [])
dealer = Dealer([player1, player2], 3, [])
self.assertEquals(species1.food, 3)
self.assertEquals(species2.food, 3)
self.assertEquals(species3.food, 1)
self.assertEquals(species4.food, 1)
self.assertEquals(dealer.wateringHole, 3)
dealer.feed_all_species_with_trait(SCAVENGER)
self.assertEquals(species1.food, 4)
self.assertEquals(species2.food, 3)
self.assertEquals(species3.food, 3)
self.assertEquals(species4.food, 1)
self.assertEquals(dealer.wateringHole, 0)
def testfeed_result_carnivore(self):
species1 = Species(1, 4, 2, [TraitCard(CARNIVORE)], 1)
species4 = Species(1, 2, 6, [TraitCard(HORNS)])
speciesList1 = [species1]
speciesList2 = [species4]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, speciesList2, [])
dealer = Dealer([player1, player2], 5, [])
self.assertEquals(dealer.wateringHole, 5)
self.assertEquals(dealer.playerStates[0].species[0].food, 1) # carnivore
self.assertEquals(dealer.playerStates[1].species[0].population, 6) # horns
dealer.feed_result_carnivore(0, 1, 0) #carnivore attacks horns
self.assertEquals(dealer.wateringHole, 5)
self.assertEquals(dealer.playerStates[0].species[0].food, 1) # carnivore
self.assertEquals(dealer.playerStates[0].species[0].population, 1) # carnivore
self.assertEquals(dealer.playerStates[1].species[0].population, 5) # horns
dealer.feed_result_carnivore(0, 1, 0) #carnivore attacks horns
self.assertEquals(dealer.wateringHole, 5)
self.assertEquals(len(dealer.playerStates[0].species), 0)
self.assertEquals(len(dealer.playerStates[1].species), 1)
self.assertTrue(dealer.playerStates[1].species[0].hasTrait(HORNS))
def test_transfer_fat_food(self):
fat1 = Species(2, 5, 7, [TraitCard(FAT_TISSUE)], 3)
empty_fat = Species(2, 5, 7, [TraitCard(FAT_TISSUE)], 0)
fat2 = Species(2, 5, 7, [TraitCard(FAT_TISSUE)], 6)
non_fat = Species(2, 3, 4)
non_fat2 = Species(1, 1, 4, [TraitCard(CARNIVORE), TraitCard(FERTILE)])
new_fat1 = Species(5, 5, 7, [TraitCard(FAT_TISSUE)], 0)
new_empty_fat = Species(2, 5, 7, [TraitCard(FAT_TISSUE)], 0)
new_fat2 = Species(7, 5, 7, [TraitCard(FAT_TISSUE)], 1)
new_non_fat = Species(2, 3, 4)
new_non_fat2 = Species(1, 1, 4, [TraitCard(CARNIVORE), TraitCard(FERTILE)])
player1 = PlayerState(1, 2, [fat1, non_fat, empty_fat])
player2 = PlayerState(2, 5, [fat2])
player3 = PlayerState(3, 4, [non_fat2])
new_player1 = PlayerState(1, 2, [new_fat1, new_non_fat, new_empty_fat])
new_player2 = PlayerState(2, 5, [new_fat2])
new_player3 = PlayerState(3, 4, [new_non_fat2])
dealer = Dealer([player1, player2, player3], 100, [])
dealer.transfer_fat_food()
new_dealer = Dealer([new_player1, new_player2, new_player3], 100, [])
self.assertEquals(player1, new_player1)
self.assertEquals(player2, new_player2)
self.assertEquals(player3, new_player3)
self.assertEquals(dealer, new_dealer)
def test_deal_x_cards(self):
species1 = Species(5, 4, 5)
species2 = Species(3, 3, 3)
species3 = Species(3, 5, 4)
species4 = Species(3, 3, 4, [TraitCard("fat-tissue", 0)], 3)
species5 = Species(3, 3 ,4, [TraitCard("fat-tissue", 0)], 1)
speciesList1 = [species1, species2, species3, species4, species5]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, [species1, species1, species2])
dealer1 = Dealer([player1], 4, [TraitCard(CARNIVORE), TraitCard(SCAVENGER), TraitCard(LONG_NECK)])
self.assertEquals(len(dealer1.hand), 3)
dealer1.deal_x_cards(player1, 2)
self.assertEquals(len(dealer1.hand), 1)
self.assertEquals(player1.trait_cards, [TraitCard(CARNIVORE), TraitCard(SCAVENGER)])
self.assertEquals(len(player2.trait_cards), 0)
self.assertEquals(dealer1.hand, [TraitCard(LONG_NECK)])
dealer1.deal_x_cards(player2, 2)
self.assertEquals(len(dealer1.hand), 0)
self.assertEquals(player2.trait_cards, [TraitCard(LONG_NECK)])
self.assertEquals(len(player1.trait_cards), 2)
self.assertEquals(dealer1.hand, [])
def testDealCards():
#Testing method dealCards
deck = Deck()
dealer = Dealer()
player = Player()
assert deck.deck["ace"][1] == 1
assert deck.deck["two"][1] == 2
assert deck.deck["king"][1] == 10
assert deck.playedCards == {}
assert dealer.deck == []
assert dealer.hand == 0
assert dealer.numberCards == 0
assert dealer.upCard == 0
assert player.deck == []
assert player.hand == 0
assert player.chips == 100
dealer.dealCards(player,deck)
assert deck.playedCards != {}
assert len(deck.playedCards.values()) != 0
assert len(deck.deck.values()) != 52
assert dealer.numberCards == 2
assert dealer.hand != 0
assert len(dealer.deck) == 2
assert dealer.hand != 0
assert len(player.deck) == 2
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 test_getPlayer(self):
dealer = Dealer()
player1 = dealer.getPlayer()
player2 = dealer.getPlayer()
player3 = dealer.getPlayer()
player4 = dealer.getPlayer()
with self.assertRaises(GameError) as e:
dealer.getPlayer()
def test_deal(self):
"""test the deal method"""
player = Player('Foo')
card = Card(Rank(0, 'x'), Suit('y'))
dealer = Dealer([card], [player], 1)
self.assertEqual(0, len(player.cards))
dealer.deal()
self.assertEqual(1, len(player.cards))
self.assertEqual(card, player.cards[0])
def executeXstep4(confiXstep): process_configuration, process_xstep4 = parse_json.parse_configuration_with_xstep4(confiXstep) [lop, watering_hole, loc] = process_configuration dealer = Dealer(watering_hole, lop, loc) dealer.step4Apply(process_xstep4) new_cofiguration = dealer.get_configuration() m_json = make_json.MakeJSON() output = m_json.make_configuration(new_cofiguration) return output
def play_hand(self, player):
dealer = Dealer()
player.value_hand()
while player.value_hand < 21:
hit_stay = input("Hit or stay? h/s").lower()
if hit_stay == 'h':
player.deal_hit()
elif (player.value_hand > dealer.value_hand) or (dealer.value_hand > 21):
print("You win!")
dealer.clear_hand()
def testForagingFeed(self):
# Species(food, body, population, traits, fatfood)
species1 = Species(3, 4, 5, [TraitCard(FORAGING)])
species2 = Species(3, 3, 5, [TraitCard(FORAGING)])
species3 = Species(3, 5, 4, [TraitCard(FORAGING)])
speciesList1 = [species1, species2]
speciesList2 = [species3]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, speciesList2, [])
dealer = Dealer([player1, player2], 4, [])
dealer.add_silly_players()
self.assertEquals(dealer.wateringHole, 4)
dealer.feed1()
dealer.playerStates.append(dealer.playerStates.pop(0))
self.assertEquals(dealer.wateringHole, 2)
self.assertEquals(dealer.playerStates[1].species[0].food, 5)
dealer.feed1()
dealer.playerStates.append(dealer.playerStates.pop(0))
self.assertEquals(dealer.wateringHole, 1)
self.assertEquals(dealer.playerStates[1].species[0].food, 4)
dealer.feed1()
dealer.playerStates.append(dealer.playerStates.pop(0))
self.assertEquals(dealer.playerStates[1].species[1].food, 4)
def testFeedFromWateringHole(self):
# Species(food, body, population, traits, fatfood)
species1 = Species(5, 4, 5, [TraitCard(FORAGING)])
species2 = Species(3, 3, 5, [TraitCard(FORAGING)])
species3 = Species(3, 5, 4, [TraitCard(FORAGING)])
species4 = Species(3, 5, 5, [TraitCard(FORAGING)])
speciesList1 = [species1, species2, species3, species4]
player1 = PlayerState(1, 0, speciesList1, [])
dealer = Dealer([player1], 4, [])
dealer.feedFromWateringHole(0, 0)
self.assertEquals(dealer.playerStates[0].species[0].food, 5)
self.assertEquals(dealer.wateringHole, 4)
dealer.feedFromWateringHole(0, 1)
self.assertEquals(dealer.playerStates[0].species[1].food, 5)
self.assertEquals(dealer.wateringHole, 2)
dealer.feedFromWateringHole(0, 2)
self.assertEquals(dealer.playerStates[0].species[2].food, 4)
self.assertEquals(dealer.wateringHole, 1)
dealer.feedFromWateringHole(0, 3)
self.assertEquals(dealer.playerStates[0].species[3].food, 4)
self.assertEquals(dealer.wateringHole, 0)
def test_deal(self): dealer = Dealer() expected = 13 player1 = dealer.getPlayer() player2 = dealer.getPlayer() player3 = dealer.getPlayer() player4 = dealer.getPlayer() self.assertEqual(expected, len(player1.getCards())) self.assertEqual(expected, len(player2.getCards())) self.assertEqual(expected, len(player3.getCards())) self.assertEqual(expected, len(player4.getCards()))
def testAutoFeed(self):
species1 = Species(5, 4, 5)
species2 = Species(3, 3, 3)
species3 = Species(3, 5, 4)
species3a = Species(1, 5, 4)
species4 = Species(4, 3, 4, [TraitCard("fat-tissue", 0)], 3)
species5 = Species(4, 3 ,4, [TraitCard("fat-tissue", 0)], 1)
carn1 = Species(3, 2, 4, [TraitCard("carnivore")])
carn2 = Species(4, 2, 5, [TraitCard("carnivore"), TraitCard("climbing")])
attackable = Species(3, 3, 5)
speciesList1 = [species1, species2]
speciesList2 = [species3, species3a]
carnList1 = [carn1]
carnList2 = [carn2, attackable]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, speciesList2, [])
player3 = PlayerState(3, 3, [species4, species5], [])
player4 = PlayerState(4, 4, [species3], [])
player5 = PlayerState(5, 5, carnList1)
player6 = PlayerState(6, 5, carnList2)
dealer1 = Dealer([player1, player2], 4, [])
dealer2 = Dealer([player2], 4, [])
dealer3 = Dealer([player3], 3, [])
dealer4 = Dealer([player4], 3, [])
dealer5 = Dealer([player5, player6], 6, [])
unchanged_player1 = copy.deepcopy(player1)
unchanged_player2 = copy.deepcopy(player2)
self.assertTrue(dealer1.auto_feed())
self.assertEquals(dealer1.fullPlayerIds, [1])
self.assertEquals(unchanged_player1, player1)
self.assertEquals(unchanged_player2, player2)
unchanged_species4 = copy.deepcopy(species4)
self.assertFalse(dealer3.auto_feed())
self.assertEquals(species5.fatFood, 1)
self.assertEquals(unchanged_species4, species4)
self.assertFalse(dealer2.auto_feed())
self.assertEquals(species3.food, 3)
self.assertEquals(species3a.food, 1)
self.assertTrue(dealer4.auto_feed())
self.assertEquals(species3.food, 4)
# no autofeeding on carnivores
self.assertEquals(carn1.food, 3)
unchanged_carn2 = copy.deepcopy(carn2)
self.assertFalse(dealer5.auto_feed())
self.assertEquals(carn1.food, 3)
self.assertEquals(unchanged_carn2, carn2)
self.assertEquals(attackable.population, 5)
class TestPot(unittest.TestCase):
"""Do we have a fully functional pot object?"""
def setUp(self):
self.p0 = Player('p0', 100)
self.p1 = Player('p1', 100)
self.p2 = Player('p2', 100)
self.p3 = Player('p3', 100)
self.p4 = Player('p4', 100)
self.p5 = Player('p5', 100)
self.s0 = Seat('s0')
self.s1 = Seat('s1')
self.s2 = Seat('s2')
self.s3 = Seat('s3')
self.s4 = Seat('s4')
self.s5 = Seat('s5')
players = [self.p0, self.p1, self.p2, self.p3, self.p4, self.p5]
seats = [self.s0, self.s1, self.s2, self.s3, self.s4, self.s5]
self.table = Table(seats, 5, 10, 0)
self.dealer = Dealer(self.table)
self.table.dealer = self.dealer
player = 0
for seat in seats:
seat.player = players[player]
seat.player.seat = seat
seat.active = True
seat.player.table = self.table
player += 1
self.table.init_hand()
def test_who_is_first_pre_flop(self):
"""Do we make the proper player act first pre-flop??"""
self.dealer.deal_hole()
self.assertTrue(self.table.seats[self.table.under_the_gun].player.action)
def test_who_is_first_post_flop(self):
"""Do we make the proper player act first post-flop"""
self.dealer.deal_hole()
self.table.seats[self.table.under_the_gun].player.action = False
self.dealer.deal()
self.assertTrue(self.table.seats[self.table.first].player.action)
def test_bet(self):
"""Can each player bet 50?"""
self.dealer.deal_hole()
i = 0
while i < 6:
i += 1
for seat in self.table.pots[-1].seats:
print(seat.player.name, seat.player.equity, seat.player.action)
if seat.player.action:
seat.player.bet(50)
self.table.pots[-1].betting_round()
break
print(seat.player.name, seat.player.equity, seat.player.action)
print(self.table.pots[-1].pot)
class dealerTest (unittest.TestCase):
def setUp(self):
self.dealer = Dealer(100)
def test_get_move(self):
self.assertEquals(self.dealer.get_move(), "hit")
self.dealer.hand.add_card(("A", "s"))
self.assertEquals(self.dealer.get_move(), "hit")
self.dealer.hand.add_card(("3", "d"))
self.assertEquals(self.dealer.get_move(), "hit")
self.dealer.hand.add_card(("2", "c"))
self.assertEquals(self.dealer.get_move(), "stay")
def json_to_dealer(cls, json_config):
assert(cls.validate_configuration_json(json_config))
players_interfaces = []
num_players = len(json_config[0])
for i in range(num_players):
players_interfaces.append(Player())
dealer = Dealer(players_interfaces)
for i in range(num_players):
dealer.players[i] = cls.json_to_player(json_config[0][i])
dealer.watering_hole = json_config[1]
deck = []
for i in range(len(json_config[2])):
deck.append(cls.json_to_trait_card(json_config[2][i]))
dealer.deck = deck
return dealer
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 setUp(self):
self.p0 = Player('p0', 100)
self.p1 = Player('p1', 100)
self.p2 = Player('p2', 100)
self.p3 = Player('p3', 100)
self.p4 = Player('p4', 100)
self.p5 = Player('p5', 100)
self.s0 = Seat('s0')
self.s1 = Seat('s1')
self.s2 = Seat('s2')
self.s3 = Seat('s3')
self.s4 = Seat('s4')
self.s5 = Seat('s5')
players = [self.p0, self.p1, self.p2, self.p3, self.p4, self.p5]
seats = [self.s0, self.s1, self.s2, self.s3, self.s4, self.s5]
self.table = Table(seats, 5, 10, 0)
self.dealer = Dealer(self.table)
self.table.dealer = self.dealer
player = 0
for seat in seats:
seat.player = players[player]
seat.player.seat = seat
seat.active = True
seat.player.table = self.table
player += 1
self.table.init_hand()
def new(self): time.sleep(2) self.cards = Cards() self.player = Player() self.dealer = Dealer() self.dealer.shuffle(self.cards) card1, card2 = self.player.receiveCards(self.dealer.deal(self.cards)) card3, card4 = Dealer.receiveCards() global screen cards_render = pygame.sprite.RenderPlain((card1,card2,card3,card4)) cards_render.update() cards_render.draw(screen) pygame.display.flip() return self._continueGame()
def showCards(self):
global screen
card1 = Dealer.revealFirstCard()
cards_render = pygame.sprite.RenderPlain((card1))
cards_render.update()
cards_render.draw(screen)
pygame.display.flip()
time.sleep(2)
ds = self.dealer.showCards()
time.sleep(2)
ps = self.player.showCards()
time.sleep(2)
_print('---------------------------------------', 'magenta')
if ps == ds or (ps > 21 and ds > 21):
_print('Push. Neither dealer nor player won.', 'magenta')
elif ps <= 21 and ps > ds:
_print('Player wins with {0}.'.format(ps), 'magenta')
elif ds <= 21 and ds > ps:
_print('Dealer wins with {0}.'.format(ds), 'magenta')
elif ps > 21 and ds <= 21:
_print('Dealer wins with {0}. Player bust.'.format(ds), 'magenta')
elif ds > 21 and ps <= 21:
_print('Player wins with {0}. Dealer bust.'.format(ps), 'magenta')
_print('---------------------------------------', 'magenta')
def test_add_silly_players(self):
species1 = Species(3, 4, 5)
species2 = Species(3, 3, 3)
species3 = Species(1, 2, 3)
species4 = Species(1, 2, 3)
speciesList1 = [species1, species2]
speciesList2 = [species3, species4]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, speciesList2, [])
dealer = Dealer([player1, player2], 4, [])
dealer.add_silly_players()
self.assertEquals(dealer.playerStates[0].player_reference.playerId, 1)
self.assertEquals(dealer.playerStates[1].player_reference.playerId, 2)
def test_get_hungry_and_fat_tissue_lists(self):
species1 = Species(5, 4, 5)
species2 = Species(3, 3, 3)
species3 = Species(3, 5, 4)
species4 = Species(3, 3, 4, [TraitCard("fat-tissue", 0)], 3)
species5 = Species(3, 3 ,4, [TraitCard("fat-tissue", 0)], 1)
speciesList1 = [species1, species2, species3, species4, species5]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, [species1, species1, species2])
dealer1 = Dealer([player1], 4, [])
dealer2 = Dealer([player2], 3, [])
self.assertEquals(dealer1.get_hungry_and_fat_tissue_lists(), ([2, 3, 4], [4]))
self.assertEquals(dealer2.get_hungry_and_fat_tissue_lists(), ([], []))
def test_create_hand(self):
hand = Dealer.create_hand()
self.assertEquals(hand[0], TraitCard(AMBUSH, -3))
self.assertEquals(hand[121], TraitCard(WARNING_CALL, 3))
self.assertEquals(len(hand), 122)
ambushes = 0
for trait in hand:
if trait.name == AMBUSH:
ambushes += 1
self.assertEquals(ambushes, 7)
carnivores = 0
for trait in hand:
if trait.name == CARNIVORE:
carnivores += 1
self.assertEquals(carnivores, 17)
warnings = 0
for trait in hand:
if trait.name == WARNING_CALL:
warnings += 1
self.assertEquals(warnings, 7)
longs = 0
for trait in hand:
if trait.name == LONG_NECK:
longs += 1
self.assertEquals(longs, 7)
def __init__(self):
self.deck = Deck()
self.players = []
while True:
try:
num_players = int(raw_input('Enter number of players (1-6): '))
except ValueError:
continue
if num_players < 1 or num_players > 6:
print "Invalid number of players"
continue
for i in range(num_players):
name = raw_input('Enter name of player %d: ' % (i + 1))
bankroll = random.choice(range(100, 1001, 100))
self.players.append(Player(name, bankroll))
print "Welcome %s, you have a starting bankroll of $%s" % (name, bankroll)
break
self.dealer = Dealer()
def testDoneFeeding(self):
species1 = Species(5, 4, 5)
species2 = Species(3, 3, 3)
species3 = Species(4, 5, 4)
speciesList1 = [species1, species2]
speciesList2 = [species3]
player1 = PlayerState(1, 0, speciesList1, [])
player2 = PlayerState(2, 2, speciesList2, [])
dealer = Dealer([player1, player2], 4, [])
dealer.feed1()
dealer.playerStates.append(dealer.playerStates.pop(0))
self.assertEquals(len(dealer.fullPlayerIds), 1)
self.assertEquals(dealer.fullPlayerIds[0], 1)
def __init__(self):
self.dealer = Dealer()
self.quit = False
self.user = Player()
def test_deal(self):
dealer = Dealer()
self.assertEqual(len(dealer.cards), 52)
dealer.deal()
self.assertEqual(len(dealer.cards), 51)
# -*- coding: utf-8 -*-
from game import Game
from dealer import Dealer
from randomPlayer import RandomPlayer
from modestPlayer import ModestPlayer
from nodoPlayer import NodoPlayer
from tablePlayer import TablePlayer
import sys
#sys.stdout = open("log.txt", "w")
if __name__ == "__main__":
game = Game()
dealer = Dealer()
player_a = RandomPlayer()
player_b = ModestPlayer()
player_c = NodoPlayer()
player_d = TablePlayer(dealer)
game.set_dealer(dealer)
# game.set_player(0,player_a)
# game.set_player(1,player_b)
# game.set_player(2,player_c)
game.set_player(3,player_d)
dealer.cards = [10,10]
player_d.cards = [1,10]
player_d.init_coin(1)
class GameManager(object):
STARTING_CHIPS = 100
def __init__(self):
self.dealer = Dealer()
self.quit = False
self.user = Player()
def setup(self):
print("\n")
print("WELCOME TO BLACKJACK!\n")
print("You will start with 100 chips")
print("Blackjack pays out 3:2.")
print("Double Down and Split bets can be less than or equal " +\
"to original bet.")
print("Only one card will be dealt to Double Down and Split hands.")
print("No insurance will be offered.")
print("Have Fun!\n\n\n")
def ask_to_quit(self):
"""Check if the user wants to quit the game"""
if self.user.get_chips() == 0:
print("Game Over, you have 0 chips remaining.")
self.quit = True
return True
user_input = input("Enter 'C' to continue or 'Q' to quit.\n")
while user_input != 'C' and user_input != 'Q':
user_input = input("Invalid input, enter 'C' to coninue " +\
"or 'Q' to quit.\n")
if user_input == 'Q':
self.quit = True
return True
return False
def get_bet(self):
"""Get a bet from the user through the command line"""
user_input = input("Enter integer ammount to bet.\n")
while True:
try:
bet = int(user_input)
assert (bet > 0 and bet <= self.user.get_chips())
return bet
except ValueError:
print("Bet must be an Integer.")
except AssertionError:
print("Valid bets are greater than 0 and less than {} chips."\
.format(self.user.get_chips()))
user_input = input("Enter integer ammount to bet.\n")
def play_hand(self, bet):
"""Logic for playing a hand of Blackjack is contained in this mehod"""
# Deal two cards to the user and the dealer
self.dealer.initial_deal(self.user)
self.display_table(self.user.get_hand(), bet, self.user.get_chips())
# Check if either hand is a blackjack and payout accordingly
dealer_bj = check_for_blackjack(self.dealer.get_hand())
user_bj = check_for_blackjack(self.user.get_hand())
if dealer_bj and user_bj:
print("Push")
print("Current chip total is {}.".format(self.user.get_chips()))
return
elif dealer_bj:
self.user.take_chips(bet)
self.display_table(self.user.get_hand(),
bet,
self.user.get_chips(),
hide_dealer=False)
print("Dealer has Blackjack. You lose.")
print("Current chip total is {}.".format(self.user.get_chips()))
return
elif user_bj:
payout = bet * 1.5
self.user.add_chips(math.ceil(payout))
print("Black Jack!")
print("Current chip total is {}.".format(self.user.get_chips()))
return
# Ask the user to Hit, Stand, Double Down, or Split
choice = self.user_choice(bet)
if choice == 'H':
while choice != 'S':
self.user.add_cards(self.dealer.deal())
self.display_table(self.user.get_hand(), bet,
self.user.get_chips())
if check_for_bust(self.user.get_hand()):
self.user.take_chips(bet)
print("BUST")
print("Current chip total is {}."\
.format(self.user.get_chips()))
return
choice = input("'H' to hit, 'S' to stand.\n")
while choice != 'H' and choice != 'S':
choice = input("Invalid input, please select 'H' to hit, "\
"'S' to stand.\n")
elif choice == 'D':
double_down = self.get_bet()
while double_down > bet or double_down > \
self.user.get_chips() - bet:
if double_down > self.user.get_chips() - bet:
print("Double down bet can't be greater than " +\
"your remiaining chips.")
else:
print("Double down bet must be less than or equal " +\
"to original bet.")
double_down = self.get_bet()
bet += double_down
self.user.add_cards(self.dealer.deal())
if check_for_bust(self.user.get_hand()):
self.display_table(self.user.get_hand(),
bet,
self.user.get_chips(),
hide_dealer=False)
self.user.take_chips(bet)
print("BUST")
print("Current chip total is {}.".format(
self.user.get_chips()))
return
elif choice == 'P':
split_bet = self.get_bet()
while split_bet > bet or split_bet > self.user.get_chips() - bet:
if split_bet > self.user.get_chips() - bet:
print("Split bet can't be greater than your " +\
"remiaining chips.")
else:
print("Split bet must be less than or equal to " +\
"original bet.")
split_bet = self.get_bet()
bet_total = bet + split_bet
hand_1 = Stack()
hand_2 = Stack()
hand_1 += self.user.get_hand().deal(1)
hand_1 += self.dealer.deal()
hand_2 += self.user.get_hand().deal(1)
hand_2 += self.dealer.deal()
if get_hand_total(self.dealer.get_hand()) < 17:
self.display_table(hand_1, bet_total, self.user.get_chips())
self.display_table(hand_2, bet_total, self.user.get_chips())
else:
self.display_table(hand_1,
bet_total,
self.user.get_chips(),
hide_dealer=False)
self.display_table(hand_2,
bet_total,
self.user.get_chips(),
hide_dealer=False)
while get_hand_total(self.dealer.get_hand()) < 17:
self.dealer.deal_dealer()
self.display_table(hand_1,
bet_total,
self.user.get_chips(),
hide_dealer=False)
self.display_table(hand_2,
bet_total,
self.user.get_chips(),
hide_dealer=False)
if check_for_bust(self.dealer.get_hand()):
self.user.add_chips(bet)
self.user.add_chips(split_bet)
print("DEALER BUSTS, YOU WIN!")
print("Current chip total is {}.".format(
self.user.get_chips()))
return
self.compare_hands(bet, hand_1)
self.compare_hands(split_bet, hand_2)
return
if choice != 'P':
self.display_table(self.user.get_hand(),
bet,
self.user.get_chips(),
hide_dealer=False)
while get_hand_total(self.dealer.get_hand()) < 17:
self.dealer.deal_dealer()
self.display_table(self.user.get_hand(),
bet,
self.user.get_chips(),
hide_dealer=False)
if check_for_bust(self.dealer.get_hand()):
self.user.add_chips(bet)
print("DEALER BUSTS, YOU WIN!")
print("Current chip total is {}.".format(self.user.get_chips()))
return
# If neither hand has busted, check which hand is higher and settle bet
self.compare_hands(bet, self.user.get_hand())
def clean_up_hand(self):
"""Clean up after hand is over"""
self.dealer.empty_hand()
self.user.empty_hand()
if len(self.dealer.deck) < self.dealer.cut_num:
self.dealer.reshuffle()
def compare_hands(self, bet, user_hand):
"""Compare hands to see which hand wins. An assumption this method
makes is that both hands are under 21."""
dealer_total = get_hand_total(self.dealer.get_hand())
user_total = get_hand_total(user_hand)
if dealer_total == user_total:
print("Push")
print("Current chip total is {}.".format(self.user.get_chips()))
elif dealer_total > user_total:
self.user.take_chips(bet)
print("House wins")
print("Current chip total is {}.".format(self.user.get_chips()))
else:
self.user.add_chips(bet)
print("Winner!")
print("Current chip total is {}.".format(self.user.get_chips()))
def display_table(self, hand, bet, chips_left, hide_dealer=True):
"""Display the current state of the table"""
dealer_cards = []
user_cards = []
print("#################################")
print(" POT: {:<3} | CHIPS LEFT: {:<3}".format(
bet, chips_left - bet))
print("---------------------------------")
print(" DEALER HAND | PLAYER HAND ")
for card in self.dealer.get_hand():
dealer_cards.append(self.card_to_print(card, hide_dealer))
hide_dealer = False
for card in hand:
user_cards.append(self.card_to_print(card))
difference = self.dealer.get_hand().size - hand.size
if difference < 0:
for i in range(difference * -1):
dealer_cards.append(self.card_to_print(place_holder=True))
elif difference > 0:
for i in range(difference):
user_cards.append(self.card_to_print(place_holder=True))
for i in range(max(len(dealer_cards), len(user_cards))):
for j in range(7):
print("{} | {}".format(dealer_cards[i][j], user_cards[i][j]))
def card_to_print(self, card=None, hide_dealer=False, place_holder=False):
"""Returs a printable representation of a playing card."""
lines = []
if place_holder:
lines.append(' ')
lines.append(' ')
lines.append(' ')
lines.append(' ')
lines.append(' ')
lines.append(' ')
lines.append(' ')
return lines
suit = SUITS[card.suit]
if card.value in VALUES:
value = VALUES[card.value]
else:
value = card.value
if hide_dealer:
lines.append(' ┌───────┐ ')
lines.append(' |*******| ')
lines.append(' |*******| ')
lines.append(' |*******| ')
lines.append(' |*******| ')
lines.append(' |*******| ')
lines.append(' └───────┘ ')
return lines
else:
suit = SUITS[card.suit]
if card.value in VALUES:
value = VALUES[card.value]
else:
value = card.value
lines.append(' ┌───────┐ ')
lines.append(' | {:<2} | '.format(value))
lines.append(' | | ')
lines.append(' | {} | '.format(suit))
lines.append(' | | ')
lines.append(' | {:>2} | '.format(value))
lines.append(' └───────┘ ')
return lines
def user_choice(self, bet):
"""Collect a choice from the user through the command line"""
choice = ''
while choice != 'H' and choice != 'S' and choice != 'D' \
and choice != 'P':
choice = input("Please select 'H' to hit, 'S' to stand, 'D' " + \
"to double-down, or 'P' to split.\n")
if choice == 'D' and self.user.get_chips() - bet == 0:
choice = ''
print("Invalid choice, you have no additional chips to bet.")
if choice == 'P' and self.user.get_chips() - bet == 0:
choice = ''
print("Invalid choice, you have no additional chips to bet.")
elif choice == 'P':
user_hand = self.user.get_hand()
card_list = []
for card in user_hand:
card_list.append(card)
if BJ_RANKS[card_list[0].value] != BJ_RANKS[
card_list[1].value]:
print("Invalid choice, you must have a pair to split.")
choice = ''
return choice
def run(self):
"""Run loop for the game manager"""
self.setup()
while not self.quit:
if not self.ask_to_quit():
bet = self.get_bet()
self.play_hand(bet)
self.clean_up_hand()
self.teardown()
def teardown(self):
"""Preform necessary teardown at the end of the game."""
if self.user.chips >= 100:
print("Congratulations you won {} dollars!".format(
self.user.get_chips() - 100))
else:
print("Better luck next time.")
print('****** WELCOME TO THE GAME OF BLACKJACK ******')
print('**********************************************')
print('\nHere are the rules:\n\
Get as close to 21 as you can without going over\n\
Dealer hits until they reach 17 \n\
Aces count as 1 or 11\n')
# Create & shuffle the deck, deal two cards to each player
deck = Deck(suits, ranks, values)
deck.shuffle()
player = Player()
player.add_card(deck.deal())
player.add_card(deck.deal())
dealer = Dealer()
dealer.add_card(deck.deal())
dealer.add_card(deck.deal())
# Set up the Player's chips (this occurs when the player is initialized.. not needed)
# Prompt the Player for their bet
player.ask_for_bet()
# Show cards (but keep one dealer card hidden)
player.show_all()
dealer.show_some()
while playing: # recall this variable from our hit_or_stand function
# Prompt for Player to Hit or Stand
def __init__(self, player_name, dealer_name):
#Create dealer and player
self.player = Player(player_name)
self.dealer = Dealer(dealer_name)
def test_get_values_k10(self):
hands = [Card('Hearts', 'King'),
Card('Spades', '10')]
dealer = Dealer()
self.assertEqual(20, dealer.get_values(hands))
class Game:
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 init_game(self):
self.deck_of_cards.shuffle()
self.prepare_players()
self.clean_table()
self.b_deal.unbind('<Button-1>')
self.b_deal.config(state='disabled')
self.b_hit.bind('<Button-1>',
lambda event: self.get_next_card(player_request=True))
self.b_hit.config(state='normal')
self.b_stand.bind('<Button-1>', lambda event: self.player_on_stand())
self.b_stand.config(state='normal')
self.red_chip_label.unbind('<Button-1>')
self.blue_chip_label.unbind('<Button-1>')
self.green_chip_label.unbind('<Button-1>')
self.instruction_label.config(text="")
self.get_next_card(player_request=True, init=True)
self.get_next_card(player_request=False, init=True, visible=False)
self.get_next_card(player_request=True, init=True)
self.get_next_card(player_request=False)
self.player.subtract_from_current_money(self.bet)
self.dealer.subtract_from_current_money(self.bet)
self.update_money()
def prepare_players(self):
self.player.prepare_to_new_round()
self.dealer.prepare_to_new_round()
def clean_table(self):
for player_label in self.player_card_labels:
player_label.place_forget()
for dealer_label in self.dealer_card_labels:
dealer_label.place_forget()
def get_next_card(self, player_request, init=False, visible=True):
card = self.deck_of_cards.get_card()
card.set_visible(visible)
if player_request:
current_player = self.player
else:
current_player = self.dealer
current_player.set_card(card)
self.show_on_screen(player_request, card)
current_player.set_points(self.count_scoring(current_player))
self.update_score_table(player_request)
if not init:
self.check_if_is_21_or_more()
def show_on_screen(self, on_player_side, card):
card_i = Image.open(card.get_path()).resize(card_size, Image.ANTIALIAS)
card_i_tk = ImageTk.PhotoImage(card_i)
if on_player_side:
index = self.player.get_current_card_index() - 1
self.player_card_labels[index].configure(image=card_i_tk)
self.player_card_labels[index].image = card_i_tk
self.player_card_labels[index].place(
x=player_card_layout[index][0], y=player_card_layout[index][1])
else:
index = self.dealer.get_current_card_index() - 1
if not card.is_visible():
card_i = Image.open(card_path + "back.png").resize(
card_size, Image.ANTIALIAS)
card_i_tk = ImageTk.PhotoImage(card_i)
self.dealer_card_labels[index].configure(image=card_i_tk)
self.dealer_card_labels[index].image = card_i_tk
self.dealer_card_labels[index].place(
x=dealer_card_layout[index][0], y=dealer_card_layout[index][1])
def count_scoring(self, current_player):
points = current_player.count_points()
if points > 21:
if current_player.get_number_of_aces() > 0:
return current_player.count_points(aces_as_one_point=True)
else:
return points
else:
return points
def update_score_table(self, player_request):
if player_request:
self.player_score_label.config(text="You = " +
str(self.player.get_points()))
else:
self.dealer_score_label.config(text="Dealer = " +
str(self.dealer.get_points()))
def check_if_is_21_or_more(self):
player_points = self.player.get_points()
dealer_points = self.dealer.get_points()
if player_points > 20 or dealer_points > 20:
if player_points == 21 and dealer_points == 21:
self.instruction_label.config(text="PUSH !")
self.player.add_to_current_money(self.bet)
self.dealer.add_to_current_money(self.bet)
elif player_points == 21 or dealer_points > 21:
self.instruction_label.config(
text="You won ! Press 'DEAL' to try again.")
self.player.add_to_current_money(self.bet * 2)
elif player_points > 21 or dealer_points == 21:
self.instruction_label.config(
text="Dealer won. Press 'DEAL' to try again.")
self.dealer.add_to_current_money(self.bet * 2)
# end game
self.update_money()
self.end_game()
def player_on_stand(self):
self.dealer_turn()
if self.player.get_points() < 21 and self.dealer.get_points() < 21:
self.check_who_win()
else:
self.check_if_is_21_or_more()
def end_game(self):
self.update_score_table(player_request=False)
self.show_dealer_hidden_card()
self.b_deal.bind('<Button-1>',
lambda event: self.ask_for_change_bets())
self.b_deal.config(state='normal')
self.b_hit.config(state='disabled')
self.b_hit.unbind('<Button-1>')
self.b_stand.config(state='disabled')
self.b_stand.unbind('<Button-1>')
def show_dealer_hidden_card(self):
cards = self.dealer.get_cards()
cards[0].set_visible(True)
card_i = Image.open(cards[0].get_path()).resize(
card_size, Image.ANTIALIAS)
card_i_tk = ImageTk.PhotoImage(card_i)
self.dealer_card_labels[0].configure(image=card_i_tk)
self.dealer_card_labels[0].image = card_i_tk
self.dealer.set_points(self.count_scoring(self.dealer))
self.update_score_table(player_request=False)
def dealer_turn(self):
self.show_dealer_hidden_card()
while self.dealer.is_sure_to_get_card():
self.get_next_card(player_request=False, init=True)
# extra method to check who has more points but under 21
def check_who_win(self):
self.end_game()
if self.player.get_points() > self.dealer.get_points():
self.instruction_label.config(
text="You won ! Press 'DEAL' to try again.")
self.player.add_to_current_money(self.bet * 2)
elif self.player.get_points() < self.dealer.get_points():
self.instruction_label.config(
text="Dealer won. Press 'DEAL' to try again.")
self.dealer.add_to_current_money(self.bet * 2)
elif self.player.get_points() == self.dealer.get_points():
self.instruction_label.config(text="PUSH !")
self.player.add_to_current_money(self.bet)
self.dealer.add_to_current_money(self.bet)
self.update_money()
def update_money(self):
self.player_money_label.config(text="You = $" +
str(self.player.get_money()))
self.dealer_money_label.config(text="Dealer = $" +
str(self.dealer.get_money()))
def ask_for_change_bets(self):
self.instruction_label.config(
text="You can optionally change bet and then 'DEAL'")
self.b_deal.bind('<Button-1>', lambda event: self.init_game())
self.red_chip_label.bind('<Button-1>', lambda event: self.set_bets(1))
self.blue_chip_label.bind('<Button-1>', lambda event: self.set_bets(2))
self.green_chip_label.bind('<Button-1>',
lambda event: self.set_bets(5))
def set_bets(self, bet):
self.bet = bet
self.bets_label.config(text="$" + str(bet))
def test_get_card(self):
dealer = Dealer()
for index in range(0, len(self.deck)):
hand = dealer.get_card()
self.assertIn(hand, self.deck)
def test__create_deck(self):
dealer = Dealer()
deck = dealer._create_deck()
self.assertEqual(self.deck, deck)
def __init__(self):
self.player = Player()
self.dealer = Dealer()
self.deck = Deck()
self.discarded = self.deck.discarded
class Blackjack():
"""Implements blackjack game specification"""
#Methods accessed from within this class (Private Methods)
def __init__(self, player_name, dealer_name):
#Create dealer and player
self.player = Player(player_name)
self.dealer = Dealer(dealer_name)
def PRINT(self, message, sleep_seconds=0):
"""Custom print function. Prints a given formatted string and sleeps for given seconds"""
print(message + '\n')
if (sleep_seconds > 0):
time.sleep(sleep_seconds)
def declare_result(self, winner, loser, result):
"""Declares result with winner/loser"""
if (result == 'BLACKJACK'):
self.PRINT(
Fore.LIGHTGREEN_EX + f"{winner} hits blackjack and WINS!!!", 3)
elif (result == 'BUSTED'):
self.PRINT(
Fore.LIGHTRED_EX + f"{loser} busts and LOSES... " +
Fore.LIGHTGREEN_EX + f"and {winner} WINS !!!!", 3)
def deal_card_to_player(self, dealer, player):
"""Deals a card to player. If dealt card is ACE, asks user to select between 1 and 11."""
self.PRINT(Fore.LIGHTYELLOW_EX + f"\nDealing card to {player.name}...",
2)
card = dealer.deal_a_card()
#handle Ace condition for player. Ask his input
if (card.rank.upper() == 'A' or card.rank.upper() == 'ACE'):
user_ace_value = int(
input(
f"You have an Ace. How do you want to take it (1 or 11)?: "
))
print(Fore.LIGHTYELLOW_EX +
f"{player.name} decided take Ace as {user_ace_value}")
if (user_ace_value == 1):
card.rank = 'A'
elif (user_ace_value == 11):
card.rank = 'Ace'
player.take_card(card)
self.PRINT(
Fore.YELLOW + f"Card dealt is '{card}'. " + Fore.LIGHTYELLOW_EX +
f"{player.name}\'s current score is: {player.cards_sum}", 2)
def deal_card_to_dealer(self, dealer, show_current_score):
"""Deals a card to dealer. If dealt card is an ACE, automatically determines 1 or 11 and takes
most appropriate value for the current game."""
if (show_current_score == True):
self.PRINT(
Fore.LIGHTCYAN_EX + f"\nDealing card to {dealer.name}...", 2)
else:
self.PRINT(
Fore.LIGHTCYAN_EX +
f"\nDealing card to {dealer.name} face down (no display of score)...",
2)
card = dealer.deal_a_card()
#at dealer end, handle Ace card smartly.
if (card.rank.upper() == 'A' or card.rank.upper() == 'ACE'):
if (
dealer.cards_sum == 0
or (dealer.cards_sum >= 6 and dealer.cards_sum < 11)
): #check for less than 11. If first card is 11 then dont take second also 11.
card.rank = 'Ace'
else:
card.rank = 'A'
dealer.take_card(card)
if (show_current_score == True
): #print only first card. second is considered face down
self.PRINT(
Fore.CYAN + f"Card dealt is '{card}'. " + Fore.LIGHTCYAN_EX +
f"{dealer.name}\'s current score is: {dealer.cards_sum}", 2)
def did_i_bust(self, checkme):
return (checkme.cards_sum > 21)
def did_i_hit_blackjack(self, checkme):
return (checkme.cards_sum == 21)
#Methods accessed by outsiders (Public Methods)
def deal_first_two_cards(self):
"""Handles dealing of first two cards to player and dealer. Dealer's second card is dealt face down."""
is_game_over_in_first_two_cards = False
for idx in [1, 2]:
#deal card to player
self.deal_card_to_player(self.dealer, self.player)
if (self.did_i_hit_blackjack(self.player)):
self.declare_result(self.player.name, self.dealer.name,
'BLACKJACK')
is_game_over_in_first_two_cards = True
break
#deal card to dealer
self.deal_card_to_dealer(self.dealer, (idx == 1))
return is_game_over_in_first_two_cards
def player_plays_the_game(self):
"""Player's game until player decides to STAND or wins blackjack or busts"""
is_players_game_over = False
self.PRINT(
Fore.LIGHTYELLOW_EX +
f"{self.player.name}\'s current score is {self.player.cards_sum}")
player_decision = input("Hit or Stand?(h-to continue / s-to stop)?: ")
self.player.update_decision(player_decision)
#deal cards to player
while (self.player.hitting):
self.deal_card_to_player(self.dealer, self.player)
if (self.did_i_hit_blackjack(self.player)):
self.declare_result(winner=self.player.name,
loser=self.dealer.name,
result='BLACKJACK')
is_players_game_over = True
break
elif (self.did_i_bust(self.player)):
self.declare_result(loser=self.player.name,
winner=self.dealer.name,
result='BUSTED')
is_players_game_over = True
break
self.PRINT(
Fore.LIGHTYELLOW_EX +
f"{self.player.name}\'s current score is {self.player.cards_sum}"
)
player_decision = input(
"Hit or Stand?(h-to continue / s-to stop)?: ")
self.player.update_decision(player_decision)
#end of while
if (self.player.hitting == False):
self.PRINT(
Fore.LIGHTYELLOW_EX +
f"\n{self.player.name} decided to STAND at {self.player.cards_sum}",
2)
return is_players_game_over
def dealer_plays_the_game(self):
"""Dealer's game until dealer decides to STAND or wins blackjack or busts"""
is_dealers_game_over = False
#deal cards to house...
self.PRINT(
Fore.LIGHTCYAN_EX +
f"Flipping the card to face up of {self.dealer.name}...", 2)
flipped_card = self.dealer.peek()
self.PRINT(
Fore.LIGHTCYAN_EX +
f"Flippeed card was '{flipped_card}'. {self.dealer.name}\'s current score is: {self.dealer.cards_sum}",
2)
while (self.dealer.iam_in_game_range() == False):
if (self.did_i_hit_blackjack(self.dealer)):
self.declare_result(winner=self.dealer.name,
loser=self.player.name,
result='BLACKJACK')
is_dealers_game_over = True
break
elif (self.did_i_bust(self.dealer)):
self.declare_result(loser=self.dealer.name,
winner=self.player.name,
result='BUSTED')
is_dealers_game_over = True
break
if (self.dealer.iam_in_game_range()):
break
self.deal_card_to_dealer(self.dealer, True)
#end of while
return is_dealers_game_over
def determine_the_winner(self):
"""Determines the winner by comparing player's and dealer's scores."""
result = ''
if (self.player.cards_sum == self.dealer.cards_sum):
result = Fore.LIGHTBLUE_EX + f"Damn, Its a DRAWWWWWWW......."
elif (self.player.cards_sum > self.dealer.cards_sum):
result = Fore.LIGHTGREEN_EX + f"Hurrrrayyyyy [{self.player.name}] WINS !!!!!!!!!"
else:
result = Fore.LIGHTGREEN_EX + f"...And the Mighty <{self.dealer.name}> WINS !!!!!!!!"
return result
def shuffle_deck(self):
"""Shuffles the deck"""
self.PRINT(
Fore.LIGHTWHITE_EX + Style.BRIGHT + f"\n.....Shuffling deck.....",
3)
self.dealer.shuffle_deck()
def display_both_players_cards(self):
print(Fore.LIGHTYELLOW_EX + f"Players cards: ",
*self.player.player_cards,
sep=', ')
print(Fore.LIGHTCYAN_EX + f"Dealers cards: ",
*self.dealer.dealer_cards,
sep=', ')
def __init__(self, player=None):
self.dealer = Dealer()
self.player = player
self.deck = Deck()
self.game_counter = 0
self.remaining_cards = GAME_DECK_SIZE
def test_cheater(self):
dealer = Dealer.create_initial(
[Player(), Player(),
Player(), Cheater(),
Player()])
class TestDealer(unittest.TestCase):
def setUp(self):
# Traits (Trait, Food-value)
self.carnivore = TraitCard(CARNIVORE, 3)
self.burrowing = TraitCard(BURROWING, 2)
self.fattissue = TraitCard(FATTISSUE, 2)
self.foraging = TraitCard(FORAGING, 2)
self.horns = TraitCard(HORNS, 0)
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.horns, self.foraging],
self.player1_species,
ext_player=Player())
self.player2 = PlayerState(2,
3, [self.carnivore, self.fattissue],
self.player2_species,
ext_player=Player())
self.player3 = PlayerState(3,
6, [self.burrowing],
self.player3_species,
ext_player=Player())
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, [])
# Action
self.action4_1 = Action4(FoodCardAction(1),
[GrowAction(POPULATION, 0, 0)], [], [], [])
self.action4_2 = Action4(FoodCardAction(0), [], [], [],
[ReplaceTraitAction(1, 0, 1)])
self.action4_3 = Action4(FoodCardAction(0), [], [], [], [])
self.action4_list = [self.action4_1, self.action4_2, self.action4_3]
def test_make_deck(self):
deck = Dealer.make_deck()
self.assertEqual(len(deck), LOC_MAX)
self.assertEqual(len(deck), len(set(deck)))
def test_deal_cards(self):
self.dealer1.deck = Dealer.make_deck()
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX, 2])
self.dealer1.deal_cards(self.player1, 10)
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX - 10, 12])
def test_public_players(self):
public_players = self.dealer1.public_players(self.player1)
self.assertTrue(public_players[0].equal_attributes(
self.public_player2))
self.assertTrue(public_players[1].equal_attributes(
self.public_player3))
def test_cheater(self):
dealer = Dealer.create_initial(
[Player(), Player(),
Player(), Cheater(),
Player()])
#result = dealer.run_game()
#print result
def test_step4(self):
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.step4(self.action4_list)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: removed cards: [horns, 0], [foraging, 2], '
'Species 0: [[population, 1->2], [food, 0->2]], '
'Species 1: [[food, 2->4]], '
'Player 2: removed cards: [carnivore, 3], [fat-tissue, 2], '
'Species 0: [[fat-tissue, 0->1]], '
'Species 1: [[traits: [0, [burrowing, 2]->[fat-tissue, 2]]], [fat-tissue, False->5]], '
'Player 3: removed cards: [burrowing, 2], '
'Species 0: [[fat-tissue, 0->7]], '
'[watering_hole, 10->0]')
def test_auto_feed1(self):
# Herbivore
self.species2.food = 6
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->1]], [watering_hole, 10->9]')
# Fat-tissue
self.species5.food = 5
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 2: Species 0: [[fat-tissue, 0->3]], [watering_hole, 9->6]')
# Carnivore
self.species7.food, self.species6.fat_storage = (7, 7)
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 1->2]], '
'Player 1: Species 1: [[population, 6->5], [food, 6->5]], '
'[watering_hole, 6->5]')
# NoFeeding
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEqual(old_dealer.show_changes(self.dealer1),
'Player 1: [active, True->False]')
def test_feed_species(self):
# Regular Feeding
herbivore_feeding = HerbivoreFeeding(1)
self.species2.traits = []
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 1: [[food, 2->3]], '
'[watering_hole, 10->9]')
# Cooperation Feeding
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding = HerbivoreFeeding(0)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->1]], Species 1: [[food, 3->4]], '
'[watering_hole, 9->7]')
# Foraging and Cooperation
self.species1.population, self.species1.food = (3, 0)
self.species1.traits.append(self.foraging)
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->2]], Species 1: [[food, 4->6]], '
'[watering_hole, 7->3]')
# Cooperation Chain / Watering Hole runs out
self.player1.species.append(self.species5)
self.player2.species.remove(self.species5)
self.species2.food, self.species2.traits, self.dealer1.watering_hole = (
4, [self.cooperation, self.foraging], 4)
old_dealer = copy.deepcopy(self.dealer1)
herbivore_feeding.handle_feeding(self.dealer1, self.player1)
self.assertEqual(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 2->3]], Species 1: [[food, 4->6]], Species 2: [[food, 3->4]], '
'[watering_hole, 4->0]')
def test_handle_attack_situation(self):
# Regular Attack
old_dealer = copy.deepcopy(self.dealer1)
attack_choice = CarnivoreFeeding(0, 0, 0)
attack_choice.handle_attack_situation(self.species2, self.species3,
self.player1, self.player2,
self.dealer1)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 2: Species 0: [[population, 3->2], [food, 3->2]]')
# Horns
old_dealer = copy.deepcopy(self.dealer1)
attack_choice.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3,
self.dealer1)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 1: [[population, 6->5]], Player 3: Species 1: [[population, 7->6]]'
)
# Double Extinction
self.species2.population = 1
self.species7.population = 1
self.dealer1.deck = [self.foraging, self.scavenger, self.cooperation]
old_dealer = copy.deepcopy(self.dealer1)
attack_choice.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3,
self.dealer1)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 1: new cards: [cooperation, 1], '
'Species 1: Species removed, '
'Player 3: new cards: [foraging, 2], [scavenger, 2], '
'Species 1: Species removed, '
'deck: removed cards: [foraging, 2], [scavenger, 2], [cooperation, 1]'
)
def test_handle_scavenging(self):
# Regular
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed_trait(SCAVENGER)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 1->2]], '
'[watering_hole, 10->9]')
# Foraging
self.species6.population, self.species6.traits[0] = (6, self.foraging)
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed_trait(SCAVENGER)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 2->4]], '
'[watering_hole, 9->7]')
# Cooperation
self.species6.traits[1] = self.cooperation
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed_trait(SCAVENGER)
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 3: Species 0: [[food, 4->6]], Species 1: [[food, 1->3]], '
'[watering_hole, 7->3]')
def test_show_changes(self):
old_dealer = copy.deepcopy(self.dealer1)
self.dealer1.feed1()
self.assertEquals(
old_dealer.show_changes(self.dealer1),
'Player 1: Species 0: [[food, 0->1]], Species 1: [[food, 2->3]], '
'[watering_hole, 10->8]')
class TestDealer(unittest.TestCase):
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.player1_species)
self.player2 = PlayerState(2, 3, [self.carnivore, self.fattissue],
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, [])
def test_make_deck(self):
deck = Dealer.make_deck()
self.assertEqual(len(deck), LOC_MAX)
self.assertEqual(len(deck), len(set(deck)))
def test_deal_cards(self):
self.dealer1.deck = Dealer.make_deck()
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX, 0])
self.dealer1.deal_cards(self.player1, 10)
self.assertEqual([len(self.dealer1.deck),
len(self.player1.hand)], [LOC_MAX - 10, 10])
def test_public_players(self):
public_players = self.dealer1.public_players(self.player1)
self.assertTrue(public_players[0].equal_attributes(
self.public_player2))
self.assertTrue(public_players[1].equal_attributes(
self.public_player3))
def test_feed1(self):
# Auto-feeding
self.species3.fat_storage = 3
self.dealer1.list_of_players, self.dealer1.watering_hole = ([
self.player2, self.player1, self.player3
], 20)
self.assertEqual([self.species5.food, self.dealer1.watering_hole],
[3, 20])
self.dealer1.feed1()
self.assertEqual([self.species5.food, self.dealer1.watering_hole],
[5, 18])
# NoFeeding
self.assertTrue(self.player2.active)
self.dealer1.feed1()
self.assertEqual([
self.species5.food, self.dealer1.watering_hole, self.player2.active
], [5, 18, False])
# HerbivoreFeeding
self.species2.traits.pop()
self.dealer1.list_of_players = [
self.player1, self.player2, self.player3
]
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole,
self.player1.active
], [0, 2, 18, True])
self.dealer1.feed1()
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole,
self.player1.active
], [0, 3, 17, True])
# FatFeeding
self.dealer1.list_of_players = [
self.player3, self.player2, self.player1
]
self.assertEqual(
[self.species6.fat_storage, self.dealer1.watering_hole], [0, 17])
self.dealer1.feed1()
self.assertEqual(
[self.species6.fat_storage, self.dealer1.watering_hole], [7, 10])
# CarnivoreFeeding
self.species7.traits.append(self.carnivore)
self.assertEqual([
self.species2.population, self.species7.food, self.species6.food,
self.dealer1.watering_hole
], [6, 1, 1, 10])
self.dealer1.feed1()
self.assertEqual([
self.species2.population, self.species7.food, self.species6.food,
self.dealer1.watering_hole
], [5, 2, 2, 8])
def test_feed_species(self):
# Regular Feeding
self.assertEqual([self.species2.food, self.dealer1.watering_hole],
[2, 10])
self.dealer1.feed_species(self.species2, self.player1)
self.assertEqual([self.species2.food, self.dealer1.watering_hole],
[3, 9])
# Cooperation Feeding
self.assertEqual(self.species1.food, 0)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole
], [1, 4, 7])
# Foraging and Cooperation
self.species1.population, self.species1.food = (3, 0)
self.species1.traits.append(self.foraging)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([
self.species1.food, self.species2.food, self.dealer1.watering_hole
], [2, 6, 3])
# Cooperation Chain / Watering Hole runs out
self.player1.species.append(self.species5)
self.species2.food, self.species2.traits, self.dealer1.watering_hole = (
4, [self.cooperation, self.foraging], 4)
self.dealer1.feed_species(self.species1, self.player1)
self.assertEqual([
self.species1.food, self.species2.food, self.species5.food,
self.dealer1.watering_hole
], [3, 6, 4, 0])
def test_handle_attack_situation(self):
# Regular Attack
self.assertEqual([self.species3.population, self.species3.food],
[3, 3])
self.dealer1.handle_attack_situation(self.species2, self.species3,
self.player1, self.player2)
self.assertEqual([self.species3.population, self.species3.food],
[2, 2])
# Horns
self.assertEqual([self.species2.population, self.species7.population],
[6, 7])
self.dealer1.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3)
self.assertEqual([self.species2.population, self.species7.population],
[5, 6])
# Double Extinction
self.species2.population = 1
self.species7.population = 1
self.dealer1.deck = [self.foraging, self.scavenger, self.cooperation]
self.dealer1.handle_attack_situation(self.species2, self.species7,
self.player1, self.player3)
self.assertEqual([
self.species2.population, self.species7.population,
self.player1.hand, self.player3.hand, self.dealer1.deck
], [
0, 0, [self.cooperation],
[self.burrowing, self.foraging, self.scavenger], []
])
self.assertFalse(self.species2 in self.player1.species)
self.assertFalse(self.species7 in self.player3.species)
def test_handle_scavenging(self):
# Regular
self.assertEqual([self.species6.food, self.dealer1.watering_hole],
[1, 10])
self.dealer1.handle_scavenging()
self.assertEqual([self.species6.food, self.dealer1.watering_hole],
[2, 9])
# Foraging
self.species6.population, self.species6.traits[0] = (6, self.foraging)
self.dealer1.handle_scavenging()
self.assertEqual([self.species6.food, self.dealer1.watering_hole],
[4, 7])
# Cooperation
self.species6.traits[1] = self.cooperation
self.assertEqual([
self.species6.food, self.species7.food, self.dealer1.watering_hole
], [4, 1, 7])
self.dealer1.handle_scavenging()
self.assertEqual([
self.species6.food, self.species7.food, self.dealer1.watering_hole
], [6, 3, 3])
new_deck = Deck()
new_deck.ShuffleDeck()
print(new_deck)
pl_hand = Player()
pl_hand.CreateHand(new_deck)
print(pl_hand)
pl_hand.Bet(3000) #Error - over balance
pl_hand.Bet(200)
pl_hand.DisplayBalance() # Should be 800
print("Player Cards total: " + str(pl_hand.CalculateTotal()))
dealer_hand = Dealer(new_deck)
dealer_hand.CreateHand()
print(dealer_hand)
print("dealer Cards total: " + str(dealer_hand.CalculateTotal()))
print("Dealer Full Hand:")
dealer_hand.PrintAll()
class OverUnder:
''' The game Over-Under is a simple guessing game where in a dealer
and a guesser play for points. A dealer deals out one facedown card
and a faceup card and the guesser guesses if tha facedown card is over
or under the faceup one. If he is correct he gets a point otherwise the
dealer gets a point. A half deck is used for the game.
'''
def __init__(self, player=None):
self.dealer = Dealer()
self.player = player
self.deck = Deck()
self.game_counter = 0
self.remaining_cards = GAME_DECK_SIZE
def guesser_won(self, facedown, faceup, guess):
return (guess == "l" and facedown < faceup) or (guess == "h" and facedown > faceup)
def print_score(self):
print("Guesser: {0} points, Dealer {1} points".format(self.player.points, self.dealer.points))
def pre_guess_prompt(self, faceup):
if not self.player.isRobot:
self.print_score()
print(ascii_version_of_hidden_card(faceup))
def card_reveal(self, facedown, faceup):
if not self.player.isRobot:
self.print_score()
print(ascii_version_of_card(facedown, faceup))
input("Press enter for next draw...")
clear_screen()
def update_score(self, facedown, faceup, guess):
if self.guesser_won(facedown, faceup, guess):
self.player.add_point()
else:
self.dealer.add_point()
if not self.player.isRobot:
clear_screen()
def find_winner(self):
self.game_counter = self.game_counter + 1
return self.dealer if self.player < self.dealer else self.player
def print_winner(self, winner):
if not winner.isRobot:
self.print_score()
print("Winner is {0} with {1} points. Congratulations!".format(winner.name, winner.points))
input("Press enter to exit")
def reset(self):
self.deck = Deck()
self.dealer.points = 0
self.player.points = 0
self.remaining_cards = GAME_DECK_SIZE
def discard_used_cards(self):
self.remaining_cards = self.remaining_cards - 2
def play(self):
while self.remaining_cards > 0:
faceup = self.deck.deal_card()
self.pre_guess_prompt(faceup)
guess = self.player.get_guess(faceup)
facedown = self.deck.deal_favorable_dealer_card(faceup, guess)
self.update_score(facedown, faceup, guess)
self.card_reveal(facedown, faceup)
self.discard_used_cards()
winner = self.find_winner()
self.print_winner(winner)
return winner.name
def test_dealer_estimation(self):
value = Dealer.get_estimated_inner_value(0b000111, 3, 6)
self.assertEqual(value, 1.5)
def play(self):
self.dealer = Dealer()
self.player = Player()
while True:
self.play_round()
if suit in card:
for name in self.dict_deck[suit].keys():
if name in card:
total += self.dict_deck[suit].get(name)
return total
def create_dict_deck(self):
card_values = dict(self.values)
self.dict_deck = dict((suits, card_values) for suits in self.suits)
return self.dict_deck
def return_values(self):
total = 0
for card in self.tup:
total += self.dict_deck[card[1]][card[0]]
return total
deck = Deck()
deck.create_deck(1)
dealer = Dealer(deck)
gamehand = GameHand(dealer)
# gamehand.start_hand()
# print(gamehand.cards_in_hand)
score = Score(gamehand)
score.create_dict_deck()
# print(score.dict_deck)
print(score.ace())
# print(score.dict_deck)
print(score.x())
def play_one_round(self):
# Create new dealer for every round
dealer = Dealer()
# Clear the pot by setting it to small + big blinds
self.pot = 3
self.winner = None
# Player 0 is always small blind and Player 1 is always big blind
self.players[0].set_blind(0)
self.players[1].set_blind(1)
self.players[0].set_cards(dealer.deal_pockets())
self.players[1].set_cards(dealer.deal_pockets())
self.show_game_status()
# Three steps, they are pre-flop, pre-turn, pre-river respectively
if self.play_one_state(0): # pre-flop
dealer.deal_flop()
self.show_game_status()
if self.play_one_state(1): # pre-turn
self.show_game_status()
dealer.deal_turn()
if self.play_one_state(1): # pre-river
dealer.deal_river()
pass
pass
pass
pass
# Find the winner of the round
if self.winner is not None:
self.winner.increase_stack(self.pot)
pass
else:
for player in self.players:
player.show_cards()
pass
pass
winner_id = winner(self.players[0], self.players[1],
dealer.communitycards)
print("Debugging Test winner_id : " + str(winner_id))
# Restore the original hands
for loop_i in range(6, 1, -1):
for player in self.players:
player.hands.pop(loop_i)
pass
pass
pass
# Winner get the pot. If it's a tie, halve the pot respectively
if winner_id is not None:
for player in self.players:
if player.check_id(winner_id):
player.increase_stack(self.pot)
self.winner = player
break
pass
pass
pass
else:
for player in self.players:
player.increase_stack(self.pot / 2)
pass
pass
pass
self.show_game_status()
pass
def main(args=None):
assert version_info.major == 3 and version_info.minor == 8, "Ensure python version (= 3.8)"
""" SETUP """
if args is None:
args = parse_args()
global loglevel
loglevel = LogLevel[args.log]
l, k, t = args.l, args.k, args.t
log(f"Participating players: {l}, Number of collaborating players (Quorom size): {k}, Maximum number of corrupt players: {t}")
assert l >= t + \
k, ("total number of participating players has to be larger than number of collaborating players and corrupt players combined")
assert k >= t + \
1, ("the minimum requried number of collaborating parties has to be at least one larger than the maximum number of corrupt parties")
primegen_method = args.primegen
log(f"Prime generation method: {primegen_method}")
"""
THE DEALER
Generates safe primes for the public key modulus.
Deals secret key shares and verification key shares.
"""
bitlength = args.bitlength
log(f"Bitlength of primes: {bitlength}")
# the fourth Fermat number - basically just a large number known to be prime
e = pow(2, pow(2, 4)) + 1
assert e > l, "e has to be a prime larger than number of players"
players = [Player() for _ in range(l)]
dealer = Dealer(bitlength, e, primegen_method)
# Shared values
n, e = dealer.public_key
v, u, m = dealer.v, dealer.u, dealer.m
log(f"Bitlength of modulus: {n.bit_length()}")
message = args.message
log(f"message: {message}", LogLevel.VERBOSE)
delta = factorial(l)
protocol = None
if k == t + 1:
log("Protocol 1")
protocol = Protocol1(message=message, n=n, delta=delta, m=m)
else:
# k > t + 1:
log("Protocol 2")
protocol = Protocol2(message=message, n=n, delta=delta, m=m, u=u, e=e)
vks = dealer.deal(players, k, protocol)
# Dealer is no longer used
del dealer
# Hashed message
x = protocol.get_hashed_message()
log(f"hashed message: {x}", LogLevel.VERBOSE)
"""
COMBINING SHARES
Combines signature shares to get a signature.
We simulate that we receive generated signature shares from k players.
"""
from random import sample
S = sample(range(1, l + 1), k)
log(f"Combining shares of players {S}", LogLevel.VERBOSE)
w = 1
for i in S:
x_i, poc_i = players[i-1].generate_signature_share(delta, protocol)
# verify proof of correctness
verify_poc(protocol, x, vks, i, poc_i, v, x_i, n)
# combine signature share
lambda_S_0i = lambda_(delta, 0, i, S)
temp = powmod(x_i, 2 * lambda_S_0i, n)
w = (w * temp) % n
log(f"w: {w}", LogLevel.VERBOSE)
e_prime = protocol.calculate_e_prime()
gcd, a, b = xgcd(e_prime, e)
assert gcd == 1, "gcd(e', e) != 1"
xe_prime = powmod(x, e_prime, n)
we = powmod(w, e, n)
assert we == xe_prime, "w^e != x^e'"
assert e_prime * a + e * b == 1, "e'a + eb != 1"
wa = powmod(w, a, n)
xb = powmod(x, b, n)
y = protocol.calculate_y(wa, xb)
ye = powmod(y, e, n)
log(f"y^e: {ye}", LogLevel.VERBOSE)
assert ye == H(message, n), "Invalid message signature"
log("Message signature was valid!", LogLevel.DEFAULT)
import os
import time
from slackclient import SlackClient
from dealer import Dealer
from admin import Admin
# possible commands, dealer will handle what to do with them
blackjack_actions = ['!show', '!bet', '!play', '!hit', '!double', '!stay']
# admin user ids
admin_ids = [os.environ.get('ADMIN_ID')]
# instantiate the dealer
dealer = Dealer()
admin = Admin(dealer)
# instantiate Slack
slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN'))
def handle_command(command, user, channel):
# Admin commands that only I can send
if command.split(' ', 1)[0] == "!admin":
if user in admin_ids:
admin.admin_do(command, user)
else:
response = "You do not have permission to execute this command"
slack_client.api_call("chat.postMessage",
channel=channel,
text=response,
as_user=True)
def main():
"""Main routine for Crazy Eight's"""
#create player objects and data structures
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))
#setup pygame
pygame.init()
pygame.display.set_caption("Crazy Eights!")
screen = pygame.display.set_mode((1000, 700))
screen.fill((0, 200, 0)) #set green background
#display game title on screen
font = pygame.font.Font(None, 48)
text = font.render("Crazy Eight!", 1, (10, 10, 10))
textpos = text.get_rect()
textpos.centerx = screen.get_rect().centerx
screen.blit(text, textpos)
pycards = Cards()
print("...Setup Complete. Enjoy the game!...\n")
#play game
running = True
while (c8_player.count() > 0 and c8_opponent.count() > 0 and running):
#check for quit event
for event in pygame.event.get():
if event.type == pygame.QUIT:
running == False
cardinplay = in_play(c8_dealer)
dispcard = cardinplay[1] + "of" + cardinplay[0]
#print("\nCard In Play Is:", dispcard, "\n")
pycards.carddisplay(screen, dispcard,
(470, 250)) #card in center of screen
#display user's cards
x, y = 230, 550
card_plot = dict()
for card in c8_player.hand:
dispcard = card[1] + "of" + card[0]
card_rect = pycards.carddisplay(screen, dispcard, (x, y))
x += 75
card_plot[card] = card_rect
#print(card_plot.keys())
pygame.display.flip()
#wait for user to select card on screen to play
cardselect = True
while cardselect:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos
for card in card_plot:
if card_plot[card].collidepoint(x, y):
#print("you clicked", card)
cardselected = card
cardselect = False
#print("Calling player_play with",cardselected)
stat = player_play(cardselected, c8_player, c8_dealer)
if (stat == "empty"):
print("...Deck is empty. Exiting...")
#break
running = False
else:
stat = game_play(c8_opponent, c8_dealer)
if stat == "empty":
print("...Deck is empty. Exiting...")
#break
running = False
screen.fill((0, 200, 0)) #refresh background
screen.blit(text, textpos) #label
if (c8_player.count() == 0):
print("Yay! You won!")
elif (c8_opponent.count() == 0):
print("Computer won. Better luck next time!")
pygame.quit()
def lambda_handler(event, context):
dto = Dealer(None)
ret_val = dto.getall()
response = {'statusCode': 200, 'body': json.dumps({'result': ret_val})}
return response
def test_make_deck(self):
deck = Dealer.make_deck()
self.assertEqual(len(deck), LOC_MAX)
self.assertEqual(len(deck), len(set(deck)))
class Table:
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 = []
def play(self):
"""
Gets the dealers hidden card and gives each player a card before starting the
while loops to let the blackjackplayer take turns and the dealer to take turns.
Stops looping if the player stands and if game ends.
:return: None
"""
self.hidden_card = self.deck.remove_card()
self.give_card(self.dealer, self.deck.remove_card())
self.give_card(self.player, self.deck.remove_card())
while self.player.can_play() and self.player.get_wants_to_play(
) and not self.game_end():
decision = input("Enter 'h' for hit or 's' for stand: ")
if decision == 'h':
self.give_card(self.player, self.deck.remove_card())
elif decision == 's':
self.player.stop_playing()
else:
print("Invalid input")
if not self.game_end():
self.give_card(self.dealer, self.hidden_card)
while self.dealer.can_play() and not self.game_end():
self.give_card(self.dealer, self.deck.remove_card())
self.show_winner()
def give_card(self, p: Player, c: Card):
"""
Gives a card to the player, either dealer or blackjackplayer, and adds this to the table turns.
:param p: Player, Dealer, or BlackJackPlayer
:param c: Card
:return: None
"""
self.turns.append((p, c))
p.add_card(c)
print(p.get_name() + ' takes card ' + c.get_card_value() + ' for ' +
str(c.get_point()[1]) + '. Total = ' +
str(p.get_player_points()))
def game_end(self):
"""
Returns true if either dealer or blackjackplayer is over or equal to 21.
:return: bool
"""
if self.player.get_player_points() >= 21:
return True
elif self.dealer.get_player_points() >= 21:
return True
return False
def show_winner(self):
"""
Prints which player has lost or won to the console, with their points.
:return: None
"""
if self.player.get_player_points() > 21:
print(self.player.get_name() + ' has lost. ' +
str(self.player.get_player_points()) + ' > 21')
elif self.dealer.get_player_points() > 21:
print(self.dealer.get_name() + ' has lost. ' +
str(self.dealer.get_player_points()) + ' > 21')
else:
winner = self.player if self.player.get_player_points(
) > self.dealer.get_player_points() else self.dealer
print(winner.get_name() + ' has won with ' +
str(winner.get_player_points()) + ' points!')
class Game(object):
def __init__(self):
self.player = Player()
self.dealer = Dealer()
self.deck = Deck()
self.discarded = self.deck.discarded
def seed_player(self):
os.system('clear')
input_check = False
while input_check == False:
print(
'Welcome to Blackjack. Please enter your starting money amount'
)
money = input()
if money == 'q':
exit()
try:
money = float(money)
self.player.money = money
input_check = True
os.system('clear')
except ValueError as e:
os.system('clear')
print(
"Input error - Plese input a starting amount greater than 0"
)
def place_bet(self):
input_check = False
while input_check == False:
print(
'Please enter your bet amount. You currently have ${}'.format(
self.player.money))
bet = input()
if bet == 'q':
exit()
try:
bet = float(bet)
except ValueError as e:
os.system('clear')
print('You did not enter a valid bet amount')
continue
if self.player.money - bet < 0:
os.system('clear')
print('You do not have that much money')
continue
else:
os.system('clear')
print('Player bets ${}'.format(bet))
input_check = True
return bet
def deal(self):
while len(self.dealer.hand) < 2:
self.dealer.draw(self.deck)
self.player.draw(self.deck)
def discard_all(self):
self.player.discard(self.discarded)
self.dealer.discard(self.discarded)
def show_status(self, start=False, clear=True):
if clear is True:
os.system('clear')
dealer_total = self.dealer.show_hand(start=start)
player_total = self.player.show_hand()
return dealer_total, player_total
def offer_insurance(self):
input_check = False
insurance = 0
while input_check is False:
print('\nDealer Shows Ace. Would you like to buy Insurance? - Y/N')
ins = input()
if ins.lower() == 'y':
print('How much would you like to bet?')
insurance = input()
try:
insurance = float(insurance)
input_check = True
if self.dealer.total == 21:
return insurance
else:
return -insurance
except ValueError as e:
self.show_status(start=True)
print('\nYou did not enter a valid bet amount')
continue
elif ins.lower() == 'n':
return insurance
elif ins.lower() == 'q':
exit()
else:
self.show_status(start=True)
print('\nInvalid Input...')
continue
def split(self):
pass
#TODO: Add splitting flow
def play_hand(self, bet):
# Function to play hand and return the winner - Player, Dealer, Push, or Blackjack if player is dealt blackjack
self.deal()
self.dealer.total, self.player.total = self.show_status(start=True,
clear=False)
insurance = 0
if self.dealer.hand[1].name == 'Ace':
insurance = self.offer_insurance()
# Initial Blackjack check
if (self.player.total == 21) and (self.dealer.total == 21):
self.show_status()
self.discard_all()
return 'push', bet, insurance
elif self.player.total == 21:
self.discard_all()
return 'blackjack', bet, insurance
elif self.dealer.total == 21:
self.show_status()
self.discard_all()
return 'dealer', bet, insurance
while self.player.total < 21:
# Initial Player Action - Hit, Stand or Double Down
# TODO: Add Splitting
if len(self.player.hand) < 3:
print('\nHit, Stand or Double Down - H/S/D')
action = input()
if action.lower() == 'h':
self.player.draw(self.deck)
self.player.total = self.show_status(start=True)[1]
elif action.lower() == 's':
self.show_status()
time.sleep(2)
break
elif action.lower() == 'd':
if self.player.money - (2 * bet) >= 0:
bet = 2 * bet
self.player.draw(self.deck)
self.player.total = self.show_status(start=True)[1]
time.sleep(2)
if self.player.total <= 21:
self.show_status()
time.sleep(2)
break
else:
self.show_status(start=True)
print('\nYou do not have enough money to double down')
elif action.lower() == 'q':
exit()
else:
continue
# Second+ Player Action - Hit or Stand
else:
print('\nHit or Stand? - H/S')
action = input()
if action.lower() == 'h':
self.player.draw(self.deck)
self.player.total = self.show_status(start=True)[1]
elif action.lower() == 's':
self.show_status()
time.sleep(2)
break
elif action.lower() == 'q':
exit()
else:
continue
# Draw dealer hand - stopping at 17
while (self.dealer.total < 17) and (self.player.total <= 21):
self.dealer.draw(self.deck)
self.dealer.total = self.show_status()[0]
time.sleep(2)
self.discard_all()
# Declare winner of hand
if self.dealer.total == self.player.total:
return 'push', bet, insurance
elif (self.dealer.total <= 21) and (self.dealer.total >
self.player.total):
return 'dealer', bet, insurance
elif (self.player.total <= 21) and (self.player.total >
self.dealer.total):
return 'player', bet, insurance
elif self.player.total > 21:
return 'dealer', bet, insurance
elif self.dealer.total > 21:
return 'player', bet, insurance
def play_game(self):
self.seed_player()
while self.player.money >= 1:
bet = self.place_bet()
winner, bet, insurance = self.play_hand(bet)
if winner == 'player':
self.player.win_money(bet, insurance=insurance)
elif winner == 'dealer':
self.player.lose_money(bet, insurance=insurance)
elif winner == 'blackjack':
self.player.win_money(bet * 1.5,
insurance=insurance,
blackjack=True)
else:
print("\nIt's a push...\n")
continue
