def test_is_my_turn(): ## ok!!!
log = logging.getLogger(__name__)
mongo = MongoManager()
table_dict = mongo.get_table('GG_6TABLE')
test_src = os.environ['test_src']
table_scraper = TableScraper(table_dict)
table_scraper.screenshot = Image.open(os.path.join(test_src, '1.PNG'))
table_scraper.crop_from_top_left_corner2(select_table=0)
screenshot = table_scraper.crop_from_top_left_corner()
status = is_template_in_search_area(table_dict, screenshot,
'my_turn', 'my_turn_search_area', table_scraper.scale_defaults)
log.debug(is_template_in_search_area(table_dict, screenshot,
'my_turn', 'my_turn_search_area', table_scraper.scale_defaults))
#
search_area = table_dict['my_turn_search_area']
template = table_dict['my_turn']
template_cv2 = binary_pil_to_cv2(template)
cropped_screenshot = screenshot.crop((search_area['x1'], search_area['y1'], search_area['x2'], search_area['y2']))
screenshot_cv2 = pil_to_cv2(cropped_screenshot)
# plt.imshow(cropped_screenshot, cmap='gray', interpolation='bicubic') # ok!
# plt.imshow(template_cv2, cmap='gray', interpolation='bicubic')
# plt.show()
assert status == True
def has_check_button(self):
"""Check if check button is present"""
self.check_button = is_template_in_search_area(self.table_dict,
self.screenshot,
'check_button',
'buttons_search_area',
self.scale_defaults)
log.info(f"Check button found: {self.check_button}")
return self.check_button
def is_dealer_changed(self, player):
if is_template_in_search_area(self.table_dict, self.screenshot,
'dealer_button', 'button_search_area',
self.scale_defaults, str(player)):
log.info(f"Dealer position not changed.")
return True
else:
log.info(f"Dealer position changed.")
return False
def has_call_button(self):
"""Chek if call button is visible"""
self.call_button = is_template_in_search_area(self.table_dict,
self.screenshot,
'call_button',
'buttons_search_area',
self.scale_defaults)
log.info(f"Call button found: {self.call_button}")
return self.call_button
def is_template_in_search_area1(self, arg={'name': None, 'player': None}):
name = arg['name']
player = arg['player']
time_cv2_start = datetime.datetime.utcnow()
if player is not None:
if name == 'dealer_button':
if is_template_in_search_area(self.table_dict, self.screenshot,
'dealer_button',
'button_search_area',
self.scale_defaults,
str(player)):
self.dealer_position = player
elif name == 'covered_card':
if is_template_in_search_area(self.table_dict, self.screenshot,
'covered_card',
'covered_card_area',
self.scale_defaults,
str(player)):
self.players_in_game.append(player)
elif name == 'miss_player':
if is_template_in_search_area(self.table_dict, self.screenshot,
'miss_player',
'miss_player_area',
self.scale_defaults,
str(player)):
self.miss_player.append(player)
elif name == 'sitting_out':
if is_template_in_search_area(self.table_dict, self.screenshot,
'sitting_out',
'miss_player_area',
self.scale_defaults,
str(player)):
self.miss_player.append(player)
if name == 'raise_button':
self.raise_button = is_template_in_search_area(
self.table_dict, self.screenshot, 'raise_button',
'buttons_search_area', self.scale_defaults)
if name == 'call_button':
self.call_button = is_template_in_search_area(
self.table_dict, self.screenshot, 'call_button',
'buttons_search_area', self.scale_defaults)
if name == 'all_in_call_button':
self.all_in_call_button = is_template_in_search_area(
self.table_dict, self.screenshot, 'all_in_call_button',
'buttons_search_area', self.scale_defaults)
if name == 'check_button':
self.check_button = is_template_in_search_area(
self.table_dict, self.screenshot, 'check_button',
'buttons_search_area', self.scale_defaults)
time_cv2_end = datetime.datetime.utcnow()
log.info(f"Collapsed time for {name}: {time_cv2_end - time_cv2_start}")
return True
def get_dealer_position2(self):
"""Determines position of dealer, where 0=myself, continous counter clockwise"""
for i in range(self.total_players):
if is_template_in_search_area(self.table_dict, self.screenshot,
'dealer_button', 'button_search_area', str(i)):
self.dealer_position = i
log.info(f"Dealer found at position {i}")
return True
log.warning("No dealer found.")
self.dealer_position = 0
def get_my_cards2(self):
"""Get my cards"""
self.my_cards = []
# if is_template_in_search_area(self.table_dict, self.screenshot,
# 'adl', 'my_left_card_area'):
# self.my_cards.append('ad')
# if is_template_in_search_area(self.table_dict, self.screenshot,
# '7hr', 'my_right_card_area'):
# self.my_cards.append('7h')
for value in CARD_VALUES:
for suit in CARD_SUITES:
if is_template_in_search_area(
self.table_dict, self.screenshot,
value.lower() + suit.lower() + 'l',
'my_left_card_area', self.scale_defaults):
self.my_cards.append(value + suit)
if is_template_in_search_area(
self.table_dict, self.screenshot,
value.lower() + suit.lower() + 'r',
'my_right_card_area', self.scale_defaults):
self.my_cards.append(value + suit)
if len(self.my_cards) >= 3:
self.my_cards = list(set(self.my_cards))
# image_area = 'my_cards_area' # 'my_cards_area' #
#
# search_area = self.table_dict[image_area]
# cropped_screenshot = self.screenshot.crop(
# (search_area['x1'], search_area['y1'], search_area['x2'], search_area['y2']))
#
# cropped_screenshot = pil_to_cv2(cropped_screenshot)
# cardsFound, allValueMatches = watchAndDisplayCards(cropped_screenshot, image_area)
# self.my_cards = list(cardsFound)
# if len(self.my_cards) != 2:
# if len(self.my_cards) == 1:
# self.screenshot.save("pics/ErrMyCardRecognize.png")
# assert len(self.my_cards) != 1, "My cards can never be 1"
# log.info("My cards are not recognized")
log.info(f"My cards: {self.my_cards}")
return True
def get_table_cards2(self):
"""Get the cards on the table"""
self.table_cards = []
for value in CARD_VALUES:
for suit in CARD_SUITES:
if is_template_in_search_area(self.table_dict, self.screenshot,
value.lower() + suit.lower(), 'table_cards_area'):
self.table_cards.append(value + suit)
log.info(f"Table cards: {self.table_cards}")
assert len(self.table_cards) != 1, "Table cards can never be 1"
assert len(self.table_cards) != 2, "Table cards can never be 2"
return True
def get_my_cards2(self):
"""Get my cards"""
self.my_cards = []
for value in CARD_VALUES:
for suit in CARD_SUITES:
if is_template_in_search_area(self.table_dict, self.screenshot,
value.lower() + suit.lower(), 'my_cards_area'):
self.my_cards.append(value + suit)
if len(self.my_cards) != 2:
log.warning("My cards not recognized")
log.info(f"My cards: {self.my_cards}")
return True
def get_players_in_game(self):
"""
Get players in the game by checking for covered cards.
Return: list of ints
"""
self.players_in_game = [0] # assume myself in game
for i in range(1, self.total_players):
if is_template_in_search_area(self.table_dict, self.screenshot,
'covered_card', 'covered_card_area', str(i)):
self.players_in_game.append(i)
log.info(f"Players in game: {self.players_in_game}")
return True
def get_table_cards2(self):
"""Get the cards on the table"""
self.table_cards = []
# if is_template_in_search_area(self.table_dict, self.screenshot,
# '3h', 'table_cards_area'):
# self.table_cards.append('3h')
# if is_template_in_search_area(self.table_dict, self.screenshot,
# '6h', 'table_cards_area'):
# self.table_cards.append('6h')
# if is_template_in_search_area(self.table_dict, self.screenshot,
# 'js', 'table_cards_area'):
# self.table_cards.append('js')
for value in CARD_VALUES:
for suit in CARD_SUITES:
if is_template_in_search_area(self.table_dict, self.screenshot,
value.lower() + suit.lower(),
'table_cards_area',
self.scale_table_cards_area):
self.table_cards.append(value + suit)
# image_area = 'table_cards_area' # 'my_cards_area' #
#
# search_area = self.table_dict[image_area]
# cropped_screenshot = self.screenshot.crop(
# (search_area['x1'], search_area['y1'], search_area['x2'], search_area['y2']))
#
# cropped_screenshot = pil_to_cv2(cropped_screenshot)
# cardsFound, allValueMatches = watchAndDisplayCards(cropped_screenshot, image_area)
# self.table_cards = list(cardsFound)
#
# log.info(f"Table cards: {self.table_cards}")
# if len(self.table_cards) == 1 or len(self.table_cards) == 2:
# self.screenshot.save("pics/ErrTableCardRecognize.png")
# # assert len(self.table_cards) != 1, "Table cards can never be 1"
# # assert len(self.table_cards) != 2, "Table cards can never be 2"
return True
def im_back(self):
"""Check if I'm back button is visible"""
return is_template_in_search_area(self.table_dict, self.screenshot,
'im_back', 'buttons_search_area')
def lost_everything(self):
"""Check if lost everything has occurred"""
return is_template_in_search_area(self.table_dict, self.screenshot,
'lost_everything', 'lost_everything_search_area')
def has_all_in_call_button(self):
"""Check if all in call button is present"""
return is_template_in_search_area(self.table_dict, self.screenshot,
'all_in_call_button', 'buttons_search_area')
def is_my_turn(self):
"""Check if it's my turn"""
return is_template_in_search_area(self.table_dict, self.screenshot,
'my_turn', 'my_turn_search_area')
def fast_fold(self):
"""Find out if fast fold button is present"""
return is_template_in_search_area(self.table_dict, self.screenshot,
'fast_fold_button', 'my_turn_search_area')
def check_button(self):
"""See if check button is avaialble"""
return is_template_in_search_area(self.table_dict, self.screenshot,
'check_button', 'buttons_search_area')
def has_raise_button(self):
"""Check if raise button is present"""
self.raise_button = is_template_in_search_area(self.table_dict, self.screenshot,
'raise_button', 'buttons_search_area')
log.info(f"Raise button found: {self.raise_button}")
return self.raise_button
def is_new_action(self, t):
"""
if there is pot change for player in game, returns True.
"""
# t.get_pots() # update current_round_pot and total_pot
# # Prepare to check Active player abs
# t.get_players_in_game()
# t.get_player_pots(skip=[])
# t.get_my_cards3()
self.is_my_turn = t.is_my_turn()
# self.players_in_game_abs = t.players_in_game
is_zero_covered = is_template_in_search_area(t.table_dict,
t.screenshot,
'covered_card',
'covered_card_area',
t.scale_defaults, str(0))
# To use in Round test.
is_bb_covered = is_template_in_search_area(t.table_dict, t.screenshot,
'covered_card',
'covered_card_area',
t.scale_defaults, str(5))
self_logger.debug(f"player 0 is covered card {is_zero_covered}")
self_logger.debug(f"player 5 is covered card {is_bb_covered}")
if not self.is_my_turn and not is_zero_covered:
try:
index = self.players_in_game_abs.index(0)
self.players_in_game_abs.pop(index)
except:
pass
if not is_bb_covered:
try:
index = self.players_in_game_abs.index(5)
self.players_in_game_abs.pop(index)
except:
pass
# Update player in game with now_player_order.
self.update_player_in_game(t)
if len(self.players_in_game_abs1) == 0:
self_logger.info(f"There is no Players in game for this Preflop.")
return False
self.player_pots = t.player_pots
# test active player abs and rels
if self.is_my_turn:
self.active_player_abs = 0
self.active_player_rel = self.find_rel_pos(self.active_player_abs)
self.current_active_player = self.player_round[
self.active_player_rel]
else:
self_logger.info(
f"players in game rel: {self.players_in_game_rel}")
self_logger.info(
f"players in game abs1: {self.players_in_game_abs1}")
if not self.get_active_player_abs():
self_logger.info(f'No active player')
return False
self.active_player_rel = self.find_rel_pos(self.active_player_abs)
self.current_active_player = self.player_round[
self.active_player_rel]
self_logger.info(f'active player abs: {self.active_player_abs}')
self_logger.info(f'active player rels: {self.active_player_rel}')
self_logger.info(
f'current active player: {self.current_active_player}')
# Get current Round
if self.get_round_status():
self_logger.info(f'round: {self.round}')
self_logger.info(f'Now Player Order: {self.now_player_order}')
else:
self_logger.info(f'Failed to check round status.')
return False
# Get player action:
if self.round == 1:
tmp = 0
else:
tmp = self.max_player
if self.now_player_order > self.active_player_rel + tmp:
self_logger.info(f'It is up-to-date')
self_logger.info(f" actions: {self.actions}")
return False
while self.now_player_order <= self.active_player_rel + tmp:
t.get_pots2("total_pot_area")
self.now_player_order_abs = self.find_abs_pos(
self.now_player_order)
self_logger.debug(
f"-----------Debug log---------------------------------")
self_logger.debug(f'round: {self.round}')
self_logger.debug(f'dealer: {self.dealer_position}')
self_logger.debug(f"total_pot: {t.total_pot} ")
self_logger.debug(f"now_player_order: {self.now_player_order}")
self_logger.debug(
f"now_player_order_abs: {self.now_player_order_abs}")
t.get_player_pots_nn(self.now_player_order_abs)
self_logger.debug(
f"current_pot: {t.player_pots[self.now_player_order_abs]}")
self_logger.debug(
f"players_in_game_abs1: {self.players_in_game_abs1}")
self_logger.debug(f'current_round_pot: {t.current_round_pot}')
self_logger.debug(f'self.last_image_pots: {self.last_image_pots}')
self_logger.debug(f'self.player_pots: {self.player_pots}')
self_logger.debug(f'SB: {self.small_blind}')
self_logger.debug(f"--------------------------------------------")
# handle players not in game
if self.now_player_order_abs not in self.players_in_game_abs1:
self_logger.debug(
f"before go into next stage {self.now_player_order_abs} not in {self.players_in_game_abs1}"
)
self.action = self.player_round[self.now_player_order %
self.max_player] + '_' + 'fold'
self.actions[self.now_player_order] = self.action
self.now_player_order += 1
if is_debug:
t.screenshot.save(
get_dir(
os.path.join(
'log', 'pics',
str(self.dealer_position) + '_' + self.action +
'.png')))
continue
# handle players in game.
if t.total_pot == 1.0 + self.small_blind:
if t.player_pots[self.now_player_order_abs] <= 1:
self_logger.debug(
f"before go into nex stage {t.total_pot} == 1.5,{t.player_pots[self.now_player_order_abs]} <= 1"
)
if t.current_round_pot > 0:
self_logger.info(f"all actions are completed.")
self_logger.debug(
f"before go into nex stage t.current_round_pot > 0"
)
call = self.get_max_bet_value(self.now_player_order)
self.action = self.player_round[
self.now_player_order %
self.max_player] + '_' + str(call)
self.actions[self.now_player_order] = self.action
return False
break
# self.action = self.player_round[self.now_player_order % self.max_player] + '_' + 'fold'
# # Remove from players in game.
# index = t.players_in_game.index(self.now_player_order_abs)
# self.players_in_game_abs.pop(index)
# self.actions[self.now_player_order] = self.action
# self.now_player_order += 1
# self_logger.info(f"action: {self.action}")
elif t.total_pot > 1.0 + self.small_blind:
t.get_player_pots_nn(self.now_player_order_abs)
# 1st round
if self.now_player_order < self.max_player:
current_pot = t.player_pots[self.now_player_order_abs]
if t.current_round_pot > 0:
self_logger.debug(
f"self.now_player_order < self.max_player and t.current_round_pot > 0"
)
# if max value is -1 and number_of_player == n, call = total_pot // n.
call = self.get_max_bet_value(self.now_player_order)
if call < 0:
sys.exit()
#call = t.total_pot // len(self.players_in_game_abs1)
self.action = self.player_round[
self.now_player_order %
self.max_player] + '_' + str(call)
self.actions[self.now_player_order] = self.action
self.now_player_order += 1
continue
elif current_pot == 1:
# self.action = self.player_round[self.now_player_order % self.max_player] + '_' + 'fold'
# # Remove from players in game.
# index = t.players_in_game.index(self.now_player_order_abs)
# self.players_in_game_abs.pop(index)
self_logger.debug(
f"before go into nex stage current_pot == 1")
if self.now_player_order != self.bb_rel:
self.action = self.player_round[
self.now_player_order %
self.max_player] + '_' + str(1.0)
self.actions[self.now_player_order] = self.action
self.now_player_order += 1
continue
else:
break
# if is_debug:
# t.screenshot.save(
# get_dir(os.path.join('log', 'pics',
# str(self.dealer_position) + '_' + self.action + '.png')))
elif current_pot > 1 and t.current_round_pot < 0:
self_logger.debug(
f"before go into nex stage t.player_pots[self.now_player_order_abs] > 1"
)
self.action = self.player_round[
self.now_player_order %
self.max_player] + '_' + str(
t.player_pots[self.now_player_order_abs])
self.actions[self.now_player_order] = self.action
self.now_player_order += 1
if is_debug:
t.screenshot.save(
get_dir(
os.path.join(
'log', 'pics',
str(self.dealer_position) + '_' +
self.action + '.png')))
else:
self_logger.debug(
f" current_pot < 1 and t.current_round_pot < 0")
break
# 2nd round
elif self.now_player_order >= self.max_player:
pre_pot = float(
self.actions[self.now_player_order %
self.max_player].split('_')[1])
current_pot = t.player_pots[self.now_player_order_abs]
if t.current_round_pot > 0:
self_logger.info(f"all actions are completed.")
self_logger.debug(
f"before go into nex stage t.current_round_pot > 0"
)
call = self.get_max_bet_value(self.now_player_order)
if call < 0:
return False
self.action = self.player_round[
self.now_player_order %
self.max_player] + '_' + str(call)
self.actions[self.now_player_order] = self.action
return False
if current_pot < 0 and t.current_round_pot < 0:
self_logger.debug(
f"before go into nex stage current_pot < 0 and t.current_round_pot < 0"
)
break
# Check in another image.
if current_pot == pre_pot:
self_logger.debug(
f"before go into nex stage current_pot == pre_pot")
break
# pots are distributed and transfered to next game.
if current_pot < pre_pot and current_pot > 0:
self_logger.info(f"all actions are completed.")
self_logger.debug(
f"before go into nex stage current_pot < pre_pot and current_pot > 0"
)
return False
self.action = self.player_round[
self.now_player_order %
self.max_player] + '_' + str(current_pot)
self.actions[self.now_player_order] = self.action
self.now_player_order += 1
if is_debug:
t.screenshot.save(
get_dir(
os.path.join(
'log', 'pics',
str(self.dealer_position) + '_' +
self.action + '.png')))
# self_logger.info(f"action: {self.action}")
elif t.total_pot == 1.0:
# sb fold and BB win the pot.
if self.now_player_order == self.max_player - 2: # SB
self_logger.debug(
f"t.total_pot == 1.0: and self.now_player_order == self.max_player - 2"
)
self.action = self.player_round[
self.now_player_order % self.max_player] + '_' + 'fold'
self.actions[self.now_player_order] = self.action
self.now_player_order += 1
elif self.now_player_order == self.max_player - 1: # BB
self_logger.debug(
f"t.total_pot == 1.0: and self.now_player_order == self.max_player - 1"
)
self.action = self.player_round[
self.now_player_order % self.max_player] + '_' + '1.0'
self.actions[self.now_player_order] = self.action
self.now_player_order += 1
return True
else:
return True
else:
self_logger.info(f'There is err, total_pot: {t.total_pot}')
return False
# all player have same pots. Transfer to next game stage.
# if max(t.player_pots) != min([t.player_pots[i] for i in t.players_in_game]):
# self_logger.info(f"use_backup_image")
# self.use_backup_image = True
return True
