def __init__(self, threadID, name, counter, updater):
threading.Thread.__init__(self)
self.threadID = threadID
self.updater = updater
self.name = name
self.counter = counter
self.loger = logging.getLogger('main')
self.game_logger = GameLogger()
def __init__(self, threadID, name, counter, gui_signals):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
self.gui_signals = gui_signals
self.logger = logging.getLogger('main')
self.logger.setLevel(logging.DEBUG)
self.game_logger = GameLogger()
def init_table(file, round_number=0, strategy='Pokemon4'):
LOG_FILENAME = 'testing.log'
logger = logging.getLogger('tester')
gui_signals = MagicMock()
p = StrategyHandler()
p.read_strategy(strategy_override=strategy)
h = main.History()
h.preflop_sheet = pd.read_excel('decisionmaker/preflop.xlsx',
sheetname=None)
game_logger = GameLogger()
t = main.TableScreenBased(p, gui_signals, game_logger, 0.0)
t.entireScreenPIL = Image.open(file)
t.get_top_left_corner(p)
t.get_dealer_position()
t.get_my_funds(h, p)
t.get_my_cards(h)
t.get_table_cards(h)
t.get_round_number(h)
h.round_number = round_number
t.init_get_other_players_info()
t.get_other_player_names(p)
t.get_other_player_funds(p)
t.get_other_player_pots()
t.get_other_player_status(p, h)
t.check_for_checkbutton()
t.check_for_call()
t.check_for_betbutton()
t.check_for_allincall()
t.get_current_call_value(p)
t.get_current_bet_value(p)
p = MagicMock()
gui_signals = MagicMock()
return t, p, gui_signals, h, logger
def __init__(self, threadID, name, counter, gui_signals):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
self.gui_signals = gui_signals
self.logger = logging.getLogger('main')
self.logger.setLevel(logging.DEBUG)
self.game_logger = GameLogger()
def init_table(file,round_number=0, strategy='vid_ps_2'):
LOG_FILENAME = 'testing.log'
logger = logging.getLogger('tester')
gui_signals = MagicMock()
p = StrategyHandler()
p.read_strategy(strategy_override=strategy)
h = main.History()
u = UpdateChecker()
cursor = u.mongodb.internal.find()
c = cursor.next()
preflop_url = c['preflop_url']
h.preflop_sheet = pd.read_excel(preflop_url, sheetname=None)
game_logger = GameLogger()
mouse = MouseMoverTableBased(p.selected_strategy['pokerSite'])
t = main.TableScreenBased(p,gui_signals,game_logger,0.0)
t.entireScreenPIL = Image.open(file)
t.get_top_left_corner(p)
t.get_dealer_position()
t.get_my_funds(h,p)
t.get_my_cards(h)
t.get_table_cards(h)
t.get_round_number(h)
h.round_number=round_number
t.init_get_other_players_info()
t.get_other_player_names(p)
t.get_other_player_funds(p)
t.get_other_player_pots()
t.get_other_player_status(p,h)
t.check_for_checkbutton()
t.check_for_call()
t.check_for_betbutton()
t.check_for_allincall()
t.get_current_call_value(p)
t.get_current_bet_value(p)
t.check_fast_fold(h, p, mouse)
p = MagicMock()
gui_signals = MagicMock()
t.get_round_pot_value(h)
t.get_bot_pot(p)
t.check_for_button()
t.get_lost_everything(h, t, p, gui_signals)
t.get_total_pot_value(h)
#t.totalPotValue = 0.5
#t.abs_equity = 0.5
#t.equity = 0.5
return t,p,gui_signals,h,logger
class ThreadManager(threading.Thread):
def __init__(self, threadID, name, counter, gui_signals):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
self.gui_signals = gui_signals
self.logger = logging.getLogger('main')
self.logger.setLevel(logging.DEBUG)
self.game_logger = GameLogger()
def update_most_gui_items(self, preflop_state, p, m, t, d, h, gui_signals):
try:
sheet_name = t.preflop_sheet_name
except:
sheet_name = ''
gui_signals.signal_decision.emit(str(d.decision + " " + sheet_name))
gui_signals.signal_status.emit(d.decision)
range2 = ''
if hasattr(t, 'reverse_sheet_name'):
range = t.reverse_sheet_name
if hasattr(preflop_state, 'range_column_name'):
range2 = " " + preflop_state.range_column_name + ""
else:
range = str(m.opponent_range)
if range == '1': range = 'All cards'
if t.gameStage != 'PreFlop' and p.selected_strategy['preflop_override']:
sheet_name = preflop_state.preflop_sheet_name
gui_signals.signal_label_number_update.emit(
'equity',
str(np.round(t.abs_equity * 100, 2)) + "%")
gui_signals.signal_label_number_update.emit('required_minbet',
str(np.round(t.minBet, 2)))
gui_signals.signal_label_number_update.emit(
'required_mincall', str(np.round(t.minCall, 2)))
# gui_signals.signal_lcd_number_update.emit('potsize', t.totalPotValue)
gui_signals.signal_label_number_update.emit(
'gamenumber',
str(int(self.game_logger.get_game_count(p.current_strategy))))
gui_signals.signal_label_number_update.emit('assumed_players',
str(int(t.assumedPlayers)))
gui_signals.signal_label_number_update.emit(
'calllimit', str(np.round(d.finalCallLimit, 2)))
gui_signals.signal_label_number_update.emit(
'betlimit', str(np.round(d.finalBetLimit, 2)))
gui_signals.signal_label_number_update.emit('runs', str(int(m.runs)))
gui_signals.signal_label_number_update.emit('sheetname', sheet_name)
gui_signals.signal_label_number_update.emit('collusion_cards',
str(m.collusion_cards))
gui_signals.signal_label_number_update.emit('mycards', str(t.mycards))
gui_signals.signal_label_number_update.emit('tablecards',
str(t.cardsOnTable))
gui_signals.signal_label_number_update.emit('opponent_range',
str(range) + str(range2))
gui_signals.signal_label_number_update.emit(
'mincallequity',
str(np.round(t.minEquityCall, 2) * 100) + "%")
gui_signals.signal_label_number_update.emit(
'minbetequity',
str(np.round(t.minEquityBet, 2) * 100) + "%")
gui_signals.signal_label_number_update.emit('outs', str(d.outs))
gui_signals.signal_label_number_update.emit(
'initiative', str(t.other_player_has_initiative))
gui_signals.signal_label_number_update.emit(
'round_pot', str(np.round(t.round_pot_value, 2)))
gui_signals.signal_label_number_update.emit(
'pot_multiple', str(np.round(d.pot_multiple, 2)))
if t.gameStage != 'PreFlop' and p.selected_strategy[
'use_relative_equity']:
gui_signals.signal_label_number_update.emit(
'relative_equity',
str(np.round(t.relative_equity, 2) * 100) + "%")
gui_signals.signal_label_number_update.emit(
'range_equity',
str(np.round(t.range_equity, 2) * 100) + "%")
else:
gui_signals.signal_label_number_update.emit('relative_equity', "")
gui_signals.signal_label_number_update.emit('range_equity', "")
# gui_signals.signal_lcd_number_update.emit('zero_ev', round(d.maxCallEV, 2))
gui_signals.signal_pie_chart_update.emit(t.winnerCardTypeList)
gui_signals.signal_curve_chart_update1.emit(h.histEquity,
h.histMinCall,
h.histMinBet, t.equity,
t.minCall, t.minBet, 'bo',
'ro')
gui_signals.signal_curve_chart_update2.emit(
t.power1, t.power2, t.minEquityCall, t.minEquityBet, t.smallBlind,
t.bigBlind, t.maxValue_call, t.maxValue_bet, t.maxEquityCall,
t.max_X, t.maxEquityBet)
def run(self):
#pdb.set_trace() #To debug in a thread, has to use set_trace()
h = History()
#preflop_url = u.get_preflop_sheet_url()
#KevinY
preflop_url = 'preflop.xlsx'
h.preflop_sheet = pd.read_excel(preflop_url, sheetname=None)
self.game_logger.clean_database()
p = StrategyHandler()
p.read_strategy()
preflop_state = CurrentHandPreflopState()
p.fast_fold_decision_turned_check = False
while True:
if self.gui_signals.pause_thread:
while self.gui_signals.pause_thread == True:
time.sleep(1)
if self.gui_signals.exit_thread == True: sys.exit()
ready = False
while (not ready):
p.read_strategy()
t = TableScreenBased(p, gui_signals, self.game_logger, version)
mouse = MouseMoverTableBased(p.selected_strategy['pokerSite'])
mouse.move_mouse_away_from_buttons_jump
#pdb.set_trace()
ready_screenshot = False
ready_screenshot = t.take_screenshot(True, p)
# to see if first round, to improve speed
if (not hasattr(h, 'round_number') or h.round_number == 0):
ready = ready_screenshot and \
t.get_top_left_corner(p) and \
t.check_for_imback(mouse) and \
t.get_other_player_names(p,h) and \
t.get_my_cards(h) and \
t.get_dealer_position() and \
t.get_round_number(h) and \
t.check_fast_fold(h, p, mouse)
ready = ready_screenshot and \
t.get_new_hand(mouse, h, p) and \
t.get_table_cards(h) and \
t.upload_collusion_wrapper(p, h) and \
t.check_for_button() and \
t.get_round_number(h) and \
t.init_get_other_players_info() and \
t.get_other_player_funds(p) and \
t.get_other_player_pots() and \
t.get_total_pot_value(h) and \
t.get_round_pot_value(h) and \
t.check_for_checkbutton() and \
t.get_other_player_status(p, h) and \
t.check_for_call() and \
t.check_for_betbutton() and \
t.check_for_allincall() and \
t.get_current_call_value(p) and \
t.get_current_bet_value(p)
if not self.gui_signals.pause_thread:
config = ConfigObj("config.ini")
m = run_montecarlo_wrapper(p, self.gui_signals, config, ui, t,
self.game_logger, preflop_state, h)
d = Decision(t, h, p, self.game_logger)
d.make_decision(t, h, p, self.logger, self.game_logger)
if self.gui_signals.exit_thread: sys.exit()
self.update_most_gui_items(preflop_state, p, m, t, d, h,
self.gui_signals)
self.logger.info("Equity: " + str(t.equity * 100) + "% -> " +
str(int(t.assumedPlayers)) + " (" +
str(int(t.other_active_players)) + "-" +
str(int(t.playersAhead)) + "+1) Plr")
self.logger.info("Final Call Limit: " + str(d.finalCallLimit) +
" --> " + str(t.minCall))
self.logger.info("Final Bet Limit: " + str(d.finalBetLimit) +
" --> " + str(t.minBet))
self.logger.info("Pot size: " + str((t.totalPotValue)) +
" -> Zero EV Call: " +
str(round(d.maxCallEV, 2)))
self.logger.info("+++++++++++++++++++++++ Decision: " +
str(d.decision) + "+++++++++++++++++++++++")
mouse_target = d.decision
if p.fast_fold_decision_turned_check == True:
self.logger.info("Fast fold decision turned check")
mouse_target = 'Check'
p.fast_fold_decision_turned_check = False
if mouse_target == 'Call' and t.allInCallButton:
mouse_target = 'Call2'
mouse.mouse_action(mouse_target, t.tlc)
t.time_action_completed = datetime.datetime.utcnow()
filename = str(h.GameID) + "_" + str(t.gameStage) + "_" + str(
h.round_number) + ".png"
self.logger.debug("Saving screenshot: " + filename)
pil_image = t.crop_image(t.entireScreenPIL, t.tlc[0], t.tlc[1],
t.tlc[0] + 950 * 2,
t.tlc[1] + 650 * 2)
pil_image.save("log/screenshots/" + filename)
self.gui_signals.signal_status.emit("Logging data")
t_log_db = threading.Thread(
name='t_log_db',
target=self.game_logger.write_log_file,
args=[p, h, t, d])
t_log_db.daemon = True
t_log_db.start()
# self.game_logger.write_log_file(p, h, t, d)
h.previousPot = t.totalPotValue
h.histGameStage = t.gameStage
h.histDecision = d.decision
h.histEquity = t.equity
h.histMinCall = t.minCall
h.histMinBet = t.minBet
h.hist_other_players = t.other_players
h.first_raiser = t.first_raiser
h.first_caller = t.first_caller
h.previous_decision = d.decision
h.lastRoundGameID = h.GameID
h.previous_round_pot_value = t.round_pot_value
h.last_round_bluff = False if t.currentBluff == 0 else True
if t.gameStage == 'PreFlop':
preflop_state.update_values(t, d.decision, h, d)
self.logger.info("=========== round end ===========")
def run_genetic_algorithm(write, logger):
logger.info("===Running genetic algorithm===")
L = GameLogger()
GeneticAlgorithm(write, logger, L)
class ThreadManager(threading.Thread):
def __init__(self, threadID, name, counter, gui_signals):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
self.gui_signals = gui_signals
self.logger = logging.getLogger('main')
self.logger.setLevel(logging.DEBUG)
self.game_logger = GameLogger()
def update_most_gui_items(self, preflop_state, p, m, t, d, h, gui_signals):
try:
sheet_name = t.preflop_sheet_name
except:
sheet_name = ''
gui_signals.signal_decision.emit(str(d.decision + " " + sheet_name))
gui_signals.signal_status.emit(d.decision)
range2 = ''
if hasattr(t, 'reverse_sheet_name'):
range = t.reverse_sheet_name
if hasattr(preflop_state, 'range_column_name'):
range2 = " " + preflop_state.range_column_name + ""
else:
range = str(m.opponent_range)
if range == '1': range = 'All cards'
if t.gameStage != 'PreFlop' and p.selected_strategy['preflop_override']:
sheet_name=preflop_state.preflop_sheet_name
gui_signals.signal_label_number_update.emit('equity', str(np.round(t.abs_equity * 100, 2)) + "%")
gui_signals.signal_label_number_update.emit('required_minbet', str(np.round(t.minBet,2)))
gui_signals.signal_label_number_update.emit('required_mincall', str(np.round(t.minCall,2)))
# gui_signals.signal_lcd_number_update.emit('potsize', t.totalPotValue)
gui_signals.signal_label_number_update.emit('gamenumber',
str(int(self.game_logger.get_game_count(p.current_strategy))))
gui_signals.signal_label_number_update.emit('assumed_players', str(int(t.assumedPlayers)))
gui_signals.signal_label_number_update.emit('calllimit', str(np.round(d.finalCallLimit,2)))
gui_signals.signal_label_number_update.emit('betlimit', str(np.round(d.finalBetLimit,2)))
gui_signals.signal_label_number_update.emit('runs', str(int(m.runs)))
gui_signals.signal_label_number_update.emit('sheetname', sheet_name)
gui_signals.signal_label_number_update.emit('collusion_cards', str(m.collusion_cards))
gui_signals.signal_label_number_update.emit('mycards', str(t.mycards))
gui_signals.signal_label_number_update.emit('tablecards', str(t.cardsOnTable))
gui_signals.signal_label_number_update.emit('opponent_range', str(range) + str(range2))
gui_signals.signal_label_number_update.emit('mincallequity', str(np.round(t.minEquityCall, 2) * 100) + "%")
gui_signals.signal_label_number_update.emit('minbetequity', str(np.round(t.minEquityBet, 2) * 100) + "%")
gui_signals.signal_label_number_update.emit('outs', str(d.outs))
gui_signals.signal_label_number_update.emit('initiative', str(t.other_player_has_initiative))
gui_signals.signal_label_number_update.emit('round_pot', str(np.round(t.round_pot_value,2)))
gui_signals.signal_label_number_update.emit('pot_multiple', str(np.round(d.pot_multiple,2)))
if t.gameStage != 'PreFlop' and p.selected_strategy['use_relative_equity']:
gui_signals.signal_label_number_update.emit('relative_equity', str(np.round(t.relative_equity,2) * 100) + "%")
gui_signals.signal_label_number_update.emit('range_equity', str(np.round(t.range_equity,2) * 100) + "%")
else:
gui_signals.signal_label_number_update.emit('relative_equity', "")
gui_signals.signal_label_number_update.emit('range_equity', "")
# gui_signals.signal_lcd_number_update.emit('zero_ev', round(d.maxCallEV, 2))
gui_signals.signal_pie_chart_update.emit(t.winnerCardTypeList)
gui_signals.signal_curve_chart_update1.emit(h.histEquity, h.histMinCall, h.histMinBet, t.equity,
t.minCall, t.minBet,
'bo',
'ro')
gui_signals.signal_curve_chart_update2.emit(t.power1, t.power2, t.minEquityCall, t.minEquityBet,
t.smallBlind, t.bigBlind,
t.maxValue_call,t.maxValue_bet,
t.maxEquityCall, t.max_X, t.maxEquityBet)
def run(self):
h = History()
preflop_url, preflop_url_backup = u.get_preflop_sheet_url()
try:
h.preflop_sheet = pd.read_excel(preflop_url, sheetname=None)
except:
h.preflop_sheet = pd.read_excel(preflop_url_backup, sheetname=None)
self.game_logger.clean_database()
p = StrategyHandler()
p.read_strategy()
preflop_state = CurrentHandPreflopState()
while True:
if self.gui_signals.pause_thread:
while self.gui_signals.pause_thread == True:
time.sleep(1)
if self.gui_signals.exit_thread == True: sys.exit()
ready = False
while (not ready):
p.read_strategy()
t = TableScreenBased(p, gui_signals, self.game_logger, version)
mouse = MouseMoverTableBased(p.selected_strategy['pokerSite'])
mouse.move_mouse_away_from_buttons_jump
ready = t.take_screenshot(True, p) and \
t.get_top_left_corner(p) and \
t.check_for_captcha(mouse) and \
t.get_lost_everything(h, t, p, gui_signals) and \
t.check_for_imback(mouse) and \
t.get_my_cards(h) and \
t.get_new_hand(mouse, h, p) and \
t.get_table_cards(h) and \
t.upload_collusion_wrapper(p, h) and \
t.get_dealer_position() and \
t.get_snowie_advice(p, h) and \
t.check_fast_fold(h, p, mouse) and \
t.check_for_button() and \
t.get_round_number(h) and \
t.init_get_other_players_info() and \
t.get_other_player_names(p) and \
t.get_other_player_funds(p) and \
t.get_other_player_pots() and \
t.get_total_pot_value(h) and \
t.get_round_pot_value(h) and \
t.check_for_checkbutton() and \
t.get_other_player_status(p, h) and \
t.check_for_call() and \
t.check_for_betbutton() and \
t.check_for_allincall() and \
t.get_current_call_value(p) and \
t.get_current_bet_value(p)
if not self.gui_signals.pause_thread:
config = ConfigObj("config.ini")
m = run_montecarlo_wrapper(p, self.gui_signals, config, ui, t, self.game_logger, preflop_state, h)
d = Decision(t, h, p, self.game_logger)
d.make_decision(t, h, p, self.logger, self.game_logger)
if self.gui_signals.exit_thread: sys.exit()
self.update_most_gui_items(preflop_state, p, m, t, d, h, self.gui_signals)
self.logger.info(
"Equity: " + str(t.equity * 100) + "% -> " + str(int(t.assumedPlayers)) + " (" + str(
int(t.other_active_players)) + "-" + str(int(t.playersAhead)) + "+1) Plr")
self.logger.info("Final Call Limit: " + str(d.finalCallLimit) + " --> " + str(t.minCall))
self.logger.info("Final Bet Limit: " + str(d.finalBetLimit) + " --> " + str(t.minBet))
self.logger.info(
"Pot size: " + str((t.totalPotValue)) + " -> Zero EV Call: " + str(round(d.maxCallEV, 2)))
self.logger.info("+++++++++++++++++++++++ Decision: " + str(d.decision) + "+++++++++++++++++++++++")
mouse_target = d.decision
if mouse_target == 'Call' and t.allInCallButton:
mouse_target = 'Call2'
mouse.mouse_action(mouse_target, t.tlc)
t.time_action_completed = datetime.datetime.utcnow()
filename = str(h.GameID) + "_" + str(t.gameStage) + "_" + str(h.round_number) + ".png"
self.logger.debug("Saving screenshot: " + filename)
pil_image = t.crop_image(t.entireScreenPIL, t.tlc[0], t.tlc[1], t.tlc[0] + 950, t.tlc[1] + 650)
pil_image.save("log/screenshots/" + filename)
self.gui_signals.signal_status.emit("Logging data")
t_log_db = threading.Thread(name='t_log_db', target=self.game_logger.write_log_file, args=[p, h, t, d])
t_log_db.daemon = True
t_log_db.start()
# self.game_logger.write_log_file(p, h, t, d)
h.previousPot = t.totalPotValue
h.histGameStage = t.gameStage
h.histDecision = d.decision
h.histEquity = t.equity
h.histMinCall = t.minCall
h.histMinBet = t.minBet
h.hist_other_players = t.other_players
h.first_raiser = t.first_raiser
h.first_caller = t.first_caller
h.previous_decision = d.decision
h.lastRoundGameID = h.GameID
h.previous_round_pot_value=t.round_pot_value
h.last_round_bluff = False if t.currentBluff == 0 else True
if t.gameStage == 'PreFlop':
preflop_state.update_values(t, d.decision, h, d)
self.logger.info("=========== round end ===========")
class ThreadManager(threading.Thread):
def __init__(self, threadID, name, counter, gui_signals):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
self.gui_signals = gui_signals
self.logger = debug_logger().start_logger('main')
self.game_logger = GameLogger()
def update_most_gui_items(self, p, t, d, h, gui_signals):
gui_signals.signal_decision.emit(
str(d.decision + " " + d.preflop_sheet_name))
gui_signals.signal_status.emit(d.decision)
gui_signals.signal_lcd_number_update.emit('equity',
np.round(t.equity * 100, 2))
gui_signals.signal_lcd_number_update.emit('required_minbet',
t.currentBetValue)
gui_signals.signal_lcd_number_update.emit('required_mincall',
t.minCall)
# gui_signals.signal_lcd_number_update.emit('potsize', t.totalPotValue)
gui_signals.signal_lcd_number_update.emit(
'gamenumber',
int(self.game_logger.get_game_count(p.current_strategy)))
gui_signals.signal_lcd_number_update.emit('assumed_players',
int(t.assumedPlayers))
gui_signals.signal_lcd_number_update.emit('calllimit',
d.finalCallLimit)
gui_signals.signal_lcd_number_update.emit('betlimit', d.finalBetLimit)
# gui_signals.signa.l_lcd_number_update.emit('zero_ev', round(d.maxCallEV, 2))
gui_signals.signal_pie_chart_update.emit(t.winnerCardTypeList)
gui_signals.signal_curve_chart_update1.emit(h.histEquity,
h.histMinCall,
h.histMinBet, t.equity,
t.minCall, t.minBet, 'bo',
'ro')
gui_signals.signal_curve_chart_update2.emit(
t.power1, t.power2, t.minEquityCall, t.minEquityBet, t.smallBlind,
t.bigBlind, t.maxValue, t.maxEquityCall, t.max_X, t.maxEquityBet)
def run(self):
h = History()
preflop_url = u.get_preflop_sheet_url()
h.preflop_sheet = pd.read_excel(preflop_url, sheetname=None)
self.game_logger.clean_database()
p = StrategyHandler()
p.read_strategy()
while True:
if self.gui_signals.pause_thread:
while self.gui_signals.pause_thread == True:
time.sleep(1)
if self.gui_signals.exit_thread == True: sys.exit()
ready = False
while (not ready):
p.read_strategy()
t = TableScreenBased(p, gui_signals, self.game_logger, version)
mouse = MouseMoverTableBased(p.selected_strategy['pokerSite'])
ready = t.take_screenshot(True, p) and \
t.get_top_left_corner(p) and \
t.check_for_captcha(mouse) and \
t.get_lost_everything(h, t, p) and \
t.check_for_imback(mouse) and \
t.get_my_funds(h, p) and \
t.get_my_cards(h) and \
t.get_new_hand(mouse, h, p) and \
t.get_table_cards(h) and \
t.upload_collusion_wrapper(p, h) and \
t.get_dealer_position() and \
t.get_snowie_advice(p, h) and \
t.check_fast_fold(h, p) and \
t.check_for_button() and \
t.get_round_number(h) and \
t.init_get_other_players_info() and \
t.get_other_player_names(p) and \
t.get_other_player_funds(p) and \
t.get_other_player_pots() and \
t.get_total_pot_value(h) and \
t.check_for_checkbutton() and \
t.get_other_player_status(p, h) and \
t.check_for_call() and \
t.check_for_betbutton() and \
t.check_for_allincall() and \
t.get_current_call_value(p) and \
t.get_current_bet_value(p)
if not self.gui_signals.pause_thread:
config = ConfigObj("config.ini")
run_montecarlo_wrapper(p, self.gui_signals, config, ui, t,
self.game_logger)
d = Decision(t, h, p, self.logger, self.game_logger)
d.make_decision(t, h, p, self.logger, self.game_logger)
if self.gui_signals.exit_thread: sys.exit()
self.update_most_gui_items(p, t, d, h, self.gui_signals)
self.logger.info("Equity: " + str(t.equity * 100) + "% -> " +
str(int(t.assumedPlayers)) + " (" +
str(int(t.other_active_players)) + "-" +
str(int(t.playersAhead)) + "+1) Plr")
self.logger.info("Final Call Limit: " + str(d.finalCallLimit) +
" --> " + str(t.minCall))
self.logger.info("Final Bet Limit: " + str(d.finalBetLimit) +
" --> " + str(t.currentBetValue))
self.logger.info("Pot size: " + str((t.totalPotValue)) +
" -> Zero EV Call: " +
str(round(d.maxCallEV, 2)))
self.logger.info("+++++++++++++++++++++++ Decision: " +
str(d.decision) + "+++++++++++++++++++++++")
mouse = MouseMoverTableBased(p.selected_strategy['pokerSite'],
p.selected_strategy['BetPlusInc'],
t.currentBluff)
mouse_target = d.decision
if mouse_target == 'Call' and t.allInCallButton:
mouse_target = 'Call2'
mouse.mouse_action(mouse_target, t.tlc)
t.time_action_completed = datetime.datetime.utcnow()
filename = str(h.GameID) + "_" + str(t.gameStage) + "_" + str(
h.round_number) + ".png"
self.logger.debug("Saving screenshot: " + filename)
pil_image = t.crop_image(t.entireScreenPIL, t.tlc[0], t.tlc[1],
t.tlc[0] + 950, t.tlc[1] + 650)
pil_image.save("log/screenshots/" + filename)
self.gui_signals.signal_status.emit("Logging data")
# t_log_db = threading.Thread(name='t_log_db', target=self.game_loggerwrite_log_file,args=[p, h, t, d])
# t_log_db.daemon = True
# t_log_db.start()
self.game_logger.write_log_file(p, h, t, d)
h.previousPot = t.totalPotValue
h.histGameStage = t.gameStage
h.histDecision = d.decision
h.histEquity = t.equity
h.histMinCall = t.minCall
h.histMinBet = t.minBet
h.hist_other_players = t.other_players
h.first_raiser = t.first_raiser
h.first_caller = t.first_caller
h.previous_decision = d.decision
h.lastRoundGameID = h.GameID
h.last_round_bluff = False if t.currentBluff == 0 else True
self.logger.info("=========== round end ===========")
class ThreadManager(threading.Thread):
def __init__(self, threadID, name, counter, updater):
threading.Thread.__init__(self)
self.threadID = threadID
self.updater = updater
self.name = name
self.counter = counter
self.loger = logging.getLogger('main')
self.game_logger = GameLogger()
def run(self):
log = logging.getLogger(__name__)
h = History()
preflop_url, preflop_url_backup = self.updater.get_preflop_sheet_url()
try:
h.preflop_sheet = pd.read_excel(preflop_url, sheet_name=None)
except:
h.preflop_sheet = pd.read_excel(preflop_url_backup,
sheet_name=None)
self.game_logger.clean_database()
p = StrategyHandler()
p.read_strategy()
preflop_state = CurrentHandPreflopState()
mongo = MongoManager()
table_scraper_name = None
#while True:
for i in range(1):
# reload table if changed
config = ConfigObj("config.ini")
ready = False
fast_fold = False
while (not ready):
p.read_strategy()
t = TableScreenBased(p, self.game_logger, version)
ready = t.load_table() and \
t.get_lost_everything(h, t, p) and \
t.get_new_hand(h, p) and \
t.get_table_cards() and \
t.get_dealer_position()
if ready and (not t.check_fast_fold(h)):
fast_fold = True
break
ready = ready and\
t.check_for_button() and \
t.get_round_number(h) and \
t.init_get_other_players_info() and \
t.get_other_player_status(p, h) and \
t.get_other_player_names(p) and \
t.get_other_player_funds(p) and \
t.get_other_player_pots() and \
t.get_total_pot_value() and \
t.get_round_pot_value() and \
t.get_current_call_value() and \
t.get_current_bet_value()
config = ConfigObj("config.ini")
if not fast_fold:
m = run_montecarlo_wrapper(p, config, t, self.game_logger,
preflop_state, h)
d = Decision(t, h, p, self.game_logger)
d.make_decision(t, h, p, self.game_logger)
decision = d.decision
log.info("Equity: " + str(t.equity * 100) + "% -> " +
str(int(t.assumedPlayers)) + " (" +
str(int(t.other_active_players)) + "-" +
str(int(t.playersAhead)) + "+1) Plr")
log.info("Final Call Limit: " + str(d.finalCallLimit) +
" --> " + str(t.minCall))
log.info("Final Bet Limit: " + str(d.finalBetLimit) + " --> " +
str(t.minBet))
log.info("Pot size: " + str((t.totalPotValue)) +
" -> Zero EV Call: " + str(round(d.maxCallEV, 2)))
t_log_db = threading.Thread(
name='t_log_db',
target=self.game_logger.write_log_file,
args=[p, h, t, d])
t_log_db.daemon = True
t_log_db.start()
h.previousPot = t.totalPotValue
h.histGameStage = t.gameStage
h.histDecision = d.decision
h.histEquity = t.equity
h.histMinCall = t.minCall
h.histMinBet = t.minBet
h.hist_other_players = t.other_players
h.first_raiser = t.first_raiser
h.first_caller = t.first_caller
h.previous_decision = d.decision
h.lastRoundGameID = h.GameID
h.previous_round_pot_value = t.round_pot_value
h.last_round_bluff = False if t.currentBluff == 0 else True
if t.gameStage == 'PreFlop':
preflop_state.update_values(t, d.decision, h, d)
log.info("=========== round end ===========")
else:
decision = DecisionTypes.fold
log.info("+++++++++++++++++++++++ Decision: " + str(decision) +
"+++++++++++++++++++++++")
