datamllab / rlcard / 234

Build # 234

Build Type

push

travis-ci

Committed by Daochen

Commit Message

<a href="https://github.com/datamllab/rlcard/commit/<a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/<a class="double-link" href="https://git"><a class=hub.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c">afd9f2685<a href="https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c">&lt;a href=&quot;https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c">&lt;a href=&quot;https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c&amp;amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;Squashed commit of the following:

commit &amp;amp;lt;/a&amp;amp;gt;&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://github.com/datamllab/rlcard/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://github.com/datamllab/rlcard/commit/9fdbf952a2cad0489f26079e14cd34c511b98a8a&amp;amp;quot;&amp;amp;gt;9fdbf952a&amp;amp;lt;/a&amp;amp;gt;&amp;amp;quot;&amp;amp;gt;9fdbf952a&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c&amp;quot;&amp;gt;
Author: Daochen &amp;amp;lt;daochen@datalab4.engr.tamu.edu&amp;amp;gt;
Date:   Tue Oct 8 20:41:13 2019 -0500

    setup

commit &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/datamllab/rlcard/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/datamllab/rlcard/commit/45cf4486cf9f753b5a60ff5c28668b27f9ffcd87&amp;quot;&gt;45cf4486c&lt;/a&gt;&quot;&gt;45cf4486c&lt;/a&gt;&lt;a href=&quot;https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c&quot;&gt;
Author: Daochen &amp;lt;daochen@datalab4.engr.tamu.edu&amp;gt;
Date:   Tue Oct 8 20:03:22 2019 -0500

    readme

commit &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datamllab/rlcard/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datamllab/rlcard/commit/ff4cddc44ab2974098dcc95a2f0f6f86ce4694c1&quot;&gt;ff4cddc44&lt;/a&gt;&quot;&gt;ff4cddc44&lt;/a&gt;&lt;a href=&quot;https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c">
Author: Daochen &lt;daochen@datalab4.engr.tamu.edu&gt;
Date:   Tue Oct 8 04:28:21 2019 -0500

    refine docs and codes

commit </a><a class="double-link" href="https://github.com/datamllab/rlcard/commit/<a class="double-link" href="https://github.com/datamllab/rlcard/commit/1f55c56953cc44fb76b4b90bb5d1527730cdcedd">1f55c5695</a>">1f55c5695</a><a href="https://github.com/datamllab/rlcard/commit/afd9f26857d41de317a92e28d14ac76aaf8c8e7c">
Author: Daochen &lt;daochen@datalab4.engr.tamu.edu&gt;
Date:   Tue Oct 8 04:02:35 2019 -0500

    cfr

commit </a><a class="double-link" href="https://github.com/datamllab/rlcard/commit/2b711efa2">2b711efa2
Author: Yuanpu <yuanpucao@gmail.com>
Date:   Tue Oct 8 04:09:57 2019 +0800

    fix uno test class name

commit 763e58287">763e58287</a><a href... (continued)

Run Details

1953 of 1953 new or added lines in 55 files covered. (100.0%)

2980 of 3419 relevant lines covered (87.16%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.01

/rlcard/games/nolimitholdem/game.py

import numpy as np
from copy import deepcopy
from rlcard.games.limitholdem.game import LimitholdemGame

from rlcard.games.nolimitholdem.dealer import NolimitholdemDealer as Dealer
from rlcard.games.nolimitholdem.player import NolimitholdemPlayer as Player
from rlcard.games.nolimitholdem.judger import NolimitholdemJudger as Judger
from rlcard.games.nolimitholdem.round import NolimitholdemRound as Round

class NolimitholdemGame(LimitholdemGame):

    def __init__(self, allow_step_back=False):
        ''' Initialize the class nolimitholdem Game
        '''
        self.allow_step_back = allow_step_back

        # small blind and big blind
        self.small_blind = 1
        self.big_blind = 2 * self.small_blind

        # config players
        self.num_players = 2
        self.init_chips = 100

    def init_game(self):
        ''' Initialilze the game of Limit Texas Hold'em

        This version supports two-player limit texas hold'em

        Returns:
            (tuple): Tuple containing:

                (dict): The first state of the game
                (int): Current player's id
        '''
        # Initilize a dealer that can deal cards
        self.dealer = Dealer()

        # Initilize two players to play the game
        self.players = [Player(i, self.init_chips) for i in range(self.num_players)]

        # Initialize a judger class which will decide who wins in the end
        self.judger = Judger()

        # Deal cards to each  player to prepare for the first round
        for i in range(2 * self.num_players):
            self.players[i % self.num_players].hand.append(self.dealer.deal_card())

        # Initilize public cards
        self.public_cards = []

        # Randomly choose a big blind and a small blind
        s = np.random.randint(0, self.num_players)
        b = (s + 1) % self.num_players
        self.players[b].in_chips = self.big_blind
        self.players[s].in_chips = self.small_blind

        # The player next to the small blind plays the first
        self.game_pointer = (b + 1) % self.num_players

        # Initilize a bidding round, in the first round, the big blind and the small blind needs to
        # be passed to the round for processing.
        self.round = Round(self.num_players, self.big_blind)

        self.round.start_new_round(game_pointer=self.game_pointer, raised=[p.in_chips for p in self.players])

        # Count the round. There are 4 rounds in each game.
        self.round_counter = 0

        # Save the hisory for stepping back to the last state.
        self.history = []

        state = self.get_state(self.game_pointer)

        return state, self.game_pointer

    def get_legal_actions(self):
        ''' Return the legal actions for current player

        Returns:
            (list): A list of legal actions
        '''
        return self.round.get_nolimit_legal_actions(self.players)

    def step(self, action):
        ''' Get the next state

        Args:
            action (str): a specific action. (call, raise, fold, or check)

        Returns:
            (tuple): Tuple containing:

                (dict): next player's state
                (int): next plater's id
        '''
        if self.allow_step_back:
            # First snapshot the current state
            r = deepcopy(self.round)
            b = self.game_pointer
            r_c = self.round_counter
            d = deepcopy(self.dealer)
            p = deepcopy(self.public_cards)
            ps = deepcopy(self.players)
            self.history.append((r, b, r_c, d, p, ps))

        # Then we proceed to the next round
        self.game_pointer = self.round.proceed_round(self.players, action)

        # If a round is over, we deal more public cards
        if self.round.is_over():
            # For the first round, we deal 3 cards
            if self.round_counter == 0:
                self.public_cards.append(self.dealer.deal_card())
                self.public_cards.append(self.dealer.deal_card())
                self.public_cards.append(self.dealer.deal_card())
            # For the following rounds, we deal only 1 card
            elif self.round_counter <= 2:
                self.public_cards.append(self.dealer.deal_card())

            self.round_counter += 1
            self.round.start_new_round(self.game_pointer)

        state = self.get_state(self.game_pointer)

        return state, self.game_pointer

    def get_state(self, player):
        ''' Return player's state

        Args:
            player_id (int): player id

        Returns:
            (dict): The state of the player
        '''
        chips = [self.players[i].in_chips for i in range(self.num_players)]
        legal_actions = self.get_legal_actions()
        state = self.players[player].get_state(self.public_cards, chips, legal_actions)

        return state

    def step_back(self):
        ''' Return to the previous state of the game

        Returns:
            (bool): True if the game steps back successfully
        '''
        if len(self.history) > 0:
            self.round, self.game_pointer, self.round_counter, self.dealer, self.public_cards, self.players = self.history.pop()
            return True
        return False

    def get_action_num(self):
        ''' Return the number of applicable actions

        Returns:
            (int): The number of actions. There are 4 kinds actions (call, raise, check and fold). For 'raise' action, we provide all possible raise amount.
        '''
        return self.init_chips + 3


#if __name__ == "__main__":
#    game = NolimitholdemGame()
#
#    while True:
#        print('New Game')
#        state, game_pointer = game.init_game()
#        print(game_pointer, state)
#        i = 1
#        while not game.is_over():
#            i += 1
#            legal_actions = game.get_legal_actions()
#            # if i == 3:
#            #     print('Step back')
#            #     print(game.step_back())
#            #     game_pointer = game.get_player_id()
#            #     print(game_pointer)
#            #     legal_actions = game.get_legal_actions()
#
#            action = np.random.choice(legal_actions)
#            # action = input()
#            # if action != 'call' and action != 'fold' and action != 'check':
#            #     action = int(action)
#            print(game_pointer, action, legal_actions)
#            state, game_pointer = game.step(action)
#            print(game_pointer, state)
#
#        print(game.get_payoffs())

1	import numpy as np	1✔
2	from copy import deepcopy	1✔
3	from rlcard.games.limitholdem.game import LimitholdemGame	1✔
4
5	from rlcard.games.nolimitholdem.dealer import NolimitholdemDealer as Dealer	1✔
6	from rlcard.games.nolimitholdem.player import NolimitholdemPlayer as Player	1✔
7	from rlcard.games.nolimitholdem.judger import NolimitholdemJudger as Judger	1✔
8	from rlcard.games.nolimitholdem.round import NolimitholdemRound as Round	1✔
9
10	class NolimitholdemGame(LimitholdemGame):	1✔
11
12	def __init__(self, allow_step_back=False):	1✔
13	''' Initialize the class nolimitholdem Game
14	'''
15	self.allow_step_back = allow_step_back	1✔
16
17	# small blind and big blind
18	self.small_blind = 1	1✔
19	self.big_blind = 2 * self.small_blind	1✔
20
21	# config players
22	self.num_players = 2	1✔
23	self.init_chips = 100	1✔
24
25	def init_game(self):	1✔
26	''' Initialilze the game of Limit Texas Hold'em
27
28	This version supports two-player limit texas hold'em
29
30	Returns:
31	(tuple): Tuple containing:
32
33	(dict): The first state of the game
34	(int): Current player's id
35	'''
36	# Initilize a dealer that can deal cards
37	self.dealer = Dealer()	1✔
38
39	# Initilize two players to play the game
40	self.players = [Player(i, self.init_chips) for i in range(self.num_players)]	1✔
41
42	# Initialize a judger class which will decide who wins in the end
43	self.judger = Judger()	1✔
44
45	# Deal cards to each player to prepare for the first round
46	for i in range(2 * self.num_players):	1✔
47	self.players[i % self.num_players].hand.append(self.dealer.deal_card())	1✔
48
49	# Initilize public cards
50	self.public_cards = []	1✔
51
52	# Randomly choose a big blind and a small blind
53	s = np.random.randint(0, self.num_players)	1✔
54	b = (s + 1) % self.num_players	1✔
55	self.players[b].in_chips = self.big_blind	1✔
56	self.players[s].in_chips = self.small_blind	1✔
57
58	# The player next to the small blind plays the first
59	self.game_pointer = (b + 1) % self.num_players	1✔
60
61	# Initilize a bidding round, in the first round, the big blind and the small blind needs to
62	# be passed to the round for processing.
63	self.round = Round(self.num_players, self.big_blind)	1✔
64
65	self.round.start_new_round(game_pointer=self.game_pointer, raised=[p.in_chips for p in self.players])	1✔
66
67	# Count the round. There are 4 rounds in each game.
68	self.round_counter = 0	1✔
69
70	# Save the hisory for stepping back to the last state.
71	self.history = []	1✔
72
73	state = self.get_state(self.game_pointer)	1✔
74
75	return state, self.game_pointer	1✔
76
77	def get_legal_actions(self):	1✔
78	''' Return the legal actions for current player
79
80	Returns:
81	(list): A list of legal actions
82	'''
83	return self.round.get_nolimit_legal_actions(self.players)	1✔
84
85	def step(self, action):	1✔
86	''' Get the next state
87
88	Args:
89	action (str): a specific action. (call, raise, fold, or check)
90
91	Returns:
92	(tuple): Tuple containing:
93
94	(dict): next player's state
95	(int): next plater's id
96	'''
97	if self.allow_step_back:	1✔
98	# First snapshot the current state
99	r = deepcopy(self.round)	1✔
100	b = self.game_pointer	1✔
101	r_c = self.round_counter	1✔
102	d = deepcopy(self.dealer)	1✔
103	p = deepcopy(self.public_cards)	1✔
104	ps = deepcopy(self.players)	1✔
105	self.history.append((r, b, r_c, d, p, ps))	1✔
106
107	# Then we proceed to the next round
108	self.game_pointer = self.round.proceed_round(self.players, action)	1✔
109
110	# If a round is over, we deal more public cards
111	if self.round.is_over():	1✔
112	# For the first round, we deal 3 cards
113	if self.round_counter == 0:	1✔
114	self.public_cards.append(self.dealer.deal_card())	1✔
115	self.public_cards.append(self.dealer.deal_card())	1✔
116	self.public_cards.append(self.dealer.deal_card())	1✔
117	# For the following rounds, we deal only 1 card
118	elif self.round_counter <= 2:	×
119	self.public_cards.append(self.dealer.deal_card())	×
120
121	self.round_counter += 1	1✔
122	self.round.start_new_round(self.game_pointer)	1✔
123
124	state = self.get_state(self.game_pointer)	1✔
125
126	return state, self.game_pointer	1✔
127
128	def get_state(self, player):	1✔
129	''' Return player's state
130
131	Args:
132	player_id (int): player id
133
134	Returns:
135	(dict): The state of the player
136	'''
137	chips = [self.players[i].in_chips for i in range(self.num_players)]	1✔
138	legal_actions = self.get_legal_actions()	1✔
139	state = self.players[player].get_state(self.public_cards, chips, legal_actions)	1✔
140
141	return state	1✔
142
143	def step_back(self):	1✔
144	''' Return to the previous state of the game
145
146	Returns:
147	(bool): True if the game steps back successfully
148	'''
149	if len(self.history) > 0:	1✔
150	self.round, self.game_pointer, self.round_counter, self.dealer, self.public_cards, self.players = self.history.pop()	1✔
151	return True	1✔
152	return False	1✔
153
154	def get_action_num(self):	1✔
155	''' Return the number of applicable actions
156
157	Returns:
158	(int): The number of actions. There are 4 kinds actions (call, raise, check and fold). For 'raise' action, we provide all possible raise amount.
159	'''
160	return self.init_chips + 3	1✔
161
162
163	#if __name__ == "__main__":
164	# game = NolimitholdemGame()
165	#
166	# while True:
167	# print('New Game')
168	# state, game_pointer = game.init_game()
169	# print(game_pointer, state)
170	# i = 1
171	# while not game.is_over():
172	# i += 1
173	# legal_actions = game.get_legal_actions()
174	# # if i == 3:
175	# # print('Step back')
176	# # print(game.step_back())
177	# # game_pointer = game.get_player_id()
178	# # print(game_pointer)
179	# # legal_actions = game.get_legal_actions()
180	#
181	# action = np.random.choice(legal_actions)
182	# # action = input()
183	# # if action != 'call' and action != 'fold' and action != 'check':
184	# # action = int(action)
185	# print(game_pointer, action, legal_actions)
186	# state, game_pointer = game.step(action)
187	# print(game_pointer, state)
188	#
189	# print(game.get_payoffs())

datamllab / rlcard / 234

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous