def _walk_after_teleport(self, walk_distance_post_teleport) -> float:
"""
Args:
walk_distance_post_teleport:
Returns:
Distance walked in one way
"""
lat_offset, lng_offset = get_lat_lng_offsets_by_distance(
walk_distance_post_teleport)
to_walk = get_distance_of_two_points_in_meters(
float(self.current_location.lat), float(self.current_location.lng),
float(self.current_location.lat) + lat_offset,
float(self.current_location.lng) + lng_offset)
self.logger.info("Walking roughly: {:.2f}m", to_walk)
time.sleep(0.3)
self._communicator.walk_from_to(
self.current_location,
Location(self.current_location.lat + lat_offset,
self.current_location.lng + lng_offset),
WALK_AFTER_TELEPORT_SPEED)
self.logger.debug("Walking back")
time.sleep(0.3)
self._communicator.walk_from_to(
Location(self.current_location.lat + lat_offset,
self.current_location.lng + lng_offset),
self.current_location, WALK_AFTER_TELEPORT_SPEED)
self.logger.debug("Done walking")
return to_walk
def _move_to_location(self):
if not self._mapping_manager.routemanager_present(self._routemanager_name) \
or self._stop_worker_event.is_set():
raise InternalStopWorkerException
routemanager_settings = self._mapping_manager.routemanager_get_settings(
self._routemanager_name)
# get the distance from our current position (last) to the next gym (cur)
distance = get_distance_of_two_points_in_meters(
float(self.last_location.lat), float(self.last_location.lng),
float(self.current_location.lat), float(self.current_location.lng))
logger.debug('Moving {} meters to the next position',
round(distance, 2))
if not self._mapping_manager.routemanager_get_init(
self._routemanager_name):
speed = routemanager_settings.get("speed", 0)
max_distance = routemanager_settings.get("max_distance", None)
else:
speed = int(25)
max_distance = int(200)
if (speed == 0 or (max_distance and 0 < max_distance < distance) or
(self.last_location.lat == 0.0 and self.last_location.lng == 0.0)):
logger.debug("main: Teleporting...")
self._transporttype = 0
self._communicator.set_location(
Location(self.current_location.lat, self.current_location.lng),
0)
# the time we will take as a starting point to wait for data...
cur_time = math.floor(time.time())
delay_used = self.get_devicesettings_value('post_teleport_delay',
7)
# Test for cooldown / teleported distance TODO: check this block...
if self.get_devicesettings_value('cool_down_sleep', False):
if distance > 10000:
delay_used = 15
elif distance > 5000:
delay_used = 10
elif distance > 2500:
delay_used = 8
logger.debug("Need more sleep after Teleport: {} seconds!",
str(delay_used))
# curTime = math.floor(time.time()) # the time we will take as a starting point to wait for data...
walk_distance_post_teleport = self.get_devicesettings_value(
'walk_after_teleport_distance', 0)
if 0 < walk_distance_post_teleport < distance:
# TODO: actually use to_walk for distance
lat_offset, lng_offset = get_lat_lng_offsets_by_distance(
walk_distance_post_teleport)
to_walk = get_distance_of_two_points_in_meters(
float(self.current_location.lat),
float(self.current_location.lng),
float(self.current_location.lat) + lat_offset,
float(self.current_location.lng) + lng_offset)
logger.info("Walking roughly: {}", str(to_walk))
time.sleep(0.3)
self._communicator.walk_from_to(
self.current_location,
Location(self.current_location.lat + lat_offset,
self.current_location.lng + lng_offset), 11)
logger.debug("Walking back")
time.sleep(0.3)
self._communicator.walk_from_to(
Location(self.current_location.lat + lat_offset,
self.current_location.lng + lng_offset),
self.current_location, 11)
logger.debug("Done walking")
time.sleep(1)
else:
logger.info("main: Walking...")
self._transporttype = 1
self._communicator.walk_from_to(self.last_location,
self.current_location, speed)
# the time we will take as a starting point to wait for data...
cur_time = math.floor(time.time())
logger.debug2("Done walking, fetching time to sleep")
delay_used = self.get_devicesettings_value('post_walk_delay', 7)
logger.debug2("Sleeping for {}s".format(str(delay_used)))
time.sleep(float(delay_used))
self.set_devicesettings_value("last_location", self.current_location)
self.last_location = self.current_location
self._waittime_without_delays = time.time()
return cur_time, True
def _move_to_location(self):
if not self._mapping_manager.routemanager_present(self._routemanager_name) \
or self._stop_worker_event.is_set():
raise InternalStopWorkerException
routemanager_settings = self._mapping_manager.routemanager_get_settings(
self._routemanager_name)
distance = get_distance_of_two_points_in_meters(
float(self.last_location.lat), float(self.last_location.lng),
float(self.current_location.lat), float(self.current_location.lng))
self.logger.debug('Moving {} meters to the next position',
round(distance, 2))
delay_used = 0
self.logger.debug("Getting time")
speed = routemanager_settings.get("speed", 0)
max_distance = routemanager_settings.get("max_distance", None)
if (speed == 0 or (max_distance and 0 < max_distance < distance) or
(self.last_location.lat == 0.0 and self.last_location.lng == 0.0)):
self.logger.debug("main: Teleporting...")
self._transporttype = 0
self._communicator.set_location(
Location(self.current_location.lat, self.current_location.lng),
0)
# the time we will take as a starting point to wait for data...
cur_time = math.floor(time.time())
delay_used = self.get_devicesettings_value('post_teleport_delay',
0)
speed = 16.67 # Speed can be 60 km/h up to distances of 3km
if self.last_location.lat == 0.0 and self.last_location.lng == 0.0:
self.logger.info('Starting fresh round - using lower delay')
else:
if distance >= 1335000:
speed = 180.43 # Speed can be abt 650 km/h
elif distance >= 1100000:
speed = 176.2820513
elif distance >= 1020000:
speed = 168.3168317
elif distance >= 1007000:
speed = 171.2585034
elif distance >= 948000:
speed = 166.3157895
elif distance >= 900000:
speed = 164.8351648
elif distance >= 897000:
speed = 166.1111111
elif distance >= 839000:
speed = 158.9015152
elif distance >= 802000:
speed = 159.1269841
elif distance >= 751000:
speed = 152.6422764
elif distance >= 700000:
speed = 151.5151515
elif distance >= 650000:
speed = 146.3963964
elif distance >= 600000:
speed = 142.8571429
elif distance >= 550000:
speed = 138.8888889
elif distance >= 500000:
speed = 134.4086022
elif distance >= 450000:
speed = 129.3103448
elif distance >= 400000:
speed = 123.4567901
elif distance >= 350000:
speed = 116.6666667
elif distance >= 328000:
speed = 113.8888889
elif distance >= 300000:
speed = 108.6956522
elif distance >= 250000:
speed = 101.6260163
elif distance >= 201000:
speed = 90.54054054
elif distance >= 175000:
speed = 85.78431373
elif distance >= 150000:
speed = 78.125
elif distance >= 125000:
speed = 71.83908046
elif distance >= 100000:
speed = 64.1025641
elif distance >= 90000:
speed = 60
elif distance >= 80000:
speed = 55.55555556
elif distance >= 70000:
speed = 50.72463768
elif distance >= 60000:
speed = 47.61904762
elif distance >= 45000:
speed = 39.47368421
elif distance >= 40000:
speed = 35.0877193
elif distance >= 35000:
speed = 32.40740741
elif distance >= 30000:
speed = 29.41176471
elif distance >= 25000:
speed = 27.77777778
elif distance >= 20000:
speed = 27.77777778
elif distance >= 15000:
speed = 27.77777778
elif distance >= 10000:
speed = 23.80952381
elif distance >= 8000:
speed = 26.66666667
elif distance >= 5000:
speed = 22.34137623
elif distance >= 4000:
speed = 22.22222222
delay_used = distance / speed
if delay_used > 7200: # There's a maximum of 2 hours wait time
delay_used = 7200
self.logger.debug("Need more sleep after Teleport: {} seconds!",
int(delay_used))
else:
delay_used = distance / (
speed / 3.6) # speed is in kmph , delay_used need mps
self.logger.info("main: Walking {} m, this will take {} seconds",
distance, delay_used)
self._transporttype = 1
self._communicator.walk_from_to(self.last_location,
self.current_location, speed)
# the time we will take as a starting point to wait for data...
cur_time = math.floor(time.time())
delay_used = self.get_devicesettings_value('post_walk_delay', 0)
walk_distance_post_teleport = self.get_devicesettings_value(
'walk_after_teleport_distance', 0)
if 0 < walk_distance_post_teleport < distance:
# TODO: actually use to_walk for distance
lat_offset, lng_offset = get_lat_lng_offsets_by_distance(
walk_distance_post_teleport)
to_walk = get_distance_of_two_points_in_meters(
float(self.current_location.lat),
float(self.current_location.lng),
float(self.current_location.lat) + lat_offset,
float(self.current_location.lng) + lng_offset)
self.logger.info("Walking roughly: {:.2f}m", to_walk)
time.sleep(0.3)
self._communicator.walk_from_to(
self.current_location,
Location(self.current_location.lat + lat_offset,
self.current_location.lng + lng_offset), 11)
self.logger.debug("Walking back")
time.sleep(0.3)
self._communicator.walk_from_to(
Location(self.current_location.lat + lat_offset,
self.current_location.lng + lng_offset),
self.current_location, 11)
self.logger.debug("Done walking")
time.sleep(1)
delay_used -= (
to_walk / 3.05
) - 1. # We already waited for a bit because of this walking part
if delay_used < 0:
delay_used = 0
if self._init:
delay_used = 5
if self.get_devicesettings_value('last_action_time', None) is not None:
timediff = time.time() - self.get_devicesettings_value(
'last_action_time', 0)
self.logger.info("Timediff between now and last action time: {}",
int(timediff))
delay_used = delay_used - timediff
elif self.get_devicesettings_value(
'last_action_time', None) is None and not self._level_mode:
self.logger.info(
'Starting first time - we wait because of some default pogo delays ...'
)
delay_used = 20
else:
self.logger.debug("No last action time found - no calculation")
delay_used = -1
if self.get_devicesettings_value('screendetection', True) and \
self._WordToScreenMatching.return_memory_account_count() > 1 and delay_used >= self._rotation_waittime \
and self.get_devicesettings_value('account_rotation', False) and not self._level_mode:
# Waiting time to long and more then one account - switch! (not level mode!!)
self.logger.info(
'Could use more then 1 account - switch & no cooldown')
self.switch_account()
delay_used = -1
if delay_used < 0:
self._current_sleep_time = 0
self.logger.info('No need to wait before spinning, continuing...')
else:
delay_used = math.floor(delay_used)
self.logger.info("Real sleep time: {} seconds: next action {}",
delay_used,
datetime.now() + timedelta(seconds=delay_used))
cleanupbox: bool = False
lastcleanupbox = self.get_devicesettings_value(
'last_cleanup_time', None)
self._current_sleep_time = delay_used
self.worker_stats()
if lastcleanupbox is not None:
if time.time() - lastcleanupbox > 900:
# just cleanup if last cleanup time > 15 minutes ago
cleanupbox = True
else:
cleanupbox = True
self._mapping_manager.routemanager_set_worker_sleeping(
self._routemanager_name, self._origin, delay_used)
while time.time() <= int(cur_time) + int(delay_used):
if delay_used > 200 and cleanupbox and not self._enhanced_mode:
self.clear_thread_task = ClearThreadTasks.BOX
cleanupbox = False
if not self._mapping_manager.routemanager_present(self._routemanager_name) \
or self._stop_worker_event.is_set():
self.logger.error("Worker was killed while sleeping")
self._current_sleep_time = 0
raise InternalStopWorkerException
time.sleep(1)
self._current_sleep_time = 0
self.set_devicesettings_value("last_location", self.current_location)
self.last_location = self.current_location
return cur_time, True
