def work(self):
if not self.should_run():
return WorkerResult.SUCCESS
nearest_fort = self.get_nearest_fort()
if nearest_fort is None:
return WorkerResult.SUCCESS
lat = nearest_fort['latitude']
lng = nearest_fort['longitude']
fortID = nearest_fort['id']
details = fort_details(self.bot, fortID, lat, lng)
fort_name = details.get('name', 'Unknown')
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
dist = distance(self.bot.position[0], self.bot.position[1], lat, lng)
noised_dist = distance(self.bot.noised_position[0],
self.bot.noised_position[1], lat, lng)
moving = noised_dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE if self.bot.config.replicate_gps_xy_noise else dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE
if moving:
fort_event_data = {
'fort_name': u"{}".format(fort_name),
'distance': format_dist(dist, unit),
}
if self.is_attracted() > 0:
fort_event_data.update(
lure_distance=format_dist(self.lure_distance, unit))
self.emit_event(
'moving_to_lured_fort',
formatted=
"Moving towards pokestop {fort_name} - {distance} (attraction of lure {lure_distance})",
data=fort_event_data)
else:
self.emit_event(
'moving_to_fort',
formatted=
"Moving towards pokestop {fort_name} - {distance}",
data=fort_event_data)
step_walker = walker_factory(self.walker, self.bot, lat, lng)
if not step_walker.step():
return WorkerResult.RUNNING
else:
if nearest_fort.get('active_fort_modifier') and self.wait_at_fort:
self.emit_event(
'arrived_at_fort',
formatted='Waiting near fort %s till Lure module expired' %
fort_name)
else:
self.emit_event('arrived_at_fort',
formatted='Arrived at fort.')
return WorkerResult.SUCCESS
def _move_to_pokemon_througt_fort(self, fort, pokemon):
"""Moves trainer towards a fort before a Pokemon.
Args:
fort
Returns:
StepWalker
"""
nearest_fort = fort
lat = nearest_fort['latitude']
lng = nearest_fort['longitude']
fortID = nearest_fort['id']
details = fort_details(self.bot, fortID, lat, lng)
fort_name = details.get('name', 'Unknown')
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
dist = distance(
self.bot.position[0],
self.bot.position[1],
lat,
lng
)
if dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE:
pokemon_throught_fort_event_data = {
'fort_name': u"{}".format(fort_name),
'distance': format_dist(dist, unit),
'poke_name': pokemon['name'],
'poke_dist': (format_dist(pokemon['dist'], self.unit))
}
self.emit_event(
'moving_to_pokemon_throught_fort',
formatted="Moving towards {poke_name} - {poke_dist} through pokestop {fort_name} - {distance}",
data= pokemon_throught_fort_event_data
)
else:
self.emit_event(
'arrived_at_fort',
formatted='Arrived at fort.'
)
return walker_factory(self.walker,
self.bot,
lat,
lng
)
def _move_to(self, pokemon):
"""Moves trainer towards a Pokemon.
Args:
pokemon: Pokemon to move to.
Returns:
Walker
"""
self.emit_event(
'move_to_map_pokemon_move_towards',
formatted=('Moving towards {poke_name}, {poke_dist}, left ('
'{disappears_in})'),
data=self._pokemon_event_data(pokemon))
return walker_factory(self.walker, self.bot, pokemon['latitude'],
pokemon['longitude'])
def _move_to(self, pokemon):
"""Moves trainer towards a Pokemon.
Args:
pokemon: Pokemon to move to.
Returns:
Walker
"""
self.emit_event(
'move_to_map_pokemon_move_towards',
formatted=('Moving towards {poke_name}, {poke_dist}, left ('
'{disappears_in})'),
data=self._pokemon_event_data(pokemon)
)
return walker_factory(self.walker, self.bot, pokemon['latitude'], pokemon['longitude'])
def work(self):
if not self.should_run():
return WorkerResult.SUCCESS
nearest_fort = self.get_nearest_fort()
if nearest_fort is None:
return WorkerResult.SUCCESS
lat = nearest_fort['latitude']
lng = nearest_fort['longitude']
fortID = nearest_fort['id']
details = fort_details(self.bot, fortID, lat, lng)
fort_name = details.get('name', 'Unknown')
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
dist = distance(
self.bot.position[0],
self.bot.position[1],
lat,
lng
)
noised_dist = distance(
self.bot.noised_position[0],
self.bot.noised_position[1],
lat,
lng
)
moving = noised_dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE if self.bot.config.replicate_gps_xy_noise else dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE
if moving:
self.wait_log_sent = None
fort_event_data = {
'fort_name': u"{}".format(fort_name),
'distance': format_dist(dist, unit),
}
if self.is_attracted() > 0:
fort_event_data.update(lure_distance=format_dist(self.lure_distance, unit))
self.emit_event(
'moving_to_lured_fort',
formatted="Moving towards pokestop {fort_name} - {distance} (attraction of lure {lure_distance})",
data=fort_event_data
)
else:
self.emit_event(
'moving_to_fort',
formatted="Moving towards pokestop {fort_name} - {distance}",
data=fort_event_data
)
step_walker = walker_factory(self.walker,
self.bot,
lat,
lng
)
if not step_walker.step():
return WorkerResult.RUNNING
else:
if not self.bot.catch_disabled and nearest_fort.get('active_fort_modifier') and self.wait_at_fort:
if self.wait_log_sent == None or self.wait_log_sent < datetime.now() - timedelta(seconds=60):
self.wait_log_sent = datetime.now()
self.emit_event(
'arrived_at_fort',
formatted='Waiting near fort %s until lure module expires' % fort_name
)
else:
self.emit_event(
'arrived_at_fort',
formatted='Arrived at fort.'
)
return WorkerResult.RUNNING
def move_to_destination(self):
if self.check_interval >= 4:
self.check_interval = 0
gyms = self.get_gyms()
for g in gyms:
if g["id"] == self.destination["id"]:
# self.logger.info("Inspecting target: %s" % g)
if "owned_by_team" in g and g[
"owned_by_team"] is not self.team:
self.logger.info(
"Damn! Team %s took gym before we arrived!" %
TEAMS[g["owned_by_team"]])
self.destination = None
return WorkerResult.SUCCESS
break
else:
self.check_interval += 1
# Moving to a gym to deploy Pokemon
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
lat = self.destination["latitude"]
lng = self.destination["longitude"]
details = fort_details(self.bot, self.destination["id"], lat, lng)
gym_name = details.get('name', 'Unknown')
dist = distance(self.bot.position[0], self.bot.position[1], lat, lng)
noised_dist = distance(self.bot.noised_position[0],
self.bot.noised_position[1], lat, lng)
moving = noised_dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE if self.bot.config.replicate_gps_xy_noise else dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE
if moving:
fort_event_data = {
'fort_name': u"{}".format(gym_name),
'distance': format_dist(dist, unit),
}
self.emit_event(
'moving_to_fort',
formatted="Moving towards open Gym {fort_name} - {distance}",
data=fort_event_data)
step_walker = walker_factory(self.walker, self.bot, lat, lng)
if not step_walker.step():
return WorkerResult.RUNNING
else:
#Running fails. Let's stop moving to the gym
return WorkerResult.SUCCESS
else:
self.emit_event('arrived_at_fort',
formatted=("Arrived at Gym %s." % gym_name))
gym_details = self.get_gym_details(self.destination)
current_pokemons = self._get_pokemons_in_gym(gym_details)
self.drop_pokemon_in_gym(self.destination, current_pokemons)
self.destination = None
if len(self.fort_pokemons) >= self.take_at_most:
self.logger.info("We have a max of %s Pokemon in gyms." %
self.take_at_most)
return WorkerResult.SUCCESS
elif self.chain_fill_gyms:
# Look around if there are more gyms to fill
self.determin_new_destination()
# If there is none, we're done, else we go to the next!
if self.destination is None:
return WorkerResult.SUCCESS
else:
return WorkerResult.RUNNING
else:
return WorkerResult.SUCCESS
def work(self):
# If done or wandering allow the next task to run
if self.status == STATUS_FINISHED:
return WorkerResult.SUCCESS
if self.disable_while_hunting and hasattr(self.bot,
"hunter_locked_target"):
if self.bot.hunter_locked_target != None:
return WorkerResult.SUCCESS
if time.time() < self.waiting_end_time:
if self.status == STATUS_WANDERING:
return WorkerResult.SUCCESS
elif self.status == STATUS_LOITERING:
return WorkerResult.RUNNING
last_lat, last_lng, last_alt = self.bot.position
point = self.points[self.ptr]
lat = point['lat']
lng = point['lng']
if 'alt' in point:
alt = float(point['alt'])
else:
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if self.bot.config.walk_max > 0:
step_walker = walker_factory(self.walker, self.bot, lat, lng, alt)
is_at_destination = False
if step_walker.step():
is_at_destination = True
else:
self.bot.api.set_position(lat, lng, alt)
dist = distance(last_lat, last_lng, lat, lng)
if not self.disable_location_output:
self.emit_event(
'position_update',
formatted=
"Walking from {last_position} to {current_position}, distance left: ({distance} {distance_unit}) ..",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position':
point["location"],
'distance':
format_dist(dist, self.distance_unit, self.append_unit),
'distance_unit':
self.distance_unit
})
if (self.bot.config.walk_min > 0 and is_at_destination) or (
self.status in [STATUS_WANDERING, STATUS_LOITERING]
and time.time() >= self.waiting_end_time):
if "loiter" in point and self.status != STATUS_LOITERING:
self.logger.info("Loitering for {} seconds...".format(
point["loiter"]))
self.status = STATUS_LOITERING
self.waiting_end_time = time.time() + point["loiter"]
return WorkerResult.RUNNING
if "wander" in point and self.status != STATUS_WANDERING:
self.logger.info("Wandering for {} seconds...".format(
point["wander"]))
self.status = STATUS_WANDERING
self.waiting_end_time = time.time() + point["wander"]
return WorkerResult.SUCCESS
if (self.ptr + 1) == len(self.points):
if self.path_mode == 'single':
self.status = STATUS_FINISHED
return WorkerResult.SUCCESS
self.ptr = 0
if self.path_mode == 'linear':
self.points = list(reversed(self.points))
if self.number_lap_max >= 0:
self.number_lap += 1
self.emit_event(
'path_lap_update',
formatted=
"number lap : {number_lap} / {number_lap_max}",
data={
'number_lap': str(self.number_lap),
'number_lap_max': str(self.number_lap_max)
})
if self.number_lap >= self.number_lap_max:
self.endLaps()
else:
self.ptr += 1
self.status = STATUS_MOVING
return WorkerResult.RUNNING
def work(self):
# If done or loitering allow the next task to run
if self.status == STATUS_FINISHED:
return WorkerResult.SUCCESS
if self.status == STATUS_LOITERING and time.time() < self.loiter_end_time:
return WorkerResult.SUCCESS
last_lat, last_lng, last_alt = self.bot.position
point = self.points[self.ptr]
lat = point['lat']
lng = point['lng']
if 'alt' in point:
alt = float(point['alt'])
else:
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if self.bot.config.walk_max > 0:
step_walker = walker_factory(self.walker,
self.bot,
lat,
lng,
alt
)
is_at_destination = False
if step_walker.step():
is_at_destination = True
else:
self.bot.api.set_position(lat, lng, alt)
dist = distance(
last_lat,
last_lng,
lat,
lng
)
self.emit_event(
'position_update',
formatted="Walking from {last_position} to {current_position}, distance left: ({distance} {distance_unit}) ..",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position': (lat, lng, alt),
'distance': format_dist(dist,self.distance_unit,self.append_unit),
'distance_unit': self.distance_unit
}
)
if dist <= 1 or (self.bot.config.walk_min > 0 and is_at_destination) or (self.status == STATUS_LOITERING and time.time() >= self.loiter_end_time):
if "loiter" in point and self.status != STATUS_LOITERING:
self.logger.info("Loitering for {} seconds...".format(point["loiter"]))
self.status = STATUS_LOITERING
self.loiter_end_time = time.time() + point["loiter"]
return WorkerResult.SUCCESS
if (self.ptr + 1) == len(self.points):
if self.path_mode == 'single':
self.status = STATUS_FINISHED
return WorkerResult.SUCCESS
self.ptr = 0
if self.path_mode == 'linear':
self.points = list(reversed(self.points))
if self.number_lap_max >= 0:
self.number_lap+=1
self.emit_event(
'path_lap_update',
formatted="number lap : {number_lap} / {number_lap_max}",
data={
'number_lap': str(self.number_lap),
'number_lap_max': str(self.number_lap_max)
}
)
if self.number_lap >= self.number_lap_max:
self.endLaps()
else:
self.ptr += 1
self.status = STATUS_MOVING
return WorkerResult.RUNNING
def work(self):
if not self.should_run():
return WorkerResult.SUCCESS
if hasattr(self.bot, "hunter_locked_target") and self.bot.hunter_locked_target is not None:
return WorkerResult.SUCCESS
nearest_fort = self.get_nearest_fort()
if nearest_fort is None:
return WorkerResult.SUCCESS
lat = nearest_fort['latitude']
lng = nearest_fort['longitude']
fortID = nearest_fort['id']
details = fort_details(self.bot, fortID, lat, lng)
fort_name = details.get('name', 'Unknown')
if self.target_id is None:
self.target_id = fort_name
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
dist = distance(
self.bot.position[0],
self.bot.position[1],
lat,
lng
)
noised_dist = distance(
self.bot.noised_position[0],
self.bot.noised_position[1],
lat,
lng
)
moving = noised_dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE if self.bot.config.replicate_gps_xy_noise else dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE
distance_to_target = int(noised_dist if self.bot.config.replicate_gps_xy_noise else dist)
if len(self.previous_distance) == 0:
self.previous_distance.append(distance_to_target)
elif self.target_id is not fort_name:
# self.logger.info("Changed target from %s to %s" % (self.target_id, fort_name))
self.previous_distance = [distance_to_target]
self.target_id = fort_name
if self.walker is not self.config.get('walker', 'StepWalker'):
self.walker = self.config.get('walker', 'StepWalker')
else:
# self.logger.info("Previous distances: %s" % self.previous_distance)
if len(self.previous_distance) > 5:
self.previous_distance.pop(0)
error_moving = False
times_found = 0
for prev_distance in self.previous_distance:
if prev_distance == distance_to_target:
error_moving = True
break
if error_moving:
if self.walker == 'StepWalker':
self.logger.info("Having difficulty walking to %s" % fort_name)
self.bot.recent_forts = self.bot.recent_forts[1:] + [fortID]
return WorkerResult.ERROR
else:
self.logger.info("Having difficulty walking to %s. Changing walker." % fort_name)
self.walker = 'StepWalker'
self.previous_distance = [distance_to_target]
else:
self.previous_distance.append(distance_to_target)
if moving:
self.wait_log_sent = None
if "type" in nearest_fort and nearest_fort["type"] == 1:
# It's a Pokestop
target_type = "pokestop"
else:
# It's a gym
target_type = "gym"
fort_event_data = {
'fort_name': u"{}".format(fort_name),
'distance': format_dist(dist, unit),
'target_type': target_type,
}
if self.is_attracted() > 0:
fort_event_data.update(lure_distance=format_dist(self.lure_distance, unit))
self.emit_event(
'moving_to_lured_fort',
formatted="Moving towards {target_type} {fort_name} - {distance} (attraction of lure {lure_distance})",
data=fort_event_data
)
else:
self.emit_event(
'moving_to_fort',
formatted="Moving towards {target_type} {fort_name} - {distance}",
data=fort_event_data
)
step_walker = walker_factory(self.walker,
self.bot,
lat,
lng
)
if not step_walker.step():
return WorkerResult.RUNNING
else:
if not self.bot.catch_disabled and nearest_fort.get('active_fort_modifier') and self.wait_at_fort:
if self.wait_log_sent == None or self.wait_log_sent < datetime.now() - timedelta(seconds=60):
self.wait_log_sent = datetime.now()
self.emit_event(
'arrived_at_fort',
formatted='Waiting near fort %s until lure module expires' % fort_name
)
else:
self.emit_event(
'arrived_at_fort',
formatted='Arrived at fort %s.' % fort_name
)
return WorkerResult.RUNNING
def move_to_destination(self):
if self.check_interval >= 4 and not self.found_raid:
self.check_interval = 0
gyms = self.get_gyms()
for g in gyms:
if g["id"] == self.destination["id"]:
# self.logger.info("Inspecting target: %s" % g)
if "owned_by_team" in g and g[
"owned_by_team"] is not self.team:
self.logger.info(
"Damn! Team %s took gym before we arrived!" %
TEAMS[g["owned_by_team"]])
self.destination = None
return WorkerResult.SUCCESS
break
elif not self.found_raid:
self.check_interval += 1
# Moving to a gym to deploy Pokemon / to start a raid
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
lat = self.destination["latitude"]
lng = self.destination["longitude"]
details = fort_details(self.bot, self.destination["id"], lat, lng)
gym_name = details.get('name', 'Unknown')
dist = distance(self.bot.position[0], self.bot.position[1], lat, lng)
noised_dist = distance(self.bot.noised_position[0],
self.bot.noised_position[1], lat, lng)
moving = noised_dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE if self.bot.config.replicate_gps_xy_noise else dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE
if moving:
fort_event_data = {
'fort_name': u"{}".format(gym_name),
'distance': format_dist(dist, unit),
}
if not self.found_raid:
self.emit_event(
'moving_to_fort',
formatted=
"Moving towards open Gym {fort_name} - {distance}",
data=fort_event_data)
else:
self.emit_event(
'moving_to_fort',
formatted=
"Moving towards raid Gym {fort_name} - {distance}",
data=fort_event_data)
step_walker = walker_factory(self.walker, self.bot, lat, lng)
if not step_walker.step():
return WorkerResult.RUNNING
else:
#Running fails. Let's stop moving to the gym
return WorkerResult.SUCCESS
else:
self.emit_event('arrived_at_fort',
formatted=("Arrived at Gym %s." % gym_name))
gym_details = self.get_gym_details(self.destination)
if not self.found_raid:
current_pokemons = self._get_pokemons_in_gym(gym_details)
self.drop_pokemon_in_gym(self.destination, current_pokemons)
self.destination = None
if len(self.fort_pokemons) >= self.take_at_most:
self.logger.info("We have a max of %s Pokemon in gyms." %
self.take_at_most)
return WorkerResult.SUCCESS
elif self.chain_fill_gyms:
# Look around if there are more gyms to fill
self.determin_new_destination()
# If there is none, we're done, else we go to the next!
if self.destination is None:
return WorkerResult.SUCCESS
else:
return WorkerResult.RUNNING
else:
return WorkerResult.SUCCESS
else:
# we are going to do raid
# steps: 1. Check if has started. if not started, we wait till start. if started we wait till max number of players in lobby reached.
# if all conditions met, enter lobby
# get ready a list of battling pokemons (using type advenage logic)
# start battle
# if failed, heal and restart the process
# successful raid, go to bonus capture
# reset raid, return success
gym_info = gym_details.get('gym_status_and_defenders', None)
if gym_info is not None:
pokemon_fort_proto = gym_info.get('pokemon_fort_proto')
raid_info = pokemon_fort_proto.get('raid_info')
raid_level = raid_info['raid_level']
raid_seed = raid_info['raid_seed']
raid_end_ms = raid_info['raid_end_ms']
raid_battle_ms = raid_info['raid_battle_ms']
raid_starts = datetime.fromtimestamp(
int(raid_info["raid_battle_ms"]) / 1e3)
raid_ends = datetime.fromtimestamp(
int(raid_info["raid_end_ms"]) / 1e3)
self.logger.info(
"Raid starts: %s" %
raid_starts.strftime('%Y-%m-%d %H:%M:%S.%f'))
self.logger.info(
"Raid ends: %s" %
raid_ends.strftime('%Y-%m-%d %H:%M:%S.%f'))
if raid_starts < datetime.now():
timediff = raid_ends - datetime.now()
results = divmod(
timediff.days * 86400 + timediff.seconds, 60)
# No need check what pokemon anymore
if results[0] >= self.do_not_raid_last_x_mins:
a = 0
#
#if raid_ends < datetime.now():
# self.logger.info("No need to wait.")
#elif (raid_ends-t).seconds > 600:
# self.logger.info("Need to wait more than 10 minutes, skipping")
# self.destination = None
# self.recent_gyms.append(gym["id"])
# self.raid_gyms[gym["id"]] = raid_ends
# return WorkerResult.SUCCESS
#else:
# first_time = False
# while raid_ends > datetime.now():
# raid_ending = (raid_ends-datetime.today()).seconds
# sleep_m, sleep_s = divmod(raid_ending, 60)
# sleep_h, sleep_m = divmod(sleep_m, 60)
# sleep_hms = '%02d:%02d:%02d' % (sleep_h, sleep_m, sleep_s)
# if not first_time:
# Clear the last log line!
# stdout.write("\033[1A\033[0K\r")
# stdout.flush()
# first_time = True
# self.logger.info("Waiting for %s for raid to end..." % sleep_hms)
# if raid_ending > 20:
# sleep(20)
# else:
# sleep(raid_ending)
# break
else:
self.logger.info("Raid has not begun yet!")
self.logger.info("Assume we are done with raid")
print("id: " + format(gym_info['pokemon_fort_proto']['id']))
if gym_info['pokemon_fort_proto']['id']:
self.raided_gyms.append(
gym_info['pokemon_fort_proto']['id']
) #check if this need to be removed after successful implenation of raid feature
print("dropped_gyms: " + format(self.raided_gyms))
self.destination = None
self.found_raid = False
return WorkerResult.SUCCESS
def work(self):
last_lat = self.bot.api._position_lat
last_lng = self.bot.api._position_lng
last_alt = self.bot.api._position_alt
point = self.points[self.ptr]
lat = float(point['lat'])
lng = float(point['lng'])
if 'alt' in point:
alt = float(point['alt'])
else:
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if self.bot.config.walk_max > 0:
step_walker = walker_factory(self.walker,
self.bot,
lat,
lng,
alt
)
is_at_destination = False
if step_walker.step():
is_at_destination = True
else:
self.bot.api.set_position(lat, lng, alt)
dist = distance(
last_lat,
last_lng,
lat,
lng
)
self.emit_event(
'position_update',
formatted="Walking from {last_position} to {current_position}, distance left: ({distance} {distance_unit}) ..",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position': (lat, lng, alt),
'distance': dist,
'distance_unit': 'm'
}
)
if dist <= 1 or (self.bot.config.walk_min > 0 and is_at_destination):
if (self.ptr + 1) == len(self.points):
self.ptr = 0
if self.path_mode == 'linear':
self.points = list(reversed(self.points))
if self.number_lap_max >= 0:
self.number_lap+=1
self.emit_event(
'path_lap_update',
formatted="number lap : {number_lap} / {number_lap_max}",
data={
'number_lap': str(self.number_lap),
'number_lap_max': str(self.number_lap_max)
}
)
if self.number_lap >= self.number_lap_max:
self.endLaps()
else:
self.ptr += 1
return [lat, lng]
def work(self):
# If done or loitering allow the next task to run
if self.status == STATUS_FINISHED:
return WorkerResult.SUCCESS
if self.status == STATUS_LOITERING and time.time() < self.loiter_end_time:
return WorkerResult.SUCCESS
last_lat = self.bot.api._position_lat
last_lng = self.bot.api._position_lng
last_alt = self.bot.api._position_alt
point = self.points[self.ptr]
lat = point['lat']
lng = point['lng']
if 'alt' in point:
alt = float(point['alt'])
else:
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if self.bot.config.walk_max > 0:
step_walker = walker_factory(self.walker,
self.bot,
lat,
lng,
alt
)
is_at_destination = False
if step_walker.step():
is_at_destination = True
else:
self.bot.api.set_position(lat, lng, alt)
dist = distance(
last_lat,
last_lng,
lat,
lng
)
self.emit_event(
'position_update',
formatted="Walking from {last_position} to {current_position}, distance left: ({distance} {distance_unit}) ..",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position': (lat, lng, alt),
'distance': dist,
'distance_unit': 'm'
}
)
if dist <= 1 or (self.bot.config.walk_min > 0 and is_at_destination) or (self.status == STATUS_LOITERING and time.time() >= self.loiter_end_time):
if "loiter" in point and self.status != STATUS_LOITERING:
print("Loitering {} seconds".format(point["loiter"]))
self.status = STATUS_LOITERING
self.loiter_end_time = time.time() + point["loiter"]
return WorkerResult.SUCCESS
if (self.ptr + 1) == len(self.points):
if self.path_mode == 'single':
self.status = STATUS_FINISHED
return WorkerResult.SUCCESS
self.ptr = 0
if self.path_mode == 'linear':
self.points = list(reversed(self.points))
if self.number_lap_max >= 0:
self.number_lap+=1
self.emit_event(
'path_lap_update',
formatted="number lap : {number_lap} / {number_lap_max}",
data={
'number_lap': str(self.number_lap),
'number_lap_max': str(self.number_lap_max)
}
)
if self.number_lap >= self.number_lap_max:
self.endLaps()
else:
self.ptr += 1
self.status = STATUS_MOVING
return WorkerResult.RUNNING
def move_to_destination(self):
if self.check_interval >= 4 and not self.found_raid:
self.check_interval = 0
gyms = self.get_gyms()
for g in gyms:
if g["id"] == self.destination["id"]:
# self.logger.info("Inspecting target: %s" % g)
if "owned_by_team" in g and g["owned_by_team"] is not self.team:
self.logger.info("Damn! Team %s took gym before we arrived!" % TEAMS[g["owned_by_team"]])
self.destination = None
return WorkerResult.SUCCESS
break
elif not self.found_raid:
self.check_interval += 1
# Moving to a gym to deploy Pokemon / to start a raid
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
lat = self.destination["latitude"]
lng = self.destination["longitude"]
details = fort_details(self.bot, self.destination["id"], lat, lng)
gym_name = details.get('name', 'Unknown')
dist = distance(
self.bot.position[0],
self.bot.position[1],
lat,
lng
)
noised_dist = distance(
self.bot.noised_position[0],
self.bot.noised_position[1],
lat,
lng
)
moving = noised_dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE if self.bot.config.replicate_gps_xy_noise else dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE
if moving:
fort_event_data = {
'fort_name': u"{}".format(gym_name),
'distance': format_dist(dist, unit),
}
if not self.found_raid:
self.emit_event(
'moving_to_fort',
formatted="Moving towards open Gym {fort_name} - {distance}",
data=fort_event_data
)
else:
self.emit_event(
'moving_to_fort',
formatted="Moving towards raid Gym {fort_name} - {distance}",
data=fort_event_data
)
step_walker = walker_factory(self.walker, self.bot, lat, lng)
if not step_walker.step():
return WorkerResult.RUNNING
else:
#Running fails. Let's stop moving to the gym
return WorkerResult.SUCCESS
else:
self.emit_event(
'arrived_at_fort',
formatted=("Arrived at Gym %s." % gym_name)
)
gym_details = self.get_gym_details(self.destination)
if not self.found_raid:
current_pokemons = self._get_pokemons_in_gym(gym_details)
self.drop_pokemon_in_gym(self.destination, current_pokemons)
self.destination = None
if len(self.fort_pokemons) >= self.take_at_most:
self.logger.info("We have a max of %s Pokemon in gyms." % self.take_at_most)
return WorkerResult.SUCCESS
elif self.chain_fill_gyms:
# Look around if there are more gyms to fill
self.determin_new_destination()
# If there is none, we're done, else we go to the next!
if self.destination is None:
return WorkerResult.SUCCESS
else:
return WorkerResult.RUNNING
else:
return WorkerResult.SUCCESS
else:
# we are going to do raid
# steps: 1. Check if has started. if not started, we wait till start. if started we wait till max number of players in lobby reached.
# if all conditions met, enter lobby
# get ready a list of battling pokemons (using type advenage logic)
# start battle
# if failed, heal and restart the process
# successful raid, go to bonus capture
# reset raid, return success
gym_info = gym_details.get('gym_status_and_defenders', None)
if gym_info is not None:
pokemon_fort_proto = gym_info.get('pokemon_fort_proto')
raid_info = pokemon_fort_proto.get('raid_info')
raid_level = raid_info['raid_level']
raid_seed = raid_info['raid_seed']
raid_end_ms = raid_info['raid_end_ms']
raid_battle_ms = raid_info['raid_battle_ms']
raid_starts = datetime.fromtimestamp(int(raid_info["raid_battle_ms"]) / 1e3)
raid_ends = datetime.fromtimestamp(int(raid_info["raid_end_ms"]) / 1e3)
self.logger.info("Raid starts: %s" % raid_starts.strftime('%Y-%m-%d %H:%M:%S.%f'))
self.logger.info("Raid ends: %s" % raid_ends.strftime('%Y-%m-%d %H:%M:%S.%f'))
if raid_starts < datetime.now():
timediff = raid_ends - datetime.now()
results = divmod(timediff.days * 86400 + timediff.seconds, 60)
# No need check what pokemon anymore
if results[0] >= self.do_not_raid_last_x_mins:
a=0
#
#if raid_ends < datetime.now():
# self.logger.info("No need to wait.")
#elif (raid_ends-t).seconds > 600:
# self.logger.info("Need to wait more than 10 minutes, skipping")
# self.destination = None
# self.recent_gyms.append(gym["id"])
# self.raid_gyms[gym["id"]] = raid_ends
# return WorkerResult.SUCCESS
#else:
# first_time = False
# while raid_ends > datetime.now():
# raid_ending = (raid_ends-datetime.today()).seconds
# sleep_m, sleep_s = divmod(raid_ending, 60)
# sleep_h, sleep_m = divmod(sleep_m, 60)
# sleep_hms = '%02d:%02d:%02d' % (sleep_h, sleep_m, sleep_s)
# if not first_time:
# Clear the last log line!
# stdout.write("\033[1A\033[0K\r")
# stdout.flush()
# first_time = True
# self.logger.info("Waiting for %s for raid to end..." % sleep_hms)
# if raid_ending > 20:
# sleep(20)
# else:
# sleep(raid_ending)
# break
else:
self.logger.info("Raid has not begun yet!")
self.logger.info("Assume we are done with raid")
print("id: "+format(gym_info['pokemon_fort_proto']['id']))
if gym_info['pokemon_fort_proto']['id']:
self.raided_gyms.append(gym_info['pokemon_fort_proto']['id'])#check if this need to be removed after successful implenation of raid feature
print("dropped_gyms: "+format(self.raided_gyms))
self.destination = None
self.found_raid = False
return WorkerResult.SUCCESS
