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