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
