def test_add_bets_with_folders_two_rounds(self): player1 = Player("player-1", "Player One", 1000) player2 = Player("player-2", "Player Two", 1000) player3 = Player("player-3", "Player Three", 1000) player4 = Player("player-4", "Player Four", 1000) game_players = GamePlayers([player1, player2, player3, player4]) game_pots = GamePots(game_players) game_players.fold("player-1") game_pots.add_bets({ "player-1": 100.0, "player-2": 200.0, "player-3": 200.0, "player-4": 200.0 }) self.assertEqual(1, len(game_pots)) self.assertEquals(700, game_pots[0].money) self.assertListEqual([player2, player3, player4], game_pots[0].players) game_players.fold("player-2") game_pots.add_bets({ "player-2": 50.0, "player-3": 100, "player-4": 100 }) self.assertEqual(1, len(game_pots)) self.assertEquals(950.0, game_pots[0].money) self.assertEquals([player3, player4], game_pots[0].players)
def test_add_bets_with_two_rounds(self): player1 = Player("player-1", "Player One", 1000) player2 = Player("player-2", "Player Two", 1000) player3 = Player("player-3", "Player Three", 1000) player4 = Player("player-4", "Player Four", 1000) game_players = GamePlayers([player1, player2, player3, player4]) game_pots = GamePots(game_players) game_pots.add_bets({ "player-1": 100, "player-2": 200.0, "player-3": 200, "player-4": 200 }) game_pots.add_bets({ "player-1": 0, "player-2": 50.0, "player-3": 100, "player-4": 100 }) self.assertEqual(3, len(game_pots)) self.assertEquals(400, game_pots[0].money) self.assertEquals([player1, player2, player3, player4], game_pots[0].players) self.assertEquals(450, game_pots[1].money) self.assertEquals([player2, player3, player4], game_pots[1].players) self.assertEquals(100, game_pots[2].money) self.assertEquals([player2, player3, player4], game_pots[1].players)
def test_bet_round_one_player_only(self): game_players = GamePlayers([ Player("player-1", "Player One", 500.0), Player("player-2", "Player Two", 1000.0), Player("player-3", "Player Three", 1000.0), Player("player-4", "Player Four", 2000.0), ]) game_players.fold("player-1") game_players.fold("player-3") game_players.fold("player-4") bet_rounder = GameBetRounder(game_players) bet_calls = { # Workaround as Python 2.7 doesn't have nonlocal "counter": 0 } def bet_function_mock(player, min_bet, max_bet, bets): bet_calls["counter"] += 1 return -1 bets = {} best_player = bet_rounder.bet_round("player-2", bets, bet_function_mock) self.assertEquals(0, bet_calls["counter"]) self.assertEquals("player-2", best_player.id) self.assertEquals({"player-2": 0.0}, bets)
def _create_game_players(self): return GamePlayers([ Player("player-1", "Player One", 1000.0), Player("player-2", "Player Two", 1000.0), Player("player-3", "Player Three", 0.0), Player("player-4", "Player Four", 1000.0), ])
def test_get_winners(self): player1 = Player("player-1", "Player One", 1000.0) player2 = Player("player-2", "Player Two", 1000.0) player3 = Player("player-3", "Player Three", 1000.0) player4 = Player("player-4", "Player Four", 1000.0) players = GamePlayers([player1, player2, player3, player4]) class ScoreMock: def __init__(self, value): self.value = value def cmp(self, other): return cmp(self.value, other.value) class GameScoresMock: def player_score(self, player_id): if player_id == "player-1": return ScoreMock(3) elif player_id == "player-2": return ScoreMock(2) elif player_id == "player-3": return ScoreMock(2) elif player_id == "player-4": return ScoreMock(1) else: raise ValueError("Unknown player id") winner_detector = GameWinnersDetector(players) winners = winner_detector.get_winners([player2, player3, player4], GameScoresMock()) self.assertListEqual([player2, player3], winners) winners = winner_detector.get_winners( [player1, player2, player3, player4], GameScoresMock()) self.assertListEqual([player1], winners) players.fold("player-1") winners = winner_detector.get_winners( [player1, player2, player3, player4], GameScoresMock()) self.assertListEqual([player2, player3], winners) players.fold("player-2") winners = winner_detector.get_winners( [player1, player2, player3, player4], GameScoresMock()) self.assertListEqual([player3], winners) players.fold("player-3") winners = winner_detector.get_winners( [player1, player2, player3, player4], GameScoresMock()) self.assertListEqual([player4], winners) players.fold("player-4") winners = winner_detector.get_winners( [player1, player2, player3, player4], GameScoresMock()) self.assertListEqual([], winners)
def test_add_bets_when_strongest_player_fold(self): player1 = Player("player-1", "Player One", 1000) player2 = Player("player-2", "Player Two", 1000) player3 = Player("player-3", "Player Three", 1000) player4 = Player("player-4", "Player Four", 1000) game_players = GamePlayers([player1, player2, player3, player4]) game_pots = GamePots(game_players) game_players.fold("player-4") self.assertRaises(ValueError, game_pots.add_bets, { "player-3": 200.0, "player-4": 400.0 })
def test_bet_round_valid_bet_dictionary_3(self): bets = {"player-1": 1000, "player-2": 500} game_players = GamePlayers([ Player("player-1", "Player One", 1000.0), Player("player-2", "Player Two", 1000.0) ]) def bet_function_mock(player, min_bet, max_bet, bets): return -1 bet_rounder = GameBetRounder(game_players) bet_rounder.bet_round("player-2", bets, bet_function_mock)
def add_player(self, player_id: str, player_name: str) -> NoReturn: """ Adds a player to our game. """ assert player_id not in self._players, "Player with player id {} already exists".format( player_id) self._players[player_id] = Player(player_name, player_id)
def test_bet_round_invalid_bet_dictionary_with_dealer(self): bets = {"player-1": 400, "player-2": 1000} game_players = GamePlayers([ Player("player-1", "Player One", 1000.0), Player("player-2", "Player Two", 1000.0), Player("player-3", "Player Three", 1000.0), Player("player-4", "Player Four", 1000.0), ]) def bet_function_mock(player, min_bet, max_bet, bets): return -1 bet_rounder = GameBetRounder(game_players) self.assertRaises(ValueError, bet_rounder.bet_round, "player-4", bets, bet_function_mock)
def test_bet_round_everyone_check(self): player1 = Player("player-1", "Player One", 1000.0) player2 = Player("player-2", "Player Two", 1000.0) player3 = Player("player-3", "Player Three", 1000.0) player4 = Player("player-4", "Player Four", 1000.0) game_players = GamePlayers([player1, player2, player3, player4]) def bet_function_mock(player, min_bet, max_bet, bets): return min_bet bet_rounder = GameBetRounder(game_players) best_player = bet_rounder.bet_round("player-3", {}, bet_function_mock) self.assertEquals("player-3", best_player.id) self.assertTrue(game_players.is_active("player-1")) self.assertTrue(game_players.is_active("player-2")) self.assertTrue(game_players.is_active("player-3")) self.assertTrue(game_players.is_active("player-4"))
def test_bet_round_no_players(self): game_players = GamePlayers([ Player("player-1", "Player One", 500.0), Player("player-2", "Player Two", 1000.0), Player("player-3", "Player Three", 1000.0), Player("player-4", "Player Four", 2000.0), ]) game_players.fold("player-1") game_players.fold("player-2") game_players.fold("player-3") game_players.fold("player-4") bet_rounder = GameBetRounder(game_players) def bet_function_mock(player, min_bet, max_bet, bets): return -1 bets = {} self.assertRaises(GameError, bet_rounder.bet_round, "player-2", bets, bet_function_mock)
def test_bet_round_everyone_fold_with_blinds(self): bets = {"player-1": 400, "player-2": 1000} player1 = Player("player-1", "Player One", 1000.0) player2 = Player("player-2", "Player Two", 1000.0) player3 = Player("player-3", "Player Three", 1000.0) player4 = Player("player-4", "Player Four", 1000.0) game_players = GamePlayers([player1, player2, player3, player4]) def bet_function_mock(player, min_bet, max_bet, bets): return -1 bet_rounder = GameBetRounder(game_players) best_player = bet_rounder.bet_round("player-3", bets, bet_function_mock) self.assertEquals("player-2", best_player.id) self.assertTrue(game_players.is_active("player-2")) self.assertFalse(game_players.is_active("player-1")) self.assertFalse(game_players.is_active("player-3")) self.assertFalse(game_players.is_active("player-4"))
print(" $$$$$$$") print(" $$ $ $$") print(" $ $ $") print(" $ $ ") print(" $$ $ ") print(" $$$$$") print(" $ $$") print(" $ $") print(" $ $ $") print(" $$ $ $$") print(" $$$$$$$") print(" $") print() myDeck = Deck() myDeck.shuffle() dealer = Player() player = Player() myDeck.deal(dealer, 2) myDeck.deal(player, 2) print("Here are the dealer's cards: " + dealer.__str__()) dealer_sum = dealer.get_value() print("They add to " + str(dealer_sum)) print() print("Here are your cards: " + player.__str__()) player_sum = player.get_value() print("They add to " + str(player_sum)) print() hitting = True while hitting: answer = input("Hit or Stay?") if answer.lower() == "hit":
def test_get_winners(self): player1 = Player("player-1", "Player One", 800.0) player2 = Player("player-2", "Player Two", 600.0) player3 = Player("player-3", "Player Three", 1200.0) player4 = Player("player-4", "Player Four", 900.0) player5 = Player("player-5", "Player Four", 3000.0) game_players = GamePlayers( [player1, player2, player3, player4, player5]) game_scores = GameScores(HoldemPokerScoreDetector()) game_scores.add_shared_cards( [Card(6, 3), Card(14, 0), Card(8, 3), Card(9, 2), Card(4, 0)]) game_scores.assign_cards("player-1", [Card(14, 1), Card(6, 2)]) game_scores.assign_cards("player-2", [Card(14, 2), Card(8, 0)]) game_scores.assign_cards("player-3", [Card(4, 1), Card(3, 2)]) game_scores.assign_cards("player-4", [Card(3, 1), Card(4, 2)]) game_scores.assign_cards("player-5", [Card(13, 1), Card(4, 3)]) game_pots = GamePots(game_players) # Bet round here player1.take_money(800.0) player2.take_money(600.0) player3.take_money(1200.0) player4.take_money(900.0) player5.take_money(900.0) game_players.fold("player-5") game_pots.add_bets({ "player-1": 800.0, "player-2": 600.0, "player-3": 1200.0, "player-4": 900.0, "player-5": 900.0 }) self.assertEquals(4, len(game_pots)) winner_detector = GameWinnersDetector(game_players) winners = winner_detector.get_winners(game_pots[0].players, game_scores) self.assertListEqual([player2], winners) winners = winner_detector.get_winners(game_pots[1].players, game_scores) self.assertListEqual([player1], winners) winners = winner_detector.get_winners(game_pots[2].players, game_scores) self.assertListEqual([player4, player3], winners) winners = winner_detector.get_winners(game_pots[3].players, game_scores) self.assertListEqual([player3], winners)
def test_stores_name_and_cards(self): hand = Hand() player = Player(name="Oleks", hand=hand) self.assertEqual(player.name, "Oleks") self.assertEqual(player.hand, hand)
def test_figures_out_own_best_hand(self): mock_hand = MagicMock() player = Player(name="Oleks", hand=mock_hand) player.best_hand() mock_hand.best_rank.assert_called()
from poker import Player, Card, Deck playing = True while playing: my_deck = Deck() my_deck.shuffle() opponent = Player() player = Player() my_deck.deal(opponent, 5) my_deck.deal(player, 5) print(opponent) print(player) playing = False
from poker import Card, Deck, Hand, Player, GameRound deck = Deck() deck.add_cards(Card.create_52_cards()) hand1 = Hand() hand2 = Hand() player1 = Player("Oleks", hand1) player2 = Player("Lexa", hand2) game_round = GameRound(deck, [player1, player2]) game_round.play() print(player1.best_hand()) print(player2.best_hand()) print(player1.hand) print(len(deck)) # def ranks_with_count(cards, count): # return { # rank: rank_count # for rank, rank_count in card_rank_count(cards).items() # if rank_count == count # } # # # def card_rank_count(cards): # card_rank_count = {} # for card in cards: # card_rank_count.setdefault(card.rank, 0)
def test_bet_round_small_and_big_blind(self): player1 = Player("player-1", "Player One", 1000.0) player2 = Player("player-2", "Player Two", 1000.0) player3 = Player("player-3", "Player Three", 900.0) player4 = Player("player-4", "Player Four", 800.0) game_players = GamePlayers([player1, player2, player3, player4]) bet_rounder = GameBetRounder(game_players) bet_calls = { # Workaround as Python 2.7 doesn't have nonlocal "counter": 0 } def bet_function_mock(player, min_bet, max_bet, bets): bet_calls["counter"] += 1 if bet_calls["counter"] == 1: self.assertEquals("player-1", player.id) self.assertEquals((200.0, 1000.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 0.0, "player-3": 100.0, "player-4": 200.0 }, bets) return -1 if bet_calls["counter"] == 2: self.assertEquals("player-2", player.id) self.assertEquals((200.0, 1000.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 0.0, "player-3": 100.0, "player-4": 200.0 }, bets) return 200.0 if bet_calls["counter"] == 3: self.assertEquals("player-3", player.id) self.assertEquals((100.0, 900.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 100.0, "player-4": 200.0 }, bets) return 100.0 if bet_calls["counter"] == 4: self.assertEquals("player-4", player.id) self.assertEquals((0.0, 800.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 200.0, "player-4": 200.0 }, bets) return 200.0 if bet_calls["counter"] == 5: self.assertEquals("player-2", player.id) self.assertEquals((200.0, 800.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 200.0, "player-4": 400.0 }, bets) return -1 if bet_calls["counter"] == 6: self.assertEquals("player-3", player.id) self.assertEquals((200.0, 800.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 200.0, "player-4": 400.0 }, bets) return 400.0 if bet_calls["counter"] == 7: self.assertEquals("player-4", player.id) self.assertEquals((200.0, 600.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 600.0, "player-4": 400.0 }, bets) return 400.0 if bet_calls["counter"] == 8: self.assertEquals("player-3", player.id) self.assertEquals((200.0, 400.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 600.0, "player-4": 800.0 }, bets) return 400.0 if bet_calls["counter"] == 9: self.assertEquals("player-4", player.id) self.assertEquals((200.0, 200.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 1000.0, "player-4": 800.0 }, bets) return 200.0 # Big and small blind bets = {"player-3": 100, "player-4": 200} best_player = bet_rounder.bet_round("player-1", bets, bet_function_mock) self.assertEquals(9, bet_calls["counter"]) self.assertEquals(1000.0, player1.money) self.assertFalse(game_players.is_active("player-1")) self.assertEquals(800.0, player2.money) self.assertFalse(game_players.is_active("player-2")) self.assertEquals(0.0, player3.money) self.assertTrue(game_players.is_active("player-3")) self.assertEquals(0.0, player4.money) self.assertTrue(game_players.is_active("player-4")) self.assertEquals("player-3", best_player.id) self.assertEquals( { "player-1": 0.0, "player-2": 200.0, "player-3": 1000.0, "player-4": 1000.0 }, bets)
def test_bet_round_2(self): player1 = Player("player-1", "Player One", 500.0) player2 = Player("player-2", "Player Two", 1000.0) player3 = Player("player-3", "Player Three", 1000.0) player4 = Player("player-4", "Player Four", 2000.0) game_players = GamePlayers([player1, player2, player3, player4]) bet_rounder = GameBetRounder(game_players) bet_calls = { # Workaround as Python 2.7 doesn't have nonlocal "counter": 0 } def bet_function_mock(player, min_bet, max_bet, bets): bet_calls["counter"] += 1 if bet_calls["counter"] == 1: self.assertEquals("player-2", player.id) self.assertEquals((0.0, 1000.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 0.0, "player-3": 0.0, "player-4": 0.0 }, bets) return -1 if bet_calls["counter"] == 2: self.assertEquals("player-3", player.id) self.assertEquals((0.0, 1000.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 0.0, "player-3": 0.0, "player-4": 0.0 }, bets) return 200.0 if bet_calls["counter"] == 3: self.assertEquals("player-4", player.id) self.assertEquals((200.0, 1000.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 0.0, "player-3": 200.0, "player-4": 0.0 }, bets) return 600.0 if bet_calls["counter"] == 4: self.assertEquals("player-1", player.id) self.assertEquals((500.0, 500.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 0.0, "player-2": 0.0, "player-3": 200.0, "player-4": 600.0 }, bets) return 500.0 if bet_calls["counter"] == 5: self.assertEquals("player-3", player.id) self.assertEquals((400.0, 800.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 500.0, "player-2": 0.0, "player-3": 200.0, "player-4": 600.0 }, bets) return 800.0 if bet_calls["counter"] == 6: self.assertEquals("player-4", player.id) self.assertEquals((400.0, 400.0), (min_bet, max_bet)) self.assertEquals( { "player-1": 500.0, "player-2": 0.0, "player-3": 1000.0, "player-4": 600.0 }, bets) return -1 bets = {} best_player = bet_rounder.bet_round("player-2", bets, bet_function_mock) self.assertEquals(6, bet_calls["counter"]) # player-1 went all-in self.assertTrue(game_players.is_active("player-1")) self.assertEqual(0.0, player1.money) # player-2 called 600 self.assertFalse(game_players.is_active("player-2")) self.assertEqual(1000.0, player2.money) # player-3 folded straight away self.assertTrue(game_players.is_active("player-3")) self.assertEqual(0.0, player3.money) # player-4 went all-in self.assertFalse(game_players.is_active("player-4")) self.assertEqual(1400.0, player4.money) # Last re-raise self.assertEquals("player-3", best_player.id) self.assertEquals( { "player-1": 500.0, "player-2": 0.0, "player-3": 1000.0, "player-4": 600.0 }, bets)
def poker_game(ws, connection_channel): client_channel = ChannelWebSocket(ws) if "player-id" not in session: client_channel.send_message({ "message_type": "error", "error": "Unrecognized user" }) client_channel.close() return session_id = str(uuid.uuid4()) player_id = session["player-id"] player_name = session["player-name"] player_money = session["player-money"] player_connector = PlayerClientConnector(redis, connection_channel, app.logger) try: server_channel = player_connector.connect(player=Player( id=player_id, name=player_name, money=player_money), session_id=session_id) except (ChannelError, MessageFormatError, MessageTimeout) as e: app.logger.error( "Unable to connect player {} to a poker5 server: {}".format( player_id, e.args[0])) else: # Forwarding connection to the client client_channel.send_message(server_channel.connection_message) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Game service communication # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def message_handler(channel1, channel2): # Forward messages received from channel1 to channel2 try: while True: message = channel1.recv_message() if "message_type" in message and message[ "message_type"] == "disconnect": raise ChannelError channel2.send_message(message) except (ChannelError, MessageFormatError): pass greenlets = [ # Forward client messages to the game service gevent.spawn(message_handler, client_channel, server_channel), # Forward game service messages to the client gevent.spawn(message_handler, server_channel, client_channel) ] def closing_handler(*args, **kwargs): # Kill other active greenlets gevent.killall(greenlets, ChannelError) greenlets[0].link(closing_handler) greenlets[1].link(closing_handler) gevent.joinall(greenlets) try: client_channel.send_message({"message_type": "disconnect"}) except: pass finally: client_channel.close() try: server_channel.send_message({"message_type": "disconnect"}) except: pass finally: server_channel.close() app.logger.info("player {} connection closed".format(player_id))
from poker import Game, Player import random if __name__ == '__main__': players = [Player('John'), Player('Bob')] game = Game(players=players, chips=10000) while len(game.players) > 1: game.initialize_round() while not game.round_ended: print(', '.join([n.full_name for n in game.players])) for player in game.players_to_act(): print("===== {} =====".format(player.name)) print("Pot: {}".format(game.pot)) print("The Board: {}".format(' '.join(map(str, game.board)))) print("Current bet: {}".format(game.current_bet)) print("Your bet: {}".format(player.bet)) print("Your cards: {}".format(' '.join(map(str, player.hand)))) print("Your chips: {}".format(player.chips)) action = input("Action: ") if action.startswith('bet'): game.bet(player, int(action.split()[1])) elif action.startswith('check'): game.check(player) elif action.startswith('call'): game.call(player) elif action.startswith('fold'): game.fold(player) game.next_betting_round() earnings = game.round_win_info
async def poker_game(ctx, bot, tournament_info): board_string = '''**Poker Tournament** {board} 💰 **Pot:** {pot} 💵 **Current Bet:** {bet} {players} **[** ☑ Check **|** ❎ Fold **|** ☎ Call **|** 💸 Bet **]**''' settings = tournament_info['settings'] players = dict((user, Player(user)) for user in settings['players']) game = Game(chips=settings['chips'], players=list(players.values())) player_string = get_player_string(game) board_message = await ctx.send('Setting up the board...') await board_message.add_reaction('☑') await board_message.add_reaction('❎') await board_message.add_reaction('☎') await board_message.add_reaction('💸') def check(reaction, user): return reaction.message.id == board_message.id and user in players.keys( ) while len(game.players) > 1: game.initialize_round() player_string = get_player_string(game) await board_message.edit( content=board_string.format(board=' '.join(map(str, game.board)), pot=game.pot, bet=game.current_bet, players=player_string)) while not game.round_ended: player_string = get_player_string(game) await board_message.edit(content=board_string.format( board=' '.join(map(str, game.board)), pot=game.pot, bet=game.current_bet, players=player_string)) reaction, user = await bot.wait_for('reaction_add', check=check) await board_message.remove_reaction(reaction, user) if players[user] == game.current_player: if str(reaction) == '☑': game.check(players[user]) elif str(reaction) == '❎': game.fold(players[user]) elif str(reaction) == '☎': game.call(players[user]) elif str(reaction) == '💸': tmp = await ctx.send("How much would you like to bet?") bet = await bot.wait_for('message', check=lambda x: x.author == user and x.channel == ctx.channel) game.bet(players[user], int(bet.content)) game.next_betting_round() else: await user.send("It is not your turn yet.") earnings = game.round_win_info for amount, information in earnings.items(): player, reason = information await ctx.send("{} won {} chips ({}) with {}".format( player.id.name, amount, reason, ''.join(map(str, player.hand)))) break