def test_bitmask_500(self):
logic = Game_Helpers()
bitmask = logic.chips_bitmask(500)
bitmask_expected = np.zeros(50)
bitmask_expected[0:50] = 1
self.assertEqual(bitmask_expected.tolist(), bitmask.tolist())
def test_multiple_actions(self):
logic = Game_Helpers()
preflop_history = np.zeros(1300)
preflop_history = preflop_history.reshape(25, 13, 4)
flop_history = np.zeros(1300).reshape(25, 13, 4)
turn_history = np.zeros(1300).reshape(25, 13, 4)
river_history = np.zeros(1300).reshape(25, 13, 4)
history_dict = {
'PREFLOP': preflop_history,
'FLOP': flop_history,
'TURN': turn_history,
'RIVER': river_history
}
# Small Blind
preflop_history[0, 0, 0:1] = 1
# Big Blind
preflop_history[1, 0, 0:2] = 1
preflop_history[2, 0:2, :] = 1
preflop_history[4, 0:6, :] = 1
street = 'RIVER'
stacks = logic.get_stack(history_dict, 500, 1, 2, street)
preflop_history[3, 0:6, :] = 1
stacks2 = logic.get_stack(history_dict, 500, 2, 2, street)
self.assertEqual(260, stacks, street)
self.assertEqual(260, stacks2, street)
def __init__(self, name, chips,agent):
self.agent = agent
self.name = name
self.cards = None
self.hand = np.zeros(shape = (1,13,4))
self.chips_preflop = np.zeros(shape = (1,13,4))
self.chips_flop = np.zeros(shape = (1,13,4))
self.chips_turn = np.zeros(shape = (1,13,4))
self.chips_river = np.zeros(shape = (1,13,4))
self.chips_dict = {'PREFLOP': self.chips_preflop,'FLOP':self.chips_flop,'TURN':self.chips_turn
,'RIVER':self.chips_river}
self.is_bb = np.zeros(shape = (1,13,4))
self.chips = chips
self.id = id
self.has_acted = False
self.active = True
self.is_allin = False
self.has_folded = False
self.is_blocking = False
self.next_player = None
self.position = None
self.current_stack = None
self.game_helpers = Game_Helpers()
self.game_state = None
self.chips_dict['PREFLOP'] = self.game_helpers.chips_bitmask_plane(chips)
self.state_memory = []
def test_blinds_raise(self):
logic = Game_Helpers()
preflop_history = np.zeros(1300)
preflop_history = preflop_history.reshape(25, 13, 4)
flop_history = np.zeros(1300).reshape(25, 13, 4)
turn_history = np.zeros(1300).reshape(25, 13, 4)
river_history = np.zeros(1300).reshape(25, 13, 4)
history_dict = {
'PREFLOP': preflop_history,
'FLOP': flop_history,
'TURN': turn_history,
'RIVER': river_history
}
# Small Blind
preflop_history[0, 0, 0:1] = 1
# Big Blind
preflop_history[1, 0, 0:2] = 1
preflop_history[2, 0:12, :] = 1
preflop_history[2, 12, 0:2] = 1
street = 'RIVER'
stacks = logic.get_stack(history_dict, 500, 1, 2, street)
stacks2 = logic.get_stack(history_dict, 500, 2, 2, street)
self.assertEqual(0, stacks)
self.assertEqual(480, stacks2)
def __init__(self, path):
self.path = path
self.game_state = np.zeros([113, 13, 4])
self.game_state_list = []
self.hand_history_list = []
self.current_hand_history = ''
self.statics = Game_Helpers()
def test_flop_check(self):
logic = Game_Helpers()
# 1 SB -> 2SB -> 6SB -> 4SB
blocking = np.zeros(52, dtype=int)
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
stack = logic.chips_bitmask(500)
legal_moves_arr = logic.legal_moves(stack, history, blocking, 'FLOP')
legal_moves_expected = np.ones(52)
legal_moves_expected[0] = 0
self.assertEqual(legal_moves_expected.tolist(),
legal_moves_arr.tolist())
def test_no_bets(self):
logic = Game_Helpers()
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
minraise_arr, call_size_arr, check = logic.get_current_raise(
history, 'FLOP')
minraise_expected = np.zeros(50, dtype=int)
minraise_expected[1:] = 1
call_expected = np.zeros(50, dtype=int)
check_expected = True
self.assertEqual(minraise_expected.tolist(), minraise_arr.tolist())
self.assertEqual(call_expected.tolist(), call_size_arr.tolist())
self.assertEqual(check_expected, check)
def test_raise_class(self):
logic = Game_Helpers()
blocking = np.zeros(50)
stack = logic.chips_bitmask(500)
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
move_arr = np.zeros(52, dtype = int)
move_arr[8] = 1
move_class,allin = logic.move_class(history,'PREFLOP',move_arr,stack)
move_class_expected = 'RAISE'
self.assertEqual(move_class_expected,move_class)
self.assertEqual(False, allin)
def test_blinds_and_call_covered(self):
logic = Game_Helpers()
blocking = np.zeros(52)
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0, 0:2] = 1
stack = logic.chips_bitmask(500)
legal_moves_arr = logic.legal_moves(stack, history, blocking,
'PREFLOP')
legal_moves_expected = np.zeros(52)
legal_moves_expected[3:] = 1
self.assertEqual(legal_moves_expected.tolist(),
legal_moves_arr.tolist())
def __init__(self, street="PREFLOP"):
self.i = 0
self.pool = []
self.positions = {}
self.current_player = None
self.action_no = 0
self.street = street
self.preflop_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.flop_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.turn_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.river_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.flop = None
self.turn = None
self.river = None
self.flop_bitmask = np.zeros(shape=(1, 13, 4), dtype=np.int_)
self.turn_bitmask = np.zeros(shape=(1, 13, 4), dtype=np.int_)
self.river_bitmask = np.zeros(shape=(1, 13, 4), dtype=np.int_)
self.history_dict = {
'PREFLOP': self.preflop_history,
'FLOP': self.flop_history,
'TURN': self.turn_history,
'RIVER': self.river_history
}
self.community_cards_dict = {
'FLOP': self.flop_bitmask,
'TURN': self.turn_bitmask,
'RIVER': self.river_bitmask
}
self.histories = [
self.preflop_history, self.flop_history, self.turn_history,
self.river_history
]
self.deck = list(range(52))
self.dealt = False
shuffle(self.deck)
self.num_players = 0
self.game_state = None
self.move_number = 2
self.blocking = np.zeros(50, dtype=np.int_)
self.statics = Game_Helpers()
self.active_hand = True
self.next_street = False
self.hand_history_str = ""
self.timer = 0
def test_blinds_and_underraise(self):
logic = Game_Helpers()
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0, 0:3] = 1
minraise_arr, call_size_arr, check = logic.get_current_raise(
history, 'FLOP')
minraise_expected = np.zeros(50, dtype=int)
minraise_expected[3:] = 1
call_expected = np.zeros(50, dtype=int)
call_expected[2] = 1
check_expected = False
self.assertEqual(call_expected.tolist(), call_size_arr.tolist())
self.assertEqual(minraise_expected.tolist(), minraise_arr.tolist())
self.assertEqual(check_expected, check)
def test_check_preflop(self):
# 1 SB -> 2SB -> 50 SB
logic = Game_Helpers()
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0, 0:2] = 1
minraise_arr, call_size_arr, check = logic.get_current_raise(
history, 'PREFLOP')
minraise_expected = np.zeros(50, dtype=int)
minraise_expected[3:] = 1
call_expected = np.zeros(50, dtype=int)
check_expected = True
self.assertEqual(minraise_expected.tolist(), minraise_arr.tolist())
self.assertEqual(call_expected.tolist(), call_size_arr.tolist())
self.assertEqual(check_expected, check)
def test_37sb_raise(self):
logic = Game_Helpers()
blocking = np.zeros(52)
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0:9, 0:4] = 1
history[2, 9, 0:3] = 1
stack = logic.chips_bitmask(500)
legal_moves_arr = logic.legal_moves(stack, history, blocking,
'PREFLOP')
legal_moves_expected = np.zeros(52)
legal_moves_expected[38] = 1
legal_moves_expected[49] = 1
legal_moves_expected[51] = 1
self.assertEqual(legal_moves_expected.tolist(),
legal_moves_arr.tolist())
def test_blinds_underraise(self):
# 1 SB -> 2SB -> 3 SB
logic = Game_Helpers()
blocking = np.zeros(50, dtype=int)
blocking[2] = 1
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0, 0:3] = 1
stack = logic.chips_bitmask(500)
legal_moves_arr = logic.legal_moves(stack, history, blocking,
'PREFLOP')
legal_moves_expected = np.zeros(52)
legal_moves_expected[2] = 1
legal_moves_expected[51] = 1
self.assertEqual(legal_moves_expected.tolist(),
legal_moves_arr.tolist())
def test_8sb_45sb_raises(self):
logic = Game_Helpers()
# 1 SB -> 2SB -> 6SB -> 4SB
blocking = np.zeros(52, dtype=int)
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, :12, :] = 1
stack = logic.chips_bitmask(410)
legal_moves_arr = logic.legal_moves(stack, history, blocking,
'PREFLOP')
legal_moves_expected = np.zeros(52)
legal_moves_expected[40] = 1
legal_moves_expected[51] = 1
#legal_moves_expected[49] = 1
self.assertEqual(legal_moves_expected.tolist(),
legal_moves_arr.tolist())
def test_just_blinds_covered(self):
logic = Game_Helpers()
blocking = np.zeros(50, dtype=int)
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
# Small Blind
history[0, 0, 0:1] = 1
# Big Blind
history[1, 0, 0:2] = 1
stack = logic.chips_bitmask(500)
legal_moves_arr = logic.legal_moves(stack, history, blocking,
'PREFLOP')
legal_moves_expected = np.zeros(52)
legal_moves_expected[1] = 1
legal_moves_expected[3:50] = 1
legal_moves_expected[51] = 1
self.assertEqual(legal_moves_expected.tolist(),
legal_moves_arr.tolist())
def test_normal_raise_uncovered_call_covered(self):
# 1 SB -> 2SB -> 16SB -> minraise = 28 SB but we only have a stack of 19 SB
logic = Game_Helpers()
blocking = np.zeros(52)
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0:4, 0:4] = 1
stack = logic.chips_bitmask(190)
legal_moves_arr = logic.legal_moves(stack, history, blocking,
'PREFLOP')
legal_moves_expected = np.zeros(52)
legal_moves_expected[15] = 1
legal_moves_expected[18] = 1
legal_moves_expected[51] = 1
self.assertEqual(legal_moves_expected.tolist(),
legal_moves_arr.tolist())
def test_allin_50sbs_first_action(self):
# 1 SB -> 2SB -> 50 SB
logic = Game_Helpers()
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0:12, 0:4] = 1
history[2, 12, 0:2] = 1
minraise_arr, call_size_arr, check = logic.get_current_raise(
history, 'FLOP')
minraise_expected = np.zeros(50, dtype=int)
call_expected = np.zeros(50, dtype=int)
call_expected[49] = 1
check_expected = False
self.assertEqual(minraise_expected.tolist(), minraise_arr.tolist())
self.assertEqual(call_expected.tolist(), call_size_arr.tolist())
self.assertEqual(check_expected, check)
def test_normal_raise(self):
#1 SB -> 2SB -> 6SB -> minraise = 10 SB
logic = Game_Helpers()
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
history[0, 0, 0:1] = 1
history[1, 0, 0:2] = 1
history[2, 0, 0:4] = 1
history[2, 1, 0:2] = 1
minraise_arr, call_size_arr, check = logic.get_current_raise(
history, 'FLOP')
minraise_expected = np.zeros(50, dtype=int)
minraise_expected[9:] = 1
call_expected = np.zeros(50, dtype=int)
call_expected[5] = 1
check_expected = False
self.assertEqual(minraise_expected.tolist(), minraise_arr.tolist())
self.assertEqual(call_expected.tolist(), call_size_arr.tolist())
self.assertEqual(check_expected, check)
def test_full_allin(self):
logic = Game_Helpers()
history = np.zeros(1300)
history = history.reshape(25, 13, 4)
#Small Blind
history[0, 0, 0:1] = 1
#Big Blind
history[1, 0, 0:2] = 1
history[2, 0:12, :] = 1
history[2, 12, 0:2] = 1
minraise_arr, call_size_arr, check = logic.get_current_raise(
history, 'FLOP')
minraise_expected = np.zeros(50, dtype=int)
call_expected = np.zeros(50, dtype=int)
call_expected[49] = 1
check_expected = False
self.assertEqual(minraise_expected.tolist(), minraise_arr.tolist())
self.assertEqual(call_expected.tolist(), call_size_arr.tolist())
self.assertEqual(check_expected, check)
def make_move(self, move):
chips = np.argmax(move)
chips_bitmask = Game_Helpers.chips_bitmask((chips + 1) * 10)
history = self.history_dict[self.street]
check_fold = np.zeros(2)
chips_bitmask = np.hstack((chips_bitmask, check_fold))
chips_bitmask = chips_bitmask.reshape(1, 13, 4)
if (chips == 50):
history[self.move_number, 12, 2] = 1
elif (chips == 51):
history[self.move_number, 12, 3] = 1
#print(history[self.move_number, 12, 3] == 1,self.move_number,self.street)
#print(self.preflop_history[self.move_number,:,:])
else:
history[self.move_number, :, :] = chips_bitmask
def test_bitmask_600(self):
logic = Game_Helpers()
bitmask = logic.chips_bitmask(600)
bitmask_expected = np.ones(50)
self.assertEqual(bitmask_expected.tolist(), bitmask.tolist())
class encoder:
def __init__(self, path):
self.path = path
self.game_state = np.zeros([113, 13, 4])
self.game_state_list = []
self.hand_history_list = []
self.current_hand_history = ''
self.statics = Game_Helpers()
def get_hand_histories(self):
file = open(self.path, 'r')
hand_history = ''
for line in file:
if line != '\n':
hand_history += line
else:
self.hand_history_list.append(hand_history)
hand_history = ''
for hand in self.hand_history_list:
self.current_hand_history = hand
self.get_chips()
self.game_state_list.append(self.game_state)
self.game_state = np.zeros([113, 13, 4])
def get_chips(self):
seat_1_chips = re.sub(
"[^\\d]", '',
re.findall('([0-9]* in chips)', self.current_hand_history)[0])
seat_2_chips = re.sub(
"[^\\d]", '',
re.findall('([0-9]* in chips)', self.current_hand_history)[1])
sb_name = re.findall('.*: posts small blind',
self.current_hand_history)[0]
bb_name = re.findall('.*: posts big blind',
self.current_hand_history)[0]
index_sb = sb_name.find(':')
index_bb = bb_name.find(':')
sb_name = sb_name[:index_sb]
bb_name = bb_name[:index_bb]
own_name = re.findall('Dealt to .*\n', self.current_hand_history)[0]
is_bb = 0
if bb_name in own_name:
is_bb = 1
hole_cards = re.search('\[.*\]', own_name)[0].strip('[]').split()
hole_cards_idx = []
keys = list(card_dict.keys())
values = list(card_dict.values())
layer = np.zeros(52)
for card in hole_cards:
idx = keys[values.index(card)]
hole_cards_idx.append(idx)
layer[idx] = 1
self.game_state[112, :, :] = layer.reshape(1, 13, 4)
splits = self.current_hand_history.split('\n')
current_street = 'PREFLOP'
preflop_actions = []
flop_actions = []
turn_actions = []
river_actions = []
rewards = []
action_dict = {
'PREFLOP': preflop_actions,
'FLOP': flop_actions,
'TURN': turn_actions,
'RIVER': river_actions,
'REWARDS': rewards
}
for action in splits:
if action.startswith('*** FLOP ***'):
current_street = 'FLOP'
elif action.startswith('*** TURN ***'):
current_street = 'TURN'
elif action.startswith('*** RIVER ***'):
current_street = 'RIVER'
if (action.startswith(sb_name + ":") or action.startswith(bb_name + ":")) and not (action.startswith(sb_name + ": shows") \
or action.startswith(bb_name + ": shows")):
action_dict[current_street].append(action)
test = sb_name + ": shows"
self.set_action_history(preflop_actions, 'PREFLOP')
self.set_action_history(flop_actions, 'FLOP')
self.set_action_history(turn_actions, 'TURN')
self.set_action_history(river_actions, 'RIVER')
if is_bb == 1:
self.game_state[111, :, :] = 1
#seat_1_player = Player(sb_name,int(seat_1_chips),None)
#seat_2_player = Player(bb_name, int(seat_2_chips), None)
#pool = [seat_1_player,seat_2_player]
#seat_1_player.set_hand(hole_cards_idx[0],hole_cards_idx[1])
#seat_2_player.set_hand(2, 3)
self.get_board()
self.set_stacks(int(seat_1_chips))
#decoders = decoder(self.game_state,pool,'hero')
#decoders.prints()
def set_action_history(self, actions, street):
id = -1
i = 0
if street == 'PREFLOP':
#Blinds
self.game_state[8, 0, 0] = 1
self.game_state[9, 0, 0:2] = 1
del actions[0:2]
id = 8
i = 2
elif street == 'FLOP':
id = 33
elif street == 'TURN':
id = 58
elif street == 'RIVER':
id = 83
for action in actions:
if action.find('raises') != -1 or action.find('bets') != -1:
size = re.sub('([^\d \s])', '', action).split()
size = np.max(list(map(int, size)))
layer = self.statics.chips_bitmask_plane(int(size))
self.game_state[id + i, :, :] = layer
if action.find('folds') != -1:
self.game_state[id + i, 12, 3] = 1
if action.find('checks') != -1:
self.game_state[id + i, 12, 2] = 1
if action.find('calls') != -1:
size = int(re.sub('([^\d])', '', action))
previous_paid = (
self.game_state[id + i - 2, 0:12, 0:4].sum(-1).sum(-1) +
self.game_state[id + i - 2, 12, 0:2].sum(-1)) * 10
layer = self.statics.chips_bitmask_plane(
int(size) + previous_paid)
self.game_state[id + i, :, :] = layer
i += 1
def get_board(self):
keys = list(card_dict.keys())
values = list(card_dict.values())
if re.findall('\*\*\* FLOP \*\*\* \[.*\]',
self.current_hand_history) != []:
flop = re.sub(
'\*\*\* FLOP \*\*\* ', '',
re.findall('\*\*\* FLOP \*\*\* \[.*\]',
self.current_hand_history)[0])
flop = re.search('\[.*\]', flop)[0].strip('[]').split()
layer = np.zeros(52)
for card in flop:
idx = keys[values.index(card)]
layer[idx] = 1
self.game_state[108, :, :] = layer.reshape(1, 13, 4)
if re.findall('\*\*\* TURN \*\*\* \[.*\] \[..\]',
self.current_hand_history) != []:
layer = np.zeros(52)
turn = re.sub(
'\*\*\* TURN \*\*\* ', '',
re.findall('\*\*\* TURN \*\*\* \[.*\] \[..\]',
self.current_hand_history)[0])
turn = re.search('\[..\]', turn)[0].strip('[]').split()
for card in turn:
idx = keys[values.index(card)]
layer[idx] = 1
self.game_state[109, :, :] = layer.reshape(1, 13, 4)
if re.findall('\*\*\* RIVER \*\*\* \[.*\] \[..\]',
self.current_hand_history) != []:
layer = np.zeros(52)
river = re.sub(
'\*\*\* RIVER \*\*\* ', '',
re.findall('\*\*\* RIVER \*\*\* \[.*\] \[..\]',
self.current_hand_history)[0])
river = re.search('\[..\]', river)[0].strip('[]').split()
for card in river:
idx = keys[values.index(card)]
layer[idx] = 1
self.game_state[110, :, :] = layer.reshape(1, 13, 4)
def set_stacks(self, stack):
preflop_history = self.game_state[8:33, :, :]
flop_history = self.game_state[33:58, :, :]
turn_history = self.game_state[58:83, :, :]
river_history = self.game_state[83:108, :, :]
history = {
'PREFLOP': preflop_history,
'FLOP': flop_history,
'TURN': turn_history,
'RIVER': river_history
}
layer = self.statics.chips_bitmask_plane(int(stack))
self.game_state[0, :, :] = layer
layer = self.statics.chips_bitmask_plane(int(stack))
self.game_state[4, :, :] = layer
self.game_state[1, :, :] = self.statics.chips_bitmask_plane(
self.statics.get_stack(history, stack, 1, 2, 'FLOP'))
self.game_state[2, :, :] = self.statics.chips_bitmask_plane(
self.statics.get_stack(history, stack, 1, 2, 'TURN'))
self.game_state[3, :, :] = self.statics.chips_bitmask_plane(
self.statics.get_stack(history, stack, 1, 2, 'RIVER'))
self.game_state[5, :, :] = self.statics.chips_bitmask_plane(
self.statics.get_stack(history, stack, 1, 2, 'FLOP'))
self.game_state[6, :, :] = self.statics.chips_bitmask_plane(
self.statics.get_stack(history, stack, 1, 2, 'TURN'))
self.game_state[7, :, :] = self.statics.chips_bitmask_plane(
self.statics.get_stack(history, stack, 1, 2, 'RIVER'))
class Game():
preflop_order = {1: "SB", 2: "SB", 3: "SB", 4: "SB", 5: "SB", 6: "SB"}
postflop_order = {1: 1, 2: 2, 3: 1, 4: 1, 5: 1, 6: 1}
streets = {
"PREFLOP": "FLOP",
"FLOP": "TURN",
"TURN": "RIVER",
"RIVER": "REWARDS",
"REWARDS": "REWARDS"
}
card_dict = {
0: '2s',
1: '3s',
2: '4s',
3: '5s',
4: '6s',
5: '7s',
6: '8s',
7: '9s',
8: 'Ts',
9: 'Js',
10: 'Qs',
11: 'Ks',
12: 'As',
13: '2d',
14: '3d',
15: '4d',
16: '5d',
17: '6d',
18: '7d',
19: '8d',
20: '9d',
21: 'Td',
22: 'Jd',
23: 'Qd',
24: 'Kd',
25: 'Ad',
26: '2h',
27: '3h',
28: '4h',
29: '5h',
30: '6h',
31: '7h',
32: '8h',
33: '9h',
34: 'Th',
35: 'Jh',
36: 'Qh',
37: 'Kh',
38: 'Ah',
39: '2c',
40: '3c',
41: '4c',
42: '5c',
43: '6c',
44: '7c',
45: '8c',
46: '9c',
47: 'Tc',
48: 'Jc',
49: 'Qc',
50: 'Kc',
51: 'Ac'
}
def __init__(self, street="PREFLOP"):
self.i = 0
self.pool = []
self.positions = {}
self.current_player = None
self.action_no = 0
self.street = street
self.preflop_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.flop_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.turn_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.river_history = np.zeros(shape=(25, 13, 4), dtype=np.int_)
self.flop = None
self.turn = None
self.river = None
self.flop_bitmask = np.zeros(shape=(1, 13, 4), dtype=np.int_)
self.turn_bitmask = np.zeros(shape=(1, 13, 4), dtype=np.int_)
self.river_bitmask = np.zeros(shape=(1, 13, 4), dtype=np.int_)
self.history_dict = {
'PREFLOP': self.preflop_history,
'FLOP': self.flop_history,
'TURN': self.turn_history,
'RIVER': self.river_history
}
self.community_cards_dict = {
'FLOP': self.flop_bitmask,
'TURN': self.turn_bitmask,
'RIVER': self.river_bitmask
}
self.histories = [
self.preflop_history, self.flop_history, self.turn_history,
self.river_history
]
self.deck = list(range(52))
self.dealt = False
shuffle(self.deck)
self.num_players = 0
self.game_state = None
self.move_number = 2
self.blocking = np.zeros(50, dtype=np.int_)
self.statics = Game_Helpers()
self.active_hand = True
self.next_street = False
self.hand_history_str = ""
self.timer = 0
def update_dicts(self):
self.history_dict = {
'PREFLOP': self.preflop_history,
'FLOP': self.flop_history,
'TURN': self.turn_history,
'RIVER': self.river_history
}
self.community_cards_dict = {
'FLOP': self.flop_bitmask,
'TURN': self.turn_bitmask,
'RIVER': self.river_bitmask
}
self.game_state = None
def add(self, player):
self.pool.append(player)
self.update_pool()
self.num_players = self.num_players + 1
# updates next_Player pointers after adding or shuffling players
def update_pool(self):
i = 0
for i in range(0, len(self.pool)):
self.positions[i] = self.pool[i]
self.positions[i].position = i + 1
if i < (len(self.pool) - 1):
self.positions[i].next_player = self.pool[i + 1]
else:
self.positions[i].next_player = self.pool[0]
self.current_player = self.pool[0]
# Shuffles the player list and puts them on different positions, so we get a random position in training
def update_own_flags(self, move, allin):
if move == 'FOLD':
self.current_player.has_folded = True
self.current_player.active = False
if allin:
self.current_player.is_allin = True
self.current_player.active = False
if move == 'CALL':
self.current_player.has_acted = True
if move == 'CHECK':
self.current_player.has_acted = True
if move == 'RAISE':
self.update_all_flags()
self.current_player.has_acted = True
self.is_next_street()
def shuffle_players(self):
shuffle(self.pool)
self.update_pool()
def set_blinds_and_deal(self):
self.preflop_history[0, 0, 0] = 1
self.preflop_history[1, 0, 0:2] = 1
for player in self.pool:
if (player.position == 2):
player.is_bb = np.ones(52).reshape(1, 13, 4)
cardA = self.deck.pop()
cardB = self.deck.pop()
player.set_hand(cardA, cardB)
player.cards = [cardA, cardB]
def deal(self):
if self.street == 'FLOP':
self.flop = [self.deck.pop(), self.deck.pop(), self.deck.pop()]
self.hand_history_str += "*** FLOP *** [" + self.card_dict[self.flop[0]] \
+" " + self.card_dict[self.flop[1]] +" "+ self.card_dict[self.flop[2]] + "]"\
+"\n"
self.flop_bitmask = self.flop_bitmask.flatten()
self.flop_bitmask[self.flop] = 1
self.flop_bitmask = self.flop_bitmask.reshape(1, 13, 4)
elif self.street == 'TURN':
self.turn = [self.deck.pop()]
self.hand_history_str += "*** TURN *** [" + self.card_dict[
self.turn[0]] + "]" + "\n"
self.turn_bitmask = self.turn_bitmask.flatten()
self.turn_bitmask[self.turn] = 1
self.turn_bitmask = self.turn_bitmask.reshape(1, 13, 4)
elif self.street == 'RIVER':
self.river = [self.deck.pop()]
self.hand_history_str += "*** RIVER *** [" + self.card_dict[
self.river[0]] + "]" + "\n"
self.river_bitmask = self.river_bitmask.flatten()
self.river_bitmask[self.river] = 1
self.river_bitmask = self.river_bitmask.reshape(1, 13, 4)
self.update_all_flags()
for player in self.pool:
if (player.position == self.postflop_order[self.num_players]):
self.current_player = player
self.is_next_street()
def update_all_flags(self):
for player in self.pool:
if (player.is_allin == True or player.has_folded == True):
player.has_acted = 1
else:
player.has_acted = 0
def is_active_hand(self):
count = 0
for player in self.pool:
if (player.has_folded == True):
count = count + 1
if (count + 1 == self.num_players):
return False
count = 0
for player in self.pool:
if (player.active == False):
count = count + 1
if (count == self.num_players):
return False
return True
def is_next_street(self):
for player in self.pool:
if (player.has_acted == False):
self.next_street = False
return
self.next_street = True
def build_game_state(self):
self.game_state = None
self.update_dicts()
for player in self.pool:
for key in player.chips_dict:
if (self.game_state is not None):
self.game_state = np.concatenate(
(self.game_state, player.chips_dict[key]))
else:
self.game_state = player.chips_dict[key]
for key in self.history_dict:
self.game_state = np.concatenate(
(self.game_state, self.history_dict[key]))
for key in self.community_cards_dict:
self.game_state = np.concatenate(
(self.game_state, self.community_cards_dict[key]))
def game_start(self):
if (self.dealt == False):
self.set_blinds_and_deal()
self.dealt = True
while self.street != 'REWARDS':
while (self.next_street == False):
if (self.street == 'REWARDS'):
break
self.update_dicts()
self.build_game_state()
move, current_stack = self.current_player.get_move(
self.history_dict, self.blocking, self.num_players,
self.street, self.game_state)
move_class, allin = self.statics.move_class(
self.history_dict[self.street], self.street, move,
current_stack)
self.make_move(move)
self.update_own_flags(move_class, allin)
#print(self.current_player.name, current_stack.sum()*10, self.current_player.active,np.argmax(move),
# move_class,allin,self.street)
self.move_number = self.move_number + 1
self.current_player = self.current_player.next_player
self.active_hand = self.is_active_hand()
if (self.active_hand == False):
break
self.move_number = 0
self.street = self.streets[self.street]
if (self.pool[0].has_folded == False
and self.pool[1].has_folded == False
and self.street != 'REWARDS'):
self.deal()
else:
self.street = self.streets['REWARDS']
self.build_game_state()
self.pool[0].build_player_game_state(self.game_state)
self.pool[1].build_player_game_state(self.game_state)
x = time.time()
decoders = decoder(self.pool[0].game_state, self.pool,
self.pool[0].name)
decoders.prints()
winners = self.statics.winner(self.pool[0].game_state,
decoders.seat_1_hand,
decoders.seat_2_hand)
y = time.time()
self.timer += (y - x)
time.sleep(5)
print(decoders.winner, winners)
winner = decoders.winner
reward_p1 = 0
reward_p2 = 0
if winner == 1:
reward_p1 = (decoders.total) / 100
reward_p2 = (decoders.total) / 100 * -1
elif winner == 2:
reward_p1 = (decoders.total) / 100 * -1
reward_p2 = (decoders.total) / 100
self.pool[0].set_reward(reward_p1)
self.pool[1].set_reward(reward_p2)
def make_move(self, move):
chips = np.argmax(move)
chips_bitmask = Game_Helpers.chips_bitmask((chips + 1) * 10)
history = self.history_dict[self.street]
check_fold = np.zeros(2)
chips_bitmask = np.hstack((chips_bitmask, check_fold))
chips_bitmask = chips_bitmask.reshape(1, 13, 4)
if (chips == 50):
history[self.move_number, 12, 2] = 1
elif (chips == 51):
history[self.move_number, 12, 3] = 1
#print(history[self.move_number, 12, 3] == 1,self.move_number,self.street)
#print(self.preflop_history[self.move_number,:,:])
else:
history[self.move_number, :, :] = chips_bitmask
class Player():
def __init__(self, name, chips,agent):
self.agent = agent
self.name = name
self.cards = None
self.hand = np.zeros(shape = (1,13,4))
self.chips_preflop = np.zeros(shape = (1,13,4))
self.chips_flop = np.zeros(shape = (1,13,4))
self.chips_turn = np.zeros(shape = (1,13,4))
self.chips_river = np.zeros(shape = (1,13,4))
self.chips_dict = {'PREFLOP': self.chips_preflop,'FLOP':self.chips_flop,'TURN':self.chips_turn
,'RIVER':self.chips_river}
self.is_bb = np.zeros(shape = (1,13,4))
self.chips = chips
self.id = id
self.has_acted = False
self.active = True
self.is_allin = False
self.has_folded = False
self.is_blocking = False
self.next_player = None
self.position = None
self.current_stack = None
self.game_helpers = Game_Helpers()
self.game_state = None
self.chips_dict['PREFLOP'] = self.game_helpers.chips_bitmask_plane(chips)
self.state_memory = []
def reset(self,chips):
self.cards = None
self.hand = np.zeros(shape = (1,13,4))
self.chips_preflop = np.zeros(shape = (1,13,4))
self.chips_flop = np.zeros(shape = (1,13,4))
self.chips_turn = np.zeros(shape = (1,13,4))
self.chips_river = np.zeros(shape = (1,13,4))
self.chips_dict = {'PREFLOP': self.chips_preflop, 'FLOP': self.chips_flop, 'TURN': self.chips_turn
, 'RIVER': self.chips_river}
self.is_bb = np.zeros(shape = (1,13,4))
self.chips = chips
self.id = id
self.has_acted = False
self.active = True
self.is_allin = False
self.has_folded = False
self.is_blocking = False
self.next_player = None
self.position = None
self.current_stack = None
self.game_helpers = Game_Helpers()
self.game_state = None
self.chips_dict['PREFLOP'] = self.game_helpers.chips_bitmask_plane(chips)
self.agent.reset()
self.state_memory = []
def set_hand(self,cardA,cardB):
self.hand = self.hand.flatten()
self.hand[cardA] = 1
self.hand[cardB] = 1
self.hand = self.hand.reshape(1, 13, 4)
def build_player_game_state(self,public_state):
self.game_state = public_state
self.game_state = np.concatenate((self.game_state, self.is_bb))
self.game_state = np.concatenate((self.game_state, self.hand))
def set_street_stacks(self,history,street,player_number):
current_stack = self.game_helpers.get_stack(history, self.chips, self.position, player_number, street)
self.chips_dict[street] = self.game_helpers.chips_bitmask_plane(current_stack)
def set_reward(self,reward):
for i in range(0,len(self.state_memory)):
rl_state = None
if i <= len(self.state_memory) -2:
rl_state = {'state0': self.state_memory[i]['state'],'action0':self.state_memory[i]['action'],
'state1':self.state_memory[i+1]['state'],'reward':0}
elif i == len(self.state_memory) -1:
rl_state = {'state0': self.state_memory[i]['state'], 'action0': self.state_memory[i]['action'],
'state1': 'Terminal', 'reward': reward}
self.agent.save_rl_transition(rl_state)
def get_move(self,history,blocking,player_number,street,public_state):
self.set_street_stacks(history, street, player_number)
current_history = history[street]
current_stack = self.game_helpers.get_stack(history,self.chips,self.position,player_number,street)
bitmask_stack = self.game_helpers.chips_bitmask(current_stack)
legals = self.game_helpers.legal_moves(bitmask_stack, current_history , blocking, street)
legals = np.argwhere(legals == 1)
self.build_player_game_state(public_state)
moves,game_state_dict = self.agent.get_move(history,blocking,player_number,street,self.game_state,legals,None)
self.state_memory.append(game_state_dict)
return moves,bitmask_stack
