def test_step(self):
game = Game()
# test raise
_, player_id = game.init_game()
init_raised = game.round.raised[player_id]
game.step(10)
step_raised = game.round.raised[player_id]
self.assertEqual(init_raised+10, step_raised)
# test call
game.init_game()
init_not_raise_num = game.round.not_raise_num
game.step('call')
step_not_raise_num = game.round.not_raise_num
self.assertEqual(init_not_raise_num+1, step_not_raise_num)
# test fold
game.init_game()
game.step('fold')
self.assertTrue(game.round.player_folded)
# test check
game.init_game()
game.step('call')
game.step('check')
self.assertEqual(game.round_counter, 1)
def test_payoffs_1(self):
game = Game()
game.init_game()
game.step(Action.CALL)
game.step(Action.RAISE_HALF_POT)
game.step(Action.FOLD)
self.assertTrue(game.is_over())
self.assertEqual(2, len(game.get_payoffs()))
def test_all_in(self):
game = Game()
_, player_id = game.init_game()
game.step(Action.ALL_IN)
step_raised = game.round.raised[player_id]
self.assertEqual(100, step_raised)
self.assertEqual(100, game.players[player_id].in_chips)
self.assertEqual(0, game.players[player_id].remained_chips)
def test_payoffs_1(self):
game = Game()
np.random.seed(0)
game.init_game()
game.step('call')
game.step(4)
game.step('fold')
self.assertTrue(game.is_over())
self.assertListEqual([-2.0, 2.0], game.get_payoffs())
def test_all_in_to_call(self):
game = Game()
game.init_chips = [50, 100]
game.dealer_id = 0
game.init_game()
game.step(Action.CALL)
game.step(Action.ALL_IN)
game.step(Action.CALL)
self.assertTrue(game.is_over())
def test_auto_step(self):
game = Game()
game.init_game()
self.assertEqual(Stage.PREFLOP, game.stage)
game.step(Action.ALL_IN)
game.step(Action.CALL)
self.assertEqual(Stage.RIVER, game.stage)
def test_payoffs_2(self):
game = Game()
np.random.seed(0)
game.init_game()
game.step(Action.CALL)
game.step(Action.RAISE_POT)
game.step(Action.ALL_IN)
game.step(Action.FOLD)
self.assertTrue(game.is_over())
self.assertEqual(2, len(game.get_payoffs()))
def test_init_game(self):
game = Game()
state, player_id = game.init_game()
test_id = game.get_player_id()
self.assertEqual(test_id, player_id)
self.assertIn('call', state['legal_actions'])
self.assertIn('fold', state['legal_actions'])
for i in range(3,100):
self.assertIn(i , state['legal_actions'])
def __init__(self, allow_step_back=False):
''' Initialize the Limitholdem environment
'''
super().__init__(Game(allow_step_back), allow_step_back)
self.actions = ['call', 'fold', 'check']
self.state_shape = [54]
for raise_amount in range(1, self.game.init_chips+1):
self.actions.append(raise_amount)
with open(os.path.join(rlcard.__path__[0], 'games/limitholdem/card2index.json'), 'r') as file:
self.card2index = json.load(file)
def test_bet_more_than_chips(self):
game = Game()
# test check
game.init_game()
player = game.players[0]
in_chips = player.in_chips
player.bet(50)
self.assertEqual(50 + in_chips, player.in_chips)
player.bet(150)
self.assertEqual(100, player.in_chips)
def test_all_in_rounds(self):
game = Game()
game.init_game()
game.step(Action.CHECK_CALL)
game.step(Action.CHECK_CALL)
self.assertEqual(game.round_counter, 1)
game.step(Action.CHECK_CALL)
game.step(Action.ALL_IN)
self.assertListEqual([Action.FOLD, Action.CHECK_CALL],
game.get_legal_actions())
game.step(Action.CHECK_CALL)
self.assertEqual(game.round_counter, 4)
self.assertEqual(200, game.dealer.pot)
def test_raise_half_pot(self):
game = Game()
_, player_id = game.init_game()
game.step(Action.RAISE_HALF_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(2, step_raised)
player_id = game.round.game_pointer
game.step(Action.RAISE_HALF_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(4, step_raised)
player_id = game.round.game_pointer
game.step(Action.RAISE_HALF_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(5, step_raised)
def test_step_2(self):
game = Game()
# test check
game.init_game()
self.assertEqual(Stage.PREFLOP, game.stage)
game.step(Action.CALL)
game.step(Action.RAISE_POT)
game.step(Action.CALL)
self.assertEqual(Stage.FLOP, game.stage)
game.step(Action.CHECK)
game.step(Action.CHECK)
self.assertEqual(Stage.TURN, game.stage)
game.step(Action.CHECK)
game.step(Action.CHECK)
self.assertEqual(Stage.RIVER, game.stage)
def test_raise_half_pot(self):
game = Game()
_, player_id = game.init_game()
self.assertNotIn(Action.RAISE_HALF_POT,
game.get_legal_actions()) # Half pot equals call
game.step(Action.CALL)
step_raised = game.round.raised[player_id]
self.assertEqual(2, step_raised)
player_id = game.round.game_pointer
game.step(Action.RAISE_HALF_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(4, step_raised)
player_id = game.round.game_pointer
game.step(Action.RAISE_HALF_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(5, step_raised)
def test_step(self):
game = Game()
# test call
game.init_game()
init_not_raise_num = game.round.not_raise_num
game.step(Action.CHECK_CALL)
step_not_raise_num = game.round.not_raise_num
self.assertEqual(init_not_raise_num + 1, step_not_raise_num)
# test fold
_, player_id = game.init_game()
game.step(Action.FOLD)
self.assertEqual(PlayerStatus.FOLDED, game.players[player_id].status)
# test check
game.init_game()
game.step(Action.CHECK_CALL)
def test_raise_pot(self):
game = Game()
_, player_id = game.init_game()
game.step(Action.RAISE_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(4, step_raised)
player_id = game.round.game_pointer
game.step(Action.RAISE_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(8, step_raised)
player_id = game.round.game_pointer
game.step(Action.RAISE_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(16, step_raised)
game.step(Action.CALL)
player_id = game.round.game_pointer
game.step(Action.RAISE_POT)
step_raised = game.round.raised[player_id]
self.assertEqual(32, step_raised)
def test_step_3_players(self):
game = Game(num_players=3)
# test check
_, first_player_id = game.init_game()
self.assertEqual(Stage.PREFLOP, game.stage)
game.step(Action.CALL)
game.step(Action.CALL)
game.step(Action.RAISE_POT)
game.step(Action.FOLD)
game.step(Action.CALL)
self.assertEqual(Stage.FLOP, game.stage)
self.assertEqual((first_player_id - 2) % 3, game.round.game_pointer)
game.step(Action.CHECK)
game.step(Action.RAISE_POT)
game.step(Action.CALL)
self.assertEqual(Stage.TURN, game.stage)
self.assertEqual((first_player_id - 2) % 3, game.round.game_pointer)
game.step(Action.CHECK)
game.step(Action.CHECK)
self.assertEqual(Stage.RIVER, game.stage)
def test_wrong_steps(self):
game = Game()
game.init_game()
self.assertRaises(Exception, game.step, Action.CHECK)
def test_init_game(self):
game = Game()
state, player_id = game.init_game()
test_id = game.get_player_id()
self.assertEqual(test_id, player_id)
def test_get_action_num(self):
game = Game()
action_num = game.get_action_num()
self.assertEqual(action_num, 103)