def do_init(self, chat_id: int, token: str = None, player_name: str = None):
if token is None:
token = "864251270:AAFzZZdjspI-kIgJVk4gF3TViGFoHnf8H4o"
self.chat_id = chat_id
self.api_url = f"https://api.telegram.org/bot{token}"
self.player_name = player_name or ""
self.__initialized = True
self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-5))
self._last_full_energy_report = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-30))
if self.__queue:
self.send_message("Telegram initialized")
def _battle_monitor_air(player: Citizen):
"""Launch battles. Check every 5th minute (0,5,10...45,50,55) if any battle could be started on specified regions
and after launching wait for 90 minutes before starting next attack so that all battles aren't launched at the same
time. If player is allowed to fight, do 100 hits on the first round in players division.
:param player: Logged in Citizen instance
":type player: Citizen
"""
global CONFIG
finished_war_ids = {*[]}
war_data = CONFIG.get('start_battles', {})
war_ids = {int(war_id) for war_id in war_data.keys()}
next_attack_time = player.now
next_attack_time = next_attack_time.replace(
minute=next_attack_time.minute // 5 * 5, second=0)
print("101", next_attack_time)
new_battle_list = []
bh_watch_list = []
while not player.stop_threads.is_set():
try:
player.update_war_info()
battles = player.cus_sorted_battles_all_air()
print(battles)
utils.now()
for id in battles:
delta = utils.now() - player.all_battles[id].start
time.sleep(1)
print(delta)
if (delta < timedelta(minutes=0)):
print("found!")
newbattleinfo = str(id) + ":" + str(
player.all_battles[id].zone_id)
print(newbattleinfo)
if not newbattleinfo in new_battle_list:
# message = 'find battle: ' + str(player.all_battles[id])
message2 = 'https://www.erepublik.com/en/military/battlefield/' + str(
id)
message3 = " new battle: " + str(delta)
post(player.telegram.api_url,
json=dict(chat_id=player.telegram.chat_id,
text=message2,
parse_mode="Markdown"))
new_battle_list.append(newbattleinfo)
# player.telegram.send_message('find battle: ' + str(player.all_battles[id]))
continue
print(battles)
player.stop_threads.wait(utils.get_sleep_seconds(next_attack_time))
except:
player.report_error("Task error: start_battles")
###########################################################
next_attack_time = utils.good_timedelta(next_attack_time,
timedelta(minutes=3))
print("133", next_attack_time)
player.stop_threads.wait(utils.get_sleep_seconds(next_attack_time))
class House:
quality = None
unactivated_count = 0
active_until = utils.good_timedelta(utils.now(), -datetime.timedelta(days=1))
def __init__(self, quality: int):
if 0 < quality < 6:
self.quality = quality
@property
def next_ot_point(self) -> datetime.datetime:
return self.active_until
def send_message(self, message: str) -> bool:
self.__queue.append(message)
if not self.__initialized:
if self._last_time < utils.now():
self.__queue.clear()
return True
self._threads = [t for t in self._threads if t.is_alive()]
self._next_time = utils.good_timedelta(utils.now(), datetime.timedelta(seconds=20))
if not self._threads:
name = f"telegram_{f'{self.player_name}_' if self.player_name else ''}send"
send_thread = threading.Thread(target=self.__send_messages, name=name)
send_thread.start()
self._threads.append(send_thread)
return True
def _battle_launcher(player: Citizen):
"""Launch battles. Check every 5th minute (0,5,10...45,50,55) if any battle could be started on specified regions
and after launching wait for 90 minutes before starting next attack so that all battles aren't launched at the same
time. If player is allowed to fight, do 100 hits on the first round in players division.
:param player: Logged in Citizen instance
:type player: Citizen
"""
global CONFIG
finished_war_ids = {*[]}
war_data = CONFIG.get('battle_launcher', {})
war_ids = {int(war_id) for war_id in war_data.keys()}
next_attack_time = player.now
next_attack_time = next_attack_time.replace(
minute=next_attack_time.minute // 5 * 5, second=0)
while not player.stop_threads.is_set():
try:
attacked = False
player.update_war_info()
running_wars = {b.war_id for b in player.all_battles.values()}
for war_id in war_ids - finished_war_ids - running_wars:
war = war_data[war_id]
war_regions = set(war.get('regions'))
auto_attack = war.get('auto_attack')
status = player.get_war_status(war_id)
if status.get('ended', False):
CONFIG['battle_launcher'].pop(war_id, None)
finished_war_ids.add(war_id)
continue
elif not status.get('can_attack'):
continue
if auto_attack or (player.now.hour > 20
or player.now.hour < 2):
for reg in war_regions:
if attacked:
break
if reg in status.get('regions', {}).keys():
player.launch_attack(
war_id, reg,
status.get('regions', {}).get(reg))
attacked = True
hits = 100
if player.energy.food_fights >= hits and player.config.fight:
for _ in range(120):
player.update_war_info()
battle_id = player.get_war_status(
war_id).get("battle_id")
if battle_id is not None and battle_id in player.all_battles:
battle = player.all_battles.get(
battle_id)
for division in battle.div.values():
if division.div == player.division:
div = division
break
else:
player.report_error(
"Players division not found in the first round!"
)
break
player.fight(battle, div,
battle.invader, hits)
break
player.sleep(1)
if attacked:
break
if attacked:
break
war_ids -= finished_war_ids
if attacked:
next_attack_time = utils.good_timedelta(
next_attack_time, timedelta(hours=1, minutes=30))
else:
next_attack_time = utils.good_timedelta(
next_attack_time, timedelta(minutes=5))
player.stop_threads.wait(utils.get_sleep_seconds(next_attack_time))
except Exception as e:
player.report_error(f"Task battle launcher ran into error {e}")
def _battle_monitor(player: Citizen):
"""Launch battles. Check every 5th minute (0,5,10...45,50,55) if any battle could be started on specified regions
and after launching wait for 90 minutes before starting next attack so that all battles aren't launched at the same
time. If player is allowed to fight, do 100 hits on the first round in players division.
:param player: Logged in Citizen instance
":type player: Citizen
"""
global CONFIG
finished_war_ids = {*[]}
war_data = CONFIG.get('start_battles', {})
war_ids = {int(war_id) for war_id in war_data.keys()}
next_attack_time = player.now
next_attack_time = next_attack_time.replace(
minute=next_attack_time.minute // 5 * 5, second=0)
print("101", next_attack_time)
new_battle_list = []
bh_watch_list = []
while not player.stop_threads.is_set():
try:
player.update_war_info()
battles = player.cus_sorted_battles()
utils.now()
for id in battles:
print(player.all_battles[id])
delta = utils.now() - player.all_battles[id].start
time.sleep(2)
if (delta < timedelta(minutes=5)
and delta > timedelta(minutes=-2)):
print("found!")
newbattleinfo = str(id) + ":" + str(
player.all_battles[id].zone_id)
print(newbattleinfo)
if not newbattleinfo in new_battle_list:
# message = 'find battle: ' + str(player.all_battles[id])
message2 = '/hit 2 https://www.erepublik.com/en/military/battlefield/' + str(
id) + ' cn '
message3 = " new battle: " + str(delta)
message4 = 'https://www.erepublik.com/en/military/battlefield/' + str(
id)
post(player.telegram.api_url,
json=dict(chat_id=player.telegram.chat_id,
text=message2,
parse_mode="Markdown"))
post(player.telegram.api_url,
json=dict(chat_id=player.telegram.chat_id,
text=message3,
parse_mode="Markdown"))
# post(player.telegram.api_url,
# json=dict(chat_id=player.telegram.chat_id, text=message4, parse_mode="Markdown"))
new_battle_list.append(newbattleinfo)
# player.telegram.send_message('find battle: ' + str(player.all_battles[id]))
continue
if (delta > timedelta(minutes=61)):
for i in range(1, 5):
bh_watch = str(id) + ":" + str(
player.all_battles[id].zone_id) + ":" + str(i)
if bh_watch in bh_watch_list:
continue
place = player.get_my_status(id, div=i)
if place > 1:
print(bh_watch)
if not bh_watch in bh_watch_list:
message = 'https://www.erepublik.com/en/military/battlefield/' + str(id) \
+ " check BH in Div: " + str(i)
post(player.telegram.api_url,
json=dict(chat_id=player.telegram.chat_id,
text=message,
parse_mode="Markdown"))
print(message)
bh_watch_list.append(bh_watch)
else:
print("check BH done: ", "div ", i, place)
time.sleep(2)
print(battles)
player.stop_threads.wait(utils.get_sleep_seconds(next_attack_time))
except:
player.report_error("Task error: start_battles")
###########################################################
# over_time
# player.update_job_info()
# ot_time = player.my_companies.next_ot_time
# delta = utils.now() - ot_time
# print(" next overtime", delta)
# if delta > timedelta(minutes=1):
# player.work_ot()
################################################
next_attack_time = utils.good_timedelta(next_attack_time,
timedelta(seconds=150))
print("149", next_attack_time)
player.stop_threads.wait(utils.get_sleep_seconds(next_attack_time))
def _slow_down_requests(self):
ltt = utils.good_timedelta(self.last_time, self.timeout)
if ltt > utils.now():
seconds = (ltt - utils.now()).total_seconds()
time.sleep(seconds if seconds > 0 else 0)
self.last_time = utils.now()
def main():
player = Citizen(email=CONFIG['email'],
password=CONFIG['password'],
auto_login=False)
player.config.interactive = CONFIG['interactive']
player.config.work = CONFIG['work']
player.config.train = CONFIG['train']
player.config.ot = CONFIG['ot']
player.config.wam = CONFIG['wam']
player.set_debug(CONFIG.get('debug', False))
player.login()
now = player.now.replace(second=0, microsecond=0)
dt_max = constants.max_datetime
tasks = {}
if player.config.work:
tasks.update({'work': now})
if player.config.train:
tasks.update({'train': now})
if player.config.ot:
tasks.update({'ot': now})
if player.config.wam:
tasks.update({'wam': now.replace(hour=14, minute=0)})
while True:
try:
player.update_all()
if tasks.get('work', dt_max) <= now:
player.write_log("Doing task: work")
player.update_citizen_info()
player.work()
if player.config.ot:
tasks['ot'] = now
player.collect_daily_task()
next_time = utils.good_timedelta(
now.replace(hour=0, minute=0, second=0), timedelta(days=1))
tasks.update({'work': next_time})
if tasks.get('train', dt_max) <= now:
player.write_log("Doing task: train")
player.update_citizen_info()
player.train()
player.collect_daily_task()
next_time = utils.good_timedelta(
now.replace(hour=0, minute=0, second=0), timedelta(days=1))
tasks.update({'train': next_time})
if tasks.get('wam', dt_max) <= now:
player.write_log("Doing task: Work as manager")
success = player.work_as_manager()
if success:
next_time = utils.good_timedelta(
now.replace(hour=14, minute=0, second=0,
microsecond=0), timedelta(days=1))
else:
next_time = utils.good_timedelta(
now.replace(second=0, microsecond=0),
timedelta(minutes=30))
tasks.update({'wam': next_time})
if tasks.get('ot', dt_max) <= now:
player.update_job_info()
player.write_log("Doing task: work overtime")
if now > player.my_companies.next_ot_time:
player.work_ot()
next_time = now + timedelta(minutes=60)
else:
next_time = player.my_companies.next_ot_time
tasks.update({'ot': next_time})
closest_next_time = dt_max
next_tasks = []
for task, next_time in sorted(tasks.items(), key=lambda s: s[1]):
next_tasks.append(f"{next_time.strftime('%F %T')}: {task}")
if next_time < closest_next_time:
closest_next_time = next_time
sleep_seconds = int(utils.get_sleep_seconds(closest_next_time))
if sleep_seconds <= 0:
player.write_log(
f"Loop detected! Offending task: '{next_tasks[0]}'")
player.write_log("My next Tasks and there time:\n" +
"\n".join(sorted(next_tasks)))
player.write_log(
f"Sleeping until (eRep): {closest_next_time.strftime('%F %T')}"
f" (sleeping for {sleep_seconds}s)")
seconds_to_sleep = sleep_seconds if sleep_seconds > 0 else 0
player.sleep(seconds_to_sleep)
except Exception as e:
player.report_error(f"Task main loop ran into error: {e}")
def main():
player = Citizen(email=CONFIG['email'],
password=CONFIG['password'],
auto_login=False)
player.config.interactive = CONFIG['interactive']
player.config.fight = CONFIG['fight']
player.set_debug(CONFIG.get('debug', False))
player.login()
now = player.now.replace(second=0, microsecond=0)
dt_max = now.replace(year=9999)
tasks = {
'eat': now,
}
if player.config.work:
tasks.update({'work': now})
if player.config.train:
tasks.update({'train': now})
if player.config.ot:
tasks.update({'ot': now})
if player.config.wam:
tasks.update({'wam': now.replace(hour=14, minute=0)})
while True:
player.update_all()
if tasks.get('work', dt_max) <= now:
player.write_log("Doing task: work")
player.update_citizen_info()
player.work()
if player.config.ot:
tasks['ot'] = now
player.collect_daily_task()
next_time = utils.good_timedelta(
now.replace(hour=0, minute=0, second=0), timedelta(days=1))
tasks.update({'work': next_time})
if tasks.get('train', dt_max) <= now:
player.write_log("Doing task: train")
player.update_citizen_info()
player.train()
player.collect_daily_task()
next_time = utils.good_timedelta(
now.replace(hour=0, minute=0, second=0), timedelta(days=1))
tasks.update({'train': next_time})
if tasks.get('wam', dt_max) <= now:
player.write_log("Doing task: Work as manager")
success = player.work_wam()
player.eat()
if success:
next_time = utils.good_timedelta(
now.replace(hour=14, minute=0, second=0, microsecond=0),
timedelta(days=1))
else:
next_time = utils.good_timedelta(
now.replace(second=0, microsecond=0),
timedelta(minutes=30))
tasks.update({'wam': next_time})
if tasks.get('eat', dt_max) <= now:
player.write_log("Doing task: eat")
player.eat()
if player.energy.food_fights > player.energy.limit // 10:
next_minutes = 12
else:
next_minutes = (
player.energy.limit -
5 * player.energy.interval) // player.energy.interval * 6
next_time = player.energy.reference_time + timedelta(
minutes=next_minutes)
tasks.update({'eat': next_time})
if tasks.get('ot', dt_max) <= now:
player.write_log("Doing task: ot")
if now > player.my_companies.next_ot_time:
player.work_ot()
next_time = now + timedelta(minutes=60)
else:
next_time = player.my_companies.next_ot_time
tasks.update({'ot': next_time})
closest_next_time = dt_max
next_tasks = []
for task, next_time in sorted(tasks.items(), key=lambda s: s[1]):
next_tasks.append("{}: {}".format(next_time.strftime('%F %T'),
task))
if next_time < closest_next_time:
closest_next_time = next_time
sleep_seconds = int(utils.get_sleep_seconds(closest_next_time))
if sleep_seconds <= 0:
player.write_log(
f"Loop detected! Offending task: '{next_tasks[0]}'")
player.write_log("My next Tasks and there time:\n" +
"\n".join(sorted(next_tasks)))
player.write_log("Sleeping until (eRep): {} (sleeping for {}s)".format(
closest_next_time.strftime("%F %T"), sleep_seconds))
seconds_to_sleep = sleep_seconds if sleep_seconds > 0 else 0
player.sleep(seconds_to_sleep)
def __init__(self, stop_event: threading.Event = None):
self._threads = []
self.__queue = []
self.__thread_stopper = threading.Event() if stop_event is None else stop_event
self._last_full_energy_report = self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(hours=1))
self._next_time = utils.now()
