def work(self):
if not self.next_point:
self.next_point = next(self.points)
point = self.next_point
step_walker = StepWalker(self.bot, point['lat'], point['lng'])
if step_walker.step():
self.next_point = None
return [point['lat'], point['lng']]
def work(self):
if not self.next_point:
self.next_point = next(self.points)
point = self.next_point
step_walker = StepWalker(self.bot, point['lat'], point['lng'])
if step_walker.step():
self.next_point = None
return [point['lat'], point['lng']]
def work(self):
last_lat, last_lng, last_alt = self.bot.api.get_position()
point = self.points[self.ptr]
self.cnt += 1
dist = distance(
last_lat,
last_lng,
point['lat'],
point['lng']
)
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if self.bot.config.walk_max > 0:
step_walker = StepWalker(
self.bot,
point['lat'],
point['lng']
)
if self.cnt == 1:
self.emit_event(
'position_update',
formatted="Walking from {last_position} to {current_position} ({distance} {distance_unit})",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position': (point['lat'], point['lng'], alt),
'distance': dist,
'distance_unit': 'm'
}
)
if step_walker.step():
step_walker = None
else:
self.bot.api.set_position(point['lat'], point['lng'], alt)
self.emit_event(
'position_update',
formatted="Teleported from {last_position} to {current_position} ({distance} {distance_unit})",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position': (point['lat'], point['lng'], alt),
'distance': dist,
'distance_unit': 'm'
}
)
if dist <= 1 or (self.bot.config.walk_min > 0 and step_walker == None):
if self.ptr + self.direction >= len(self.points) or self.ptr + self.direction <= -1:
self.direction *= -1
if len(self.points) != 1:
self.ptr += self.direction
else:
self.ptr = 0
self.cnt = 0
return [point['lat'], point['lng']]
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.logger.info("New destination at %(distance).2f meters: %(name)s", self.destination)
self.no_log_until = now + 60
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[1:] + self.search_points[:1]
else:
if self.no_log_until < now:
self.logger.info("There is no nearby pokemon worth hunting down [%s]", ", ".join(p["name"] for p in pokemons))
self.no_log_until = now + 120
self.last_cell_id = None
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"] for p in self.bot.cell["catchable_pokemons"] + self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"] for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.destination = None
else:
self.logger.info("Now searching for %(name)s", self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_points = self.search_points[1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
self.logger.info("Moving to destination at %s meters: %s", round(distance, 2), self.destination["name"])
self.no_log_until = now + 30
return WorkerResult.RUNNING
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'])
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if 'alt' in point:
alt = float(point['alt'])
if self.bot.config.walk_max > 0:
step_walker = StepWalker(self.bot, lat, lng)
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 walker_factory(name, bot, dest_lat, dest_lng, *args, **kwargs):
'''
Charlie and the Walker Factory
'''
if 'StepWalker' == name:
ret = StepWalker(bot, dest_lat, dest_lng)
elif 'PolylineWalker' == name:
try:
ret = PolylineWalker(bot, dest_lat, dest_lng)
except:
ret = StepWalker(bot, dest_lat, dest_lng)
return ret
def work(self):
last_lat, last_lng, last_alt = self.bot.api.get_position()
point = self.points[self.ptr]
self.cnt += 1
dist = distance(last_lat, last_lng, point['lat'], point['lng'])
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if self.bot.config.walk_max > 0:
step_walker = StepWalker(self.bot, point['lat'], point['lng'])
if self.cnt == 1:
self.emit_event(
'position_update',
formatted=
"Walking from {last_position} to {current_position} ({distance} {distance_unit})",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position': (point['lat'], point['lng'], alt),
'distance': dist,
'distance_unit': 'm'
})
if step_walker.step():
step_walker = None
else:
self.bot.api.set_position(point['lat'], point['lng'], alt)
self.emit_event(
'position_update',
formatted=
"Teleported from {last_position} to {current_position} ({distance} {distance_unit})",
data={
'last_position': (last_lat, last_lng, last_alt),
'current_position': (point['lat'], point['lng'], alt),
'distance': dist,
'distance_unit': 'm'
})
if dist <= 1 or (self.bot.config.walk_min > 0 and step_walker == None):
if self.ptr + self.direction >= len(
self.points) or self.ptr + self.direction <= -1:
self.direction *= -1
if len(self.points) != 1:
self.ptr += self.direction
else:
self.ptr = 0
self.cnt = 0
return [point['lat'], point['lng']]
def test_small_distance_same_spot(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 1
self.bot.config.walk_min = 1
sw = StepWalker(self.bot, 0, 0, precision=0.0)
self.assertEqual(sw.dest_lat, 0, 'dest_lat should be 0')
self.assertEqual(sw.dest_lng, 0, 'dest_lng should be 0')
@mock.patch('random.uniform')
def run_step(mock_random):
mock_random.return_value = 0.0
return sw.step()
moveInprecision = run_step()
self.assertTrue(moveInprecision, 'step should return True')
distance = Geodesic.WGS84.Inverse(0.0, 0.0, self.bot.position[0],
self.bot.position[1])["s12"]
self.assertTrue(0.0 <= distance <= (sw.precision + sw.epsilon))
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_normalized_distance_times_2(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 2
self.bot.config.walk_min = 2
sw = StepWalker(self.bot, 0.1, 0.1, precision=0.0)
self.assertTrue(sw.dest_lat > 0)
self.assertTrue(sw.dest_lng > 0)
@mock.patch('random.uniform')
def run_step(mock_random):
mock_random.return_value = 0.0
return sw.step()
stayInPlace = run_step()
self.assertFalse(stayInPlace)
self.assertAlmostEqual(self.bot.position[0],
NORMALIZED_LAT_LNG_DISTANCE[0] * 2,
places=6)
self.assertAlmostEqual(self.bot.position[1],
NORMALIZED_LAT_LNG_DISTANCE[1] * 2,
places=6)
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_teleport(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 4
self.bot.config.walk_min = 2
sw = StepWalker(self.bot, 10, 10, precision=0.0)
self.assertEqual(sw.dest_lat, 10)
self.assertEqual(sw.dest_lng, 10)
@mock.patch('random.uniform')
def run_step(mock_random):
mock_random.return_value = 0.0
return sw.step(speed=float("inf"))
finishedWalking = run_step()
self.assertTrue(finishedWalking, 'step should return True')
total_distance = Geodesic.WGS84.Inverse(0.0, 0.0, 10, 10)["s12"]
distance = Geodesic.WGS84.Inverse(0.0, 0.0, self.bot.position[0],
self.bot.position[1])["s12"]
self.assertTrue(0.0 <= abs(total_distance -
distance) <= (sw.precision + sw.epsilon))
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_small_distance_small_step(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 1
self.bot.config.walk_min = 1
# distance from origin 0,0 to 1e-6, 1e-6 is 0.157253373328 meters
total_distance = Geodesic.WGS84.Inverse(0.0, 0.0, 1e-6, 1e-6)["s12"]
# we take a precision bigger then the total value...
sw = StepWalker(self.bot, 1e-6, 1e-6, precision=0.2)
self.assertEqual(sw.dest_lat, 1e-6)
self.assertEqual(sw.dest_lng, 1e-6)
@mock.patch('random.uniform')
def run_step(mock_random):
mock_random.return_value = 0.0
return sw.step()
moveInprecistion = run_step()
self.assertTrue(moveInprecistion, 'step should return True')
distance = Geodesic.WGS84.Inverse(0.0, 0.0, self.bot.position[0],
self.bot.position[1])["s12"]
self.assertTrue(0.0 <= abs(total_distance -
distance) <= (sw.precision + sw.epsilon))
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_small_distance_same_spot(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 1
self.bot.config.walk_min = 1
sw = StepWalker(self.bot, 0, 0)
self.assertEqual(sw.dLat, 0, 'dLat should be 0')
self.assertEqual(sw.dLng, 0, 'dLng should be 0')
self.assertTrue(sw.step(), 'step should return True')
self.assertTrue(self.lat == self.bot.position[0])
self.assertTrue(self.lng == self.bot.position[1])
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_normalized_distance_times_2(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 2
self.bot.config.walk_min = 2
sw = StepWalker(self.bot, 0.1, 0.1, precision=0.0)
self.assertTrue(sw.dLat > 0)
self.assertTrue(sw.dLng > 0)
stayInPlace = sw.step()
self.assertFalse(stayInPlace)
self.assertTrue(float_equal(self.lat, NORMALIZED_LAT_LNG_DISTANCE[0] * 2))
self.assertTrue(float_equal(self.lng, NORMALIZED_LAT_LNG_DISTANCE[1] * 2))
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_normalized_distance(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 1
self.bot.config.walk_min = 1
sw = StepWalker(self.bot, 0.1, 0.1)
self.assertGreater(sw.dLat, 0)
self.assertGreater(sw.dLng, 0)
stayInPlace = sw.step()
self.assertFalse(stayInPlace)
self.assertTrue(float_equal(self.lat, NORMALIZED_LAT_LNG_DISTANCE_STEP))
self.assertTrue(float_equal(self.lng, NORMALIZED_LAT_LNG_DISTANCE_STEP))
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_small_distance_small_step(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 1
self.bot.config.walk_min = 1
sw = StepWalker(self.bot, 1e-5, 1e-5)
self.assertEqual(sw.dLat, 0)
self.assertEqual(sw.dLng, 0)
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def test_big_distances(self):
walk_max = self.bot.config.walk_max
walk_min = self.bot.config.walk_min
self.bot.config.walk_max = 1
self.bot.config.walk_min = 1
sw = StepWalker(self.bot, 10, 10, precision=0.0)
self.assertEqual(sw.dest_lat, 10)
self.assertEqual(sw.dest_lng, 10)
@mock.patch('random.uniform')
def run_step(mock_random):
mock_random.return_value = 0.0
return sw.step()
finishedWalking = run_step()
self.assertFalse(finishedWalking, 'step should return False')
self.assertAlmostEqual(self.bot.position[0],
NORMALIZED_LAT_LNG_DISTANCE[0],
places=6)
self.bot.config.walk_max = walk_max
self.bot.config.walk_min = walk_min
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.bot.catch_disabled:
# When catching is disabled, drop the target.
if self.destination is not None:
self.destination = None
self.last_cell_id = None
if not hasattr(self.bot, "hunter_disabled_global_warning") or \
(hasattr(self.bot, "hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info("All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled".format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.bot.softban:
# At softban, drop target
if self.destination is not None:
self.destination = None
self.last_cell_id = None
self.hunting_trash = False
if not hasattr(self.bot, "softban_global_warning") or \
(hasattr(self.bot, "softban_global_warning") and not self.bot.softban_global_warning):
self.logger.info("Possible softban! Not trying to catch Pokemon.")
self.bot.softban_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.softban_global_warning = False
if self.config_disabled_while_camping and hasattr(self.bot, 'camping_forts') and self.bot.camping_forts:
return WorkerResult.SUCCESS
if not self.config_lock_on_target:
self.bot.hunter_locked_target = None
if self.no_hunt_until != None and self.no_hunt_until > time.time():
# No hunting now, cooling down
return WorkerResult.SUCCESS
else:
# Resume hunting
self.no_hunt_until = None
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
self.hunting_trash = False
return WorkerResult.SUCCESS
if hasattr(self.bot,"hunter_locked_target"):
if self.destination is not None and self.bot.hunter_locked_target is not None:
if self.destination is not self.bot.hunter_locked_target:
self.logger.info("Locked on to a different target than destination??")
self.bot.hunter_locked_target = None
if self.destination is not None:
if self.destination_caught():
self.logger.info("We found a %(name)s while hunting.", self.destination)
# self.recent_tries.append(self.destination['pokemon_id'])
self.previous_destination = self.destination
self.destination = None
self.hunting_trash = False
self.bot.hunter_locked_target = None
self.lost_counter = 0
self.lost_map_counter = 0
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
else:
self.logger.info("Electing new target....")
if self.destination_vanished():
self.logger.info("Darn, target got away!")
# self.recent_tries.append(self.destination['pokemon_id'])
self.previous_destination = self.destination
self.destination = None
self.hunting_trash = False
self.bot.hunter_locked_target = None
self.lost_counter = 0
self.lost_map_counter = 0
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
else:
self.logger.info("Electing new target....")
now = time.time()
pokemons = self.get_nearby_pokemons()
pokemons = filter(lambda x: x["pokemon_id"] not in self.recent_tries, pokemons)
trash_mons = ["Caterpie", "Weedle", "Pidgey", "Pidgeotto", "Pidgeot", "Kakuna", "Beedrill", "Metapod", "Butterfree"]
if self.destination is not None:
target_mons = filter(lambda x: x["name"] is self.destination["name"], pokemons)
if self.no_log_until < now:
# self.logger.info("Targets on sightings: %s" % len(target_mons))
if len(pokemons) > 0:
if len(target_mons) < 1:
# Target off sightings; must be getting close
# Drops of at about 120 meters to target...
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
if (distance > 125 and self.lost_map_counter > 4) or self.lost_map_counter > 10:
# If > 120 meter => must be gone?
# Searching for 10 times, give up...
self.logger.info("It seems %(name)s is no longer there!", self.destination)
self.destination = None
self.hunting_trash = False
self.bot.hunter_locked_target = None
self.lost_map_counter = 0
self.lost_counter = 0
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
else:
self.logger.info("Electing new target....")
else:
self.lost_map_counter += 1
else:
self.lost_map_counter = 0
else:
self.logger.info("No sightings available at the moment...")
if self.config_hunt_for_trash and self.hunting_trash is False and (self.destination is None or not self._is_vip_pokemon(self.destination) ):
# Okay, we should hunt for trash if the bag is almost full
pokemons.sort(key=lambda p: p["distance"])
possible_targets = filter(lambda x: x["name"] in trash_mons, pokemons)
if self.pokemon_slots_left() <= self.config_trash_hunt_open_slots:
if self.no_log_until < now:
self.logger.info("Less than %s slots left to fill, starting hunt for trash" % self.config_trash_hunt_open_slots)
if len(possible_targets) is 0:
self.logger.info("No trash pokemon around...")
for pokemon in possible_targets:
if self.destination is not None:
self.logger.info("Trash hunt takes priority! Changing target...")
self.hunting_trash = True
self.destination = pokemon
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("Hunting for trash at %(distance).2f meters: %(name)s", self.destination)
self.set_target()
# We have a target
return WorkerResult.RUNNING
if self.config_hunt_for_trash and self.hunting_trash:
if self.pokemon_slots_left() > self.config_trash_hunt_open_slots:
self.logger.info("No longer trying to fill the bag. Electing new target....")
self.hunting_trash = False
self.destination = None
# Closer target?
if self.no_log_until < now:
# Don't check every tick!
if self.destination is not None and len(pokemons) > 0:
pokemons.sort(key=lambda p: p["distance"])
possible_targets = filter(lambda x: x["name"] in trash_mons, pokemons)
# Check for a closer target
self.destination["distance"] = self.get_distance(self.bot.position, self.destination)
for pokemon in possible_targets:
if pokemon is not self.destination:
if round(pokemon["distance"], 2) >= round(self.destination["distance"], 2):
# further away!
break
self.logger.info("Found a closer target: %s < %s" % (pokemon["distance"], self.destination["distance"]))
if self.destination is not None:
self.logger.info("Closer trash hunt takes priority! Changing target...")
self.hunting_trash = True
self.destination = pokemon
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("New target at %(distance).2f meters: %(name)s", self.destination)
self.set_target()
# We have a target
return WorkerResult.RUNNING
if self.destination is None:
# Use this time for shadowban check
if self.shadowban_detection:
if not self.check_rare_pokemons(pokemons):
self.no_rare_counts += 1
self.logger.info("[Shadow Ban Detection] I cannot find any rares/uncommon pokemons. Count: " + format(self.no_rare_counts))
else:
# Reset to zero
self.logger.info("[Shadow Ban Detection] Rares/uncommon pokemons are spotted")
self.no_rare_counts = 0
if self.no_rare_counts > 3:
# If more than 3 times we can't find any rares, we alert user of possible shadow bans
self.emit_event(
'shadowban_alert',
formatted="\033[91m[Shadow Ban Alert]\033[0m More than 3 occassions we could not find any rare pokemons."
)
if self.no_rare_counts == 4:
# Record in database once per run
try:
with self.bot.database as conn:
c = conn.cursor()
c.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='shadowban_log'")
result = c.fetchone()
while True:
if result[0] == 1:
conn.execute('''INSERT INTO shadowban_log (username) VALUES (?)''', (str(self.bot.config.username),))
break
else:
self.emit_event(
'shadowban_log',
sender=self,
level='info',
formatted="shadow_log table not found, skipping log"
)
user_data_shadowban = os.path.join(_base_dir, 'data', 'shadowban-%s.json' % self.bot.config.username)
with open(user_data_shadowban, 'ab') as outfile:
json.dump(OrderedDict({
'datetime': str(datetime.now()),
'username': self.bot.config.username
}), outfile)
outfile.write('\n')
except IOError as e:
self.logger.info('[x] Error while opening location file: %s' % e)
if self.exit_if_shadowbanned:
sys.exit(0)
worth_pokemons = self.get_worth_pokemons(pokemons, self.config_hunt_closest_first)
if len(worth_pokemons) > 0:
# Pick a random target from the list
# random.shuffle(worth_pokemons)
if self.config_hunt_closest_first:
# Priotize closer pokemon
worth_pokemons.sort(key=lambda p: p["distance"])
else:
random.shuffle(worth_pokemons)
# Prevents the bot from looping the same Pokemon
self.destination = worth_pokemons[0]
if self.previous_destination is not None:
# Check if we are hunting the same target again...
if self.previous_destination["pokemon_id"] == self.destination["pokemon_id"]:
# Hunting the same pokemon again?
if "fort_id" in self.previous_destination and "fort_id" in self.destination and \
self.previous_destination["fort_id"] == self.destination["fort_id"]:
# Hunting the same target again?
if len(worth_pokemons) > 1:
self.destination = worth_pokemons[1]
else:
# Checking if it's the same distance...
self.previous_destination["distance"] = self.get_distance(self.bot.start_position, self.previous_destination)
self.destination["distance"] = self.get_distance(self.bot.start_position, self.destination)
if round(self.previous_destination["distance"], 2) == round(self.destination["distance"], 2):
self.logger.info("Likely we are trying the same Pokemon again")
if len(worth_pokemons) > 1:
self.destination = worth_pokemons[1]
if self.previous_destination == self.destination:
# We already caught that Pokemon!
if len(worth_pokemons) > 1:
self.destination = worth_pokemons[1]
self.set_target()
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("New destination at %(distance).2f meters: %(name)s", self.destination)
if self._is_vip_pokemon(self.destination) and self.config_lock_on_target:
self.logger.info("This is a VIP Pokemon! Locking on to target!")
self.bot.hunter_locked_target = self.destination
elif self._is_family_of_vip(self.destination) and self.config_treat_family_of_vip_as_vip and self.config_lock_on_target:
self.logger.info("This Pokemon is family of a VIP! Locking target!")
self.bot.hunter_locked_target = self.destination
elif self._is_needed_pokedex(self.destination):
self.logger.info("I need a %(name)s to complete the Pokedex! I have %(candies)s candies.", self.destination)
if self.config_lock_on_target and not self.config_lock_vip_only:
self.bot.hunter_locked_target = self.destination
else:
self.bot.hunter_locked_target = None
self.no_log_until = now + 60
# We have a target
return WorkerResult.SUCCESS
else:
if self.no_log_until < now:
# Show like "Pidgey (12), Zubat(2)"
names = Counter((p["name"] for p in pokemons))
sorted(names) # unicode object, no lower? , key=str.lower)
if len(names) > 0:
self.logger.info("There is no nearby pokemon worth hunting down [%s]", ", ".join('{}({})'.format(key, val) for key, val in names.items()))
else:
self.logger.info("No sightings available at the moment...")
self.no_log_until = now + 120
self.destination = None
if self.config_enable_cooldown:
wait = uniform(120, 360)
self.no_hunt_until = now + wait
self.logger.info("Will look again around {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
self.last_cell_id = None
return WorkerResult.SUCCESS
# Make sure a VIP is treated that way
if self.config_lock_on_target and self.bot.hunter_locked_target is None and self.destination is not None:
if self._is_vip_pokemon(self.destination):
self.bot.hunter_locked_target = self.destination
#Check if we are treating Family of VIP as VIP
if self.config_treat_family_of_vip_as_vip and self.destination is not None:
if self._is_family_of_vip(self.destination):
# We're hunting for family, so we need to check if we find a VIP
if self.no_log_until < now:
# Not every tick please
possible_targets = filter(lambda p: self._is_vip_pokemon(p), pokemons)
# Update the distance to targets
for p in possible_targets:
p["distance"] = self.get_distance(self.bot.position, p)
possible_targets.sort(key=lambda p: p["distance"])
if len(possible_targets) > 0:
# Check if it's not the same mon...
if possible_targets[0]["name"] != self.destination["name"]:
self.logger.info("We found a real VIP while hunting for %(name)s", self.destination)
self.destination = possible_targets[0]
self.bot.hunter_locked_target = self.destination
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("New VIP target at %(distance).2f meters: %(name)s", self.destination)
self.set_target()
# We have a target
return WorkerResult.RUNNING
# Now we check if there is a VIP target closer by
if self.destination is not None and self.bot.hunter_locked_target is self.destination:
# Hunting a VIP, checking for closer VIP target
if self.no_log_until < now:
# Not every tick please
possible_targets = filter(lambda p: self._is_vip_pokemon(p), pokemons)
# Update the distance to targets
for p in possible_targets:
p["distance"] = self.get_distance(self.bot.position, p)
possible_targets.sort(key=lambda p: p["distance"])
# Check for a closer target
self.destination["distance"] = self.get_distance(self.bot.position, self.destination)
for pokemon in possible_targets:
if pokemon is not self.destination:
if round(pokemon["distance"], 2) >= round(self.destination["distance"], 2):
# further away!
break
with self.bot.database as conn:
c = conn.cursor()
c.execute(
"SELECT COUNT(pokemon) FROM catch_log where pokemon = '{}' and datetime(dated, 'localtime') > Datetime('{}')".format(pokemon["name"], self.hunt_started_at.strftime("%Y-%m-%d %H:%M:%S")))
# Now check if there is 1 or more caught
amount = c.fetchone()[0]
if amount > 0:
# We caught this pokemon recently, skip it
continue
if self.config_treat_family_of_vip_as_vip and self._is_family_of_vip(pokemon):
if self._is_vip_pokemon(self.destination):
self.logger.info("Seeing a familymember of a VIP at %(distance).2f meters: %(name)s", pokemon)
self.logger.info("Not hunting down because we are locked to a real VIP: %(name)s", self.destination)
continue
else:
self.logger.info("Closer (is distance) familymember of VIP found!")
self.logger.info("Found a closer VIP target: %s < %s" % (pokemon["distance"], self.destination["distance"]))
if self.destination is not None:
self.logger.info("Closer VIP hunt takes priority! Changing target...")
self.destination = pokemon
self.bot.hunter_locked_target = self.destination
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("New VIP target at %(distance).2f meters: %(name)s", self.destination)
self.set_target()
# We have a target
return WorkerResult.RUNNING
# Check if there is a VIP around to hunt
if (self.destination is not None and
self.config_lock_on_target and
self.config_lock_vip_only and
self.bot.hunter_locked_target is None):
worth_pokemons = self.get_worth_pokemons(pokemons)
# We have a none VIP target set, check for VIP targets!
if len(worth_pokemons) > 0:
for pokemon in worth_pokemons:
if self._is_vip_pokemon(pokemon):
self.hunting_trash = False
self.destination = pokemon
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.set_target()
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
self.logger.info("Spotted a VIP Pokemon! Looking for a %(name)s at %(distance).2f.", self.destination)
return WorkerResult.SUCCESS
if self.destination is None:
if self.no_log_until < now:
self.logger.info("Nothing to hunt.")
return WorkerResult.SUCCESS
if self.config_lock_on_target and not self.config_lock_vip_only:
if self.bot.hunter_locked_target == None:
self.logger.info("We found a %(name)s while hunting. Aborting the current search.", self.destination)
self.previous_destination = self.destination
self.destination = None
self.hunting_trash = False
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
# Determin if we are allowed to run to a VIP
different_target = False
if self.destination is not None:
if self.previous_destination is None:
self.previous_destination = self.destination
elif self.previous_destination is not self.destination:
different_target = True
self.previous_destination = self.destination
if self.config_run_to_vip and self._is_vip_pokemon(self.destination):
if self.runs_to_vips > 3:
self.logger.info("Ran to 3 Pokemon in a row. Cooling down...")
self.runs_to_vips = 0
speed = None
else:
speed = self.bot.config.walk_max
if different_target:
self.runs_to_vips += 1
else:
speed = None
if any(self.destination["encounter_id"] == p["encounter_id"] for p in self.bot.cell["catchable_pokemons"] + self.bot.cell["wild_pokemons"]):
self.destination = None
self.hunting_trash = False
elif self.walker.step(speed):
if not any(self.destination["encounter_id"] == p["encounter_id"] for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.logger.info("I haven't found %(name)s", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
self.hunting_trash = False
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
else:
self.logger.info("Now searching for %(name)s", self.destination)
if self.search_points == []:
self.walker = StepWalker(self.bot, self.destination['latitude'], self.destination['longitude'])
else:
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_points = self.search_points[1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
if round(distance, 2) == self.distance_to_target:
# Hmm, not moved toward the Pokemon?
self.distance_counter += 1
else:
self.distance_counter = 0
if self.distance_counter is 3:
# Try another walker
self.logger.info("Having difficulty walking to target, changing walker!")
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.distance_counter += 1
if self.distance_counter >= 6:
# Ignore last 3
if len(self.recent_tries) > 3:
self.recent_tries.pop()
self.recent_tries.append(self.destination['pokemon_id'])
self.logger.info("I cant move toward %(name)s! Aborting search.", self.destination)
self.hunting_trash = False
self.bot.hunter_locked_target = None
self.destination = None
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.ERROR
else:
unit = self.bot.config.distance_unit # Unit to use when printing formatted distance
if speed is not None:
self.emit_event(
'moving_to_hunter_target',
formatted="Running towards VIP target {target_name} - {distance}",
data={
'target_name': u"{}".format(self.destination["name"]),
'distance': format_dist(distance, unit),
}
)
else:
self.emit_event(
'moving_to_hunter_target',
formatted="Moving towards target {target_name} - {distance}",
data={
'target_name': u"{}".format(self.destination["name"]),
'distance': format_dist(distance, unit),
}
)
# self.logger.info("Moving to destination at %s meters: %s", round(distance, 2), self.destination["name"])
# record the new distance...
self.distance_to_target = round(distance, 2)
if self.config_lock_on_target and not self.config_lock_vip_only:
# Just to ensure we stay on target
self.bot.hunter_locked_target = self.destination
self.no_log_until = now + 5
return WorkerResult.RUNNING
def test_big_distances(self):
# FIXME currently the StepWalker acts like it won't move if big distances gives as input
# see args below
# with self.assertRaises(RuntimeError):
sw = StepWalker(self.bot, 10, 10)
sw.step() # equals True i.e act like the distance is too short for a step
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.config_disabled_while_camping and hasattr(
self.bot, 'camping_forts') and self.bot.camping_forts:
return WorkerResult.SUCCESS
if not self.config_lock_on_target:
self.bot.hunter_locked_target = None
if self.no_hunt_until != None and self.no_hunt_until > time.time():
# No hunting now, cooling down
return WorkerResult.SUCCESS
else:
# Resume hunting
self.no_hunt_until = None
if self.bot.catch_disabled:
if not hasattr(self.bot,"hunter_disabled_global_warning") or \
(hasattr(self.bot,"hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info(
"All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled"
.format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.bot.softban:
if not hasattr(self.bot, "softban_global_warning") or \
(hasattr(self.bot, "softban_global_warning") and not self.bot.softban_global_warning):
self.logger.info(
"Possible softban! Not trying to catch Pokemon.")
self.bot.softban_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.softban_global_warning = False
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.destination is not None:
if self.destination_caught():
self.logger.info(
"We found a %(name)s while hunting. Aborting the current search.",
self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
pokemons = filter(lambda x: x["pokemon_id"] not in self.recent_tries,
pokemons)
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
# Pick a random target from the list
random.shuffle(worth_pokemons)
# Prevents the bot from looping the same Pokemon
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info(
"New destination at %(distance).2f meters: %(name)s",
self.destination)
if self._is_vip_pokemon(self.destination):
self.logger.info("This is a VIP Pokemon! Starting hunt.")
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
elif self._is_needed_pokedex(self.destination):
self.logger.info(
"I need a %(name)s to complete the Pokedex! I have %(candies)s candies.",
self.destination)
if self.config_lock_on_target and not self.config_lock_vip_only:
self.bot.hunter_locked_target = self.destination
else:
self.bot.hunter_locked_target = None
self.no_log_until = now + 60
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(
self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot,
self.search_points[0][0],
self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[
1:] + self.search_points[:1]
else:
if self.no_log_until < now:
# Show like "Pidgey (12), Zubat(2)"
names = Counter((p["name"] for p in pokemons))
sorted(names) # unicode object, no lower? , key=str.lower)
self.logger.info(
"There is no nearby pokemon worth hunting down [%s]",
", ".join('{}({})'.format(key, val)
for key, val in names.items()))
self.no_log_until = now + 120
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Will look again around {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.config_lock_on_target and not self.config_lock_vip_only:
if self.bot.hunter_locked_target == None:
self.logger.info(
"We found a %(name)s while hunting. Aborting the current search.",
self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"]
for p in self.bot.cell["catchable_pokemons"] +
self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"]
for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.logger.info("I haven't found %(name)s", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
else:
self.logger.info("Now searching for %(name)s",
self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0],
self.search_points[0][1])
self.search_points = self.search_points[
1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(
self.bot.position,
(self.walker.dest_lat, self.walker.dest_lng)).meters
if round(distance, 2) == self.distance_to_target:
# Hmm, not moved toward the Pokemon?
self.distance_counter += 1
else:
self.distance_counter = 0
if self.distance_counter >= 3:
# Ignore last 3
if len(self.recent_tries) > 3:
self.recent_tries.pop()
self.recent_tries.append(self.destination['pokemon_id'])
self.logger.info(
"I cant move toward %(name)s! Aborting search.",
self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.ERROR
else:
self.logger.info("Moving to destination at %s meters: %s",
round(distance, 2), self.destination["name"])
# record the new distance...
self.distance_to_target = round(distance, 2)
if self.config_lock_on_target and not self.config_lock_vip_only:
# Just to ensure we stay on target
self.bot.hunter_locked_target = self.destination
self.no_log_until = now + 30
return WorkerResult.RUNNING
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.config_disabled_while_camping and hasattr(self.bot, 'camping_forts') and self.bot.camping_forts:
return WorkerResult.SUCCESS
if not self.config_lock_on_target:
self.bot.hunter_locked_target = None
if self.no_hunt_until != None and self.no_hunt_until > time.time():
# No hunting now, cooling down
return WorkerResult.SUCCESS
else:
# Resume hunting
self.no_hunt_until = None
if self.bot.catch_disabled:
if not hasattr(self.bot,"hunter_disabled_global_warning") or \
(hasattr(self.bot,"hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info("All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled".format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.destination is not None:
if self.destination_caught():
self.logger.info("We found a %(name)s while hunting. Aborting the current search.", self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
pokemons = filter(lambda x: x["pokemon_id"] not in self.recent_tries, pokemons)
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
# Pick a random target from the list
random.shuffle(worth_pokemons)
# Prevents the bot from looping the same Pokemon
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("New destination at %(distance).2f meters: %(name)s", self.destination)
if self._is_vip_pokemon(self.destination):
self.logger.info("This is a VIP Pokemon! Starting hunt.")
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
elif self._is_needed_pokedex(self.destination):
self.logger.info("I need a %(name)s to complete the Pokedex! I have %(candies)s candies.", self.destination)
if self.config_lock_on_target and not self.config_lock_vip_only:
self.bot.hunter_locked_target = self.destination
else:
self.bot.hunter_locked_target = None
self.no_log_until = now + 60
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[1:] + self.search_points[:1]
else:
if self.no_log_until < now:
# Show like "Pidgey (12), Zubat(2)"
names = Counter((p["name"] for p in pokemons))
sorted(names) # unicode object, no lower? , key=str.lower)
self.logger.info("There is no nearby pokemon worth hunting down [%s]", ", ".join('{}({})'.format(key, val) for key, val in names.items()))
self.no_log_until = now + 120
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Will look again around {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.config_lock_on_target and not self.config_lock_vip_only:
if self.bot.hunter_locked_target == None:
self.logger.info("We found a %(name)s while hunting. Aborting the current search.", self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"] for p in self.bot.cell["catchable_pokemons"] + self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"] for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.logger.info("I haven't found %(name)s", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
else:
self.logger.info("Now searching for %(name)s", self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_points = self.search_points[1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
if round(distance, 2) == self.distance_to_target:
# Hmm, not moved toward the Pokemon?
self.distance_counter += 1
else:
self.distance_counter = 0
if self.distance_counter >= 3:
# Ignore last 3
if len(self.recent_tries) > 3:
self.recent_tries.pop()
self.recent_tries.append(self.destination['pokemon_id'])
self.logger.info("I cant move toward %(name)s! Aborting search.", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.ERROR
else:
self.logger.info("Moving to destination at %s meters: %s", round(distance, 2), self.destination["name"])
# record the new distance...
self.distance_to_target = round(distance, 2)
if self.config_lock_on_target and not self.config_lock_vip_only:
# Just to ensure we stay on target
self.bot.hunter_locked_target = self.destination
self.no_log_until = now + 30
return WorkerResult.RUNNING
class PokemonHunter(BaseTask):
SUPPORTED_TASK_API_VERSION = 1
def __init__(self, bot, config):
super(PokemonHunter, self).__init__(bot, config)
def initialize(self):
self.notified_second_gen = []
self.destination = None
self.walker = None
self.search_cell_id = None
self.search_points = []
self.lost_counter = 0
self.no_log_until = 0
self.distance_to_target = 0
self.distance_counter = 0
self.recent_tries = []
self.no_hunt_until = None
self.hunt_started_at = None
self.config_max_distance = self.config.get("max_distance", 2000)
self.config_hunt_all = self.config.get("hunt_all", False)
self.config_hunt_vip = self.config.get("hunt_vip", True)
self.config_hunt_pokedex = self.config.get("hunt_pokedex", True)
# Lock on Target; ignore all other Pokémon until we found our target.
self.config_lock_on_target = self.config.get("lock_on_target", False)
# Lock only VIP Pokemon (unseen / VIP)
self.config_lock_vip_only = self.config.get("lock_vip_only", True)
# If we are camping forts, disable hunting (see CampFort)
self.config_disabled_while_camping = self.config.get("disabled_while_camping", True)
# Hunt unseens as VIP?
self.config_treat_unseen_as_vip = self.config.get("treat_unseen_as_vip", True)
self.bot.hunter_locked_target = None
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.config_disabled_while_camping and hasattr(self.bot, 'camping_forts') and self.bot.camping_forts:
return WorkerResult.SUCCESS
if not self.config_lock_on_target:
self.bot.hunter_locked_target = None
if self.no_hunt_until != None and self.no_hunt_until > time.time():
# No hunting now, cooling down
return WorkerResult.SUCCESS
else:
# Resume hunting
self.no_hunt_until = None
if self.bot.catch_disabled:
if not hasattr(self.bot,"hunter_disabled_global_warning") or \
(hasattr(self.bot,"hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info("All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled".format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.destination is not None:
if self.destination_caught():
self.logger.info("We found a %(name)s while hunting. Aborting the current search.", self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
pokemons = filter(lambda x: x["pokemon_id"] not in self.recent_tries, pokemons)
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
# Pick a random target from the list
random.shuffle(worth_pokemons)
# Prevents the bot from looping the same Pokemon
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("New destination at %(distance).2f meters: %(name)s", self.destination)
if self._is_vip_pokemon(self.destination):
self.logger.info("This is a VIP Pokemon! Starting hunt.")
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
elif self._is_needed_pokedex(self.destination):
self.logger.info("I need a %(name)s to complete the Pokedex! I have %(candies)s candies.", self.destination)
if self.config_lock_on_target and not self.config_lock_vip_only:
self.bot.hunter_locked_target = self.destination
else:
self.bot.hunter_locked_target = None
self.no_log_until = now + 60
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[1:] + self.search_points[:1]
else:
if self.no_log_until < now:
# Show like "Pidgey (12), Zubat(2)"
names = Counter((p["name"] for p in pokemons))
sorted(names) # unicode object, no lower? , key=str.lower)
self.logger.info("There is no nearby pokemon worth hunting down [%s]", ", ".join('{}({})'.format(key, val) for key, val in names.items()))
self.no_log_until = now + 120
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Will look again around {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.config_lock_on_target and not self.config_lock_vip_only:
if self.bot.hunter_locked_target == None:
self.logger.info("We found a %(name)s while hunting. Aborting the current search.", self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"] for p in self.bot.cell["catchable_pokemons"] + self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"] for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.logger.info("I haven't found %(name)s", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
else:
self.logger.info("Now searching for %(name)s", self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_points = self.search_points[1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
if round(distance, 2) == self.distance_to_target:
# Hmm, not moved toward the Pokemon?
self.distance_counter += 1
else:
self.distance_counter = 0
if self.distance_counter >= 3:
# Ignore last 3
if len(self.recent_tries) > 3:
self.recent_tries.pop()
self.recent_tries.append(self.destination['pokemon_id'])
self.logger.info("I cant move toward %(name)s! Aborting search.", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.ERROR
else:
self.logger.info("Moving to destination at %s meters: %s", round(distance, 2), self.destination["name"])
# record the new distance...
self.distance_to_target = round(distance, 2)
if self.config_lock_on_target and not self.config_lock_vip_only:
# Just to ensure we stay on target
self.bot.hunter_locked_target = self.destination
self.no_log_until = now + 30
return WorkerResult.RUNNING
def get_pokeball_count(self):
return sum([inventory.items().get(ball.value).count for ball in [Item.ITEM_POKE_BALL, Item.ITEM_GREAT_BALL, Item.ITEM_ULTRA_BALL]])
def get_nearby_pokemons(self):
radius = self.config_max_distance
pokemons = [p for p in self.bot.cell["nearby_pokemons"] if self.get_distance(self.bot.start_position, p) <= radius]
for pokemon in pokemons:
pokemon["distance"] = self.get_distance(self.bot.position, p)
pokemon["name"] = inventory.pokemons().name_for(pokemon["pokemon_id"])
pokemon["candies"] = inventory.candies().get(pokemon["pokemon_id"]).quantity
pokemons.sort(key=lambda p: p["distance"])
return pokemons
def _is_vip_pokemon(self, pokemon):
# having just a name present in the list makes them vip
# Not seen pokemons also will become vip if it's not disabled in config
if self.bot.config.vips.get(pokemon["name"]) == {} or (self.config_treat_unseen_as_vip and not inventory.pokedex().seen(pokemon["pokemon_id"])):
return True
def _is_needed_pokedex(self, pokemon):
candies = inventory.candies().get(pokemon["pokemon_id"]).quantity
if candies > 150:
# We have enough candies, pass on hunting this Pokemon
return False
# get family ids, gets ALL ids, also for previous evo!
# We could see a Ivysaur on the map, and need a Bulbasaur
# Then we have no need for a Ivysaur. If we see a Bulbasaur and need
# a Ivysaur, then we DO need this pokemon.
got_current_evo = False
ids = []
for fid in self.get_family_ids(pokemon):
if got_current_evo:
ids += [fid]
else:
if fid == pokemon["pokemon_id"]:
ids += [fid]
got_current_evo = True
# Check if we need this, or a next EVO in the Pokedex
if any(not inventory.pokedex().seen(fid) for fid in ids):
return True
def get_worth_pokemons(self, pokemons):
if self.config_hunt_all:
worth_pokemons = pokemons
else:
worth_pokemons = []
if self.config_hunt_vip:
worth_pokemons += [p for p in pokemons if p["name"] in self.bot.config.vips]
if self.config_hunt_pokedex:
worth_pokemons += [p for p in pokemons if (p not in worth_pokemons) and self._is_needed_pokedex(p)]
worth_pokemons.sort(key=lambda p: inventory.candies().get(p["pokemon_id"]).quantity)
return worth_pokemons
def get_family_ids(self, pokemon):
family_id = inventory.pokemons().data_for(pokemon["pokemon_id"]).first_evolution_id
ids = [family_id]
ids += inventory.pokemons().data_for(family_id).next_evolutions_all[:]
return ids
def get_distance(self, location, pokemon):
return great_circle(location, (pokemon["latitude"], pokemon["longitude"])).meters
def get_search_points(self, cell_id):
points = []
# For cell level 15
for c in Cell(CellId(cell_id)).subdivide():
for cc in c.subdivide():
latlng = LatLng.from_point(cc.get_center())
point = (latlng.lat().degrees, latlng.lng().degrees)
points.append(point)
points[0], points[1] = points[1], points[0]
points[14], points[15] = points[15], points[14]
point = points.pop(2)
points.insert(7, point)
point = points.pop(13)
points.insert(8, point)
closest = min(points, key=lambda p: great_circle(self.bot.position, p).meters)
index = points.index(closest)
return points[index:] + points[:index]
def destination_caught(self):
# self.logger.info("Searching for a {} since {}".format(self.destination["name"], self.hunt_started_at.strftime("%Y-%m-%d %H:%M:%S")))
with self.bot.database as conn:
c = conn.cursor()
c.execute(
"SELECT COUNT(pokemon) FROM catch_log where pokemon = '{}' and datetime(dated, 'localtime') > Datetime('{}')".format(self.destination["name"], self.hunt_started_at.strftime("%Y-%m-%d %H:%M:%S")))
# Now check if there is 1 or more caught
amount = c.fetchone()[0]
caught = amount > 0
if caught:
self.logger.info("We caught {} {}(s) since {}".format(amount, self.destination["name"], self.hunt_started_at.strftime("%Y-%m-%d %H:%M:%S")))
return caught
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.bot.catch_disabled:
if not hasattr(self.bot,"hunter_disabled_global_warning") or \
(hasattr(self.bot,"hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info(
"All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled"
.format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.logger.info(
"New destination at %(distance).2f meters: %(name)s",
self.destination)
self.no_log_until = now + 60
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(
self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot,
self.search_points[0][0],
self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[
1:] + self.search_points[:1]
else:
if self.no_log_until < now:
self.logger.info(
"There is no nearby pokemon worth hunting down [%s]",
", ".join(p["name"] for p in pokemons))
self.no_log_until = now + 120
self.last_cell_id = None
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"]
for p in self.bot.cell["catchable_pokemons"] +
self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"]
for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.destination = None
else:
self.logger.info("Now searching for %(name)s",
self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0],
self.search_points[0][1])
self.search_points = self.search_points[
1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(
self.bot.position,
(self.walker.dest_lat, self.walker.dest_lng)).meters
self.logger.info("Moving to destination at %s meters: %s",
round(distance, 2), self.destination["name"])
self.no_log_until = now + 30
return WorkerResult.RUNNING
class PokemonHunter(BaseTask):
SUPPORTED_TASK_API_VERSION = 1
def __init__(self, bot, config):
super(PokemonHunter, self).__init__(bot, config)
def initialize(self):
self.destination = None
self.walker = None
self.search_cell_id = None
self.search_points = []
self.lost_counter = 0
self.no_log_until = 0
self.config_max_distance = self.config.get("max_distance", 2000)
self.config_hunt_all = self.config.get("hunt_all", False)
self.config_hunt_vip = self.config.get("hunt_vip", True)
self.config_hunt_pokedex = self.config.get("hunt_pokedex", True)
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.logger.info("New destination at %(distance).2f meters: %(name)s", self.destination)
self.no_log_until = now + 60
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[1:] + self.search_points[:1]
else:
if self.no_log_until < now:
self.logger.info("There is no nearby pokemon worth hunting down [%s]", ", ".join(p["name"] for p in pokemons))
self.no_log_until = now + 120
self.last_cell_id = None
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"] for p in self.bot.cell["catchable_pokemons"] + self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"] for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.destination = None
else:
self.logger.info("Now searching for %(name)s", self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_points = self.search_points[1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
self.logger.info("Moving to destination at %s meters: %s", round(distance, 2), self.destination["name"])
self.no_log_until = now + 30
return WorkerResult.RUNNING
def get_pokeball_count(self):
return sum([inventory.items().get(ball.value).count for ball in [Item.ITEM_POKE_BALL, Item.ITEM_GREAT_BALL, Item.ITEM_ULTRA_BALL]])
def get_nearby_pokemons(self):
radius = self.config_max_distance
pokemons = [p for p in self.bot.cell["nearby_pokemons"] if self.get_distance(self.bot.start_position, p) <= radius]
for pokemon in pokemons:
pokemon["distance"] = self.get_distance(self.bot.position, p)
pokemon["name"] = inventory.pokemons().name_for(pokemon["pokemon_id"])
pokemons.sort(key=lambda p: p["distance"])
return pokemons
def get_worth_pokemons(self, pokemons):
if self.config_hunt_all:
worth_pokemons = pokemons
else:
worth_pokemons = []
if self.config_hunt_vip:
worth_pokemons += [p for p in pokemons if p["name"] in self.bot.config.vips]
if self.config_hunt_pokedex:
worth_pokemons += [p for p in pokemons if (p not in worth_pokemons) and any(not inventory.pokedex().seen(fid) for fid in self.get_family_ids(p))]
worth_pokemons.sort(key=lambda p: inventory.candies().get(p["pokemon_id"]).quantity)
return worth_pokemons
def get_family_ids(self, pokemon):
family_id = inventory.pokemons().data_for(pokemon["pokemon_id"]).first_evolution_id
ids = [family_id]
ids += inventory.pokemons().data_for(family_id).next_evolutions_all[:]
return ids
def get_distance(self, location, pokemon):
return great_circle(location, (pokemon["latitude"], pokemon["longitude"])).meters
def get_search_points(self, cell_id):
points = []
# For cell level 15
for c in Cell(CellId(cell_id)).subdivide():
for cc in c.subdivide():
latlng = LatLng.from_point(cc.get_center())
point = (latlng.lat().degrees, latlng.lng().degrees)
points.append(point)
points[0], points[1] = points[1], points[0]
points[14], points[15] = points[15], points[14]
point = points.pop(2)
points.insert(7, point)
point = points.pop(13)
points.insert(8, point)
closest = min(points, key=lambda p: great_circle(self.bot.position, p).meters)
index = points.index(closest)
return points[index:] + points[:index]
class PokemonHunter(BaseTask):
SUPPORTED_TASK_API_VERSION = 1
def __init__(self, bot, config):
super(PokemonHunter, self).__init__(bot, config)
def initialize(self):
self.notified_second_gen = []
self.destination = None
self.walker = None
self.search_cell_id = None
self.search_points = []
self.lost_counter = 0
self.no_log_until = 0
self.distance_to_target = 0
self.distance_counter = 0
self.recent_tries = []
self.no_hunt_until = None
self.hunt_started_at = None
self.config_max_distance = self.config.get("max_distance", 2000)
self.config_hunt_all = self.config.get("hunt_all", False)
self.config_hunt_vip = self.config.get("hunt_vip", True)
self.config_hunt_pokedex = self.config.get("hunt_pokedex", True)
# Lock on Target; ignore all other Pokémon until we found our target.
self.config_lock_on_target = self.config.get("lock_on_target", False)
# Lock only VIP Pokemon (unseen / VIP)
self.config_lock_vip_only = self.config.get("lock_vip_only", True)
# If we are camping forts, disable hunting (see CampFort)
self.config_disabled_while_camping = self.config.get(
"disabled_while_camping", True)
# Hunt unseens as VIP?
self.config_treat_unseen_as_vip = self.config.get(
"treat_unseen_as_vip", True)
self.bot.hunter_locked_target = None
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.config_disabled_while_camping and hasattr(
self.bot, 'camping_forts') and self.bot.camping_forts:
return WorkerResult.SUCCESS
if not self.config_lock_on_target:
self.bot.hunter_locked_target = None
if self.no_hunt_until != None and self.no_hunt_until > time.time():
# No hunting now, cooling down
return WorkerResult.SUCCESS
else:
# Resume hunting
self.no_hunt_until = None
if self.bot.catch_disabled:
if not hasattr(self.bot,"hunter_disabled_global_warning") or \
(hasattr(self.bot,"hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info(
"All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled"
.format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.bot.softban:
if not hasattr(self.bot, "softban_global_warning") or \
(hasattr(self.bot, "softban_global_warning") and not self.bot.softban_global_warning):
self.logger.info(
"Possible softban! Not trying to catch Pokemon.")
self.bot.softban_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.softban_global_warning = False
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.destination is not None:
if self.destination_caught():
self.logger.info(
"We found a %(name)s while hunting. Aborting the current search.",
self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
pokemons = filter(lambda x: x["pokemon_id"] not in self.recent_tries,
pokemons)
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
# Pick a random target from the list
random.shuffle(worth_pokemons)
# Prevents the bot from looping the same Pokemon
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info(
"New destination at %(distance).2f meters: %(name)s",
self.destination)
if self._is_vip_pokemon(self.destination):
self.logger.info("This is a VIP Pokemon! Starting hunt.")
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
elif self._is_needed_pokedex(self.destination):
self.logger.info(
"I need a %(name)s to complete the Pokedex! I have %(candies)s candies.",
self.destination)
if self.config_lock_on_target and not self.config_lock_vip_only:
self.bot.hunter_locked_target = self.destination
else:
self.bot.hunter_locked_target = None
self.no_log_until = now + 60
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(
self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot,
self.search_points[0][0],
self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[
1:] + self.search_points[:1]
else:
if self.no_log_until < now:
# Show like "Pidgey (12), Zubat(2)"
names = Counter((p["name"] for p in pokemons))
sorted(names) # unicode object, no lower? , key=str.lower)
self.logger.info(
"There is no nearby pokemon worth hunting down [%s]",
", ".join('{}({})'.format(key, val)
for key, val in names.items()))
self.no_log_until = now + 120
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Will look again around {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
self.last_cell_id = None
return WorkerResult.SUCCESS
if self.config_lock_on_target and not self.config_lock_vip_only:
if self.bot.hunter_locked_target == None:
self.logger.info(
"We found a %(name)s while hunting. Aborting the current search.",
self.destination)
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"]
for p in self.bot.cell["catchable_pokemons"] +
self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"]
for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.logger.info("I haven't found %(name)s", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
else:
self.logger.info("Now searching for %(name)s",
self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0],
self.search_points[0][1])
self.search_points = self.search_points[
1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(
self.bot.position,
(self.walker.dest_lat, self.walker.dest_lng)).meters
if round(distance, 2) == self.distance_to_target:
# Hmm, not moved toward the Pokemon?
self.distance_counter += 1
else:
self.distance_counter = 0
if self.distance_counter >= 3:
# Ignore last 3
if len(self.recent_tries) > 3:
self.recent_tries.pop()
self.recent_tries.append(self.destination['pokemon_id'])
self.logger.info(
"I cant move toward %(name)s! Aborting search.",
self.destination)
self.bot.hunter_locked_target = None
self.destination = None
wait = uniform(120, 600)
self.no_hunt_until = now + wait
self.logger.info("Hunting on cooldown until {}.".format(
(datetime.now() +
timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.ERROR
else:
self.logger.info("Moving to destination at %s meters: %s",
round(distance, 2), self.destination["name"])
# record the new distance...
self.distance_to_target = round(distance, 2)
if self.config_lock_on_target and not self.config_lock_vip_only:
# Just to ensure we stay on target
self.bot.hunter_locked_target = self.destination
self.no_log_until = now + 30
return WorkerResult.RUNNING
def get_pokeball_count(self):
return sum([
inventory.items().get(ball.value).count for ball in
[Item.ITEM_POKE_BALL, Item.ITEM_GREAT_BALL, Item.ITEM_ULTRA_BALL]
])
def get_nearby_pokemons(self):
radius = self.config_max_distance
pokemons = [
p for p in self.bot.cell["nearby_pokemons"]
if self.get_distance(self.bot.start_position, p) <= radius
]
for pokemon in pokemons:
pokemon["distance"] = self.get_distance(self.bot.position, p)
pokemon["name"] = inventory.pokemons().name_for(
pokemon["pokemon_id"])
pokemon["candies"] = inventory.candies().get(
pokemon["pokemon_id"]).quantity
pokemons.sort(key=lambda p: p["distance"])
return pokemons
def _is_vip_pokemon(self, pokemon):
# having just a name present in the list makes them vip
# Not seen pokemons also will become vip if it's not disabled in config
if self.bot.config.vips.get(pokemon["name"]) == {} or (
self.config_treat_unseen_as_vip
and not inventory.pokedex().seen(pokemon["pokemon_id"])):
return True
def _is_needed_pokedex(self, pokemon):
candies = inventory.candies().get(pokemon["pokemon_id"]).quantity
if candies > 150:
# We have enough candies, pass on hunting this Pokemon
return False
# get family ids, gets ALL ids, also for previous evo!
# We could see a Ivysaur on the map, and need a Bulbasaur
# Then we have no need for a Ivysaur. If we see a Bulbasaur and need
# a Ivysaur, then we DO need this pokemon.
got_current_evo = False
ids = []
for fid in self.get_family_ids(pokemon):
if got_current_evo:
ids += [fid]
else:
if fid == pokemon["pokemon_id"]:
ids += [fid]
got_current_evo = True
# Check if we need this, or a next EVO in the Pokedex
if any(not inventory.pokedex().seen(fid) for fid in ids):
return True
def get_worth_pokemons(self, pokemons):
if self.config_hunt_all:
worth_pokemons = pokemons
else:
worth_pokemons = []
if self.config_hunt_vip:
worth_pokemons += [
p for p in pokemons if p["name"] in self.bot.config.vips
]
if self.config_hunt_pokedex:
worth_pokemons += [
p for p in pokemons
if (p not in worth_pokemons) and self._is_needed_pokedex(p)
]
worth_pokemons.sort(
key=lambda p: inventory.candies().get(p["pokemon_id"]).quantity)
return worth_pokemons
def get_family_ids(self, pokemon):
family_id = inventory.pokemons().data_for(
pokemon["pokemon_id"]).first_evolution_id
ids = [family_id]
ids += inventory.pokemons().data_for(family_id).next_evolutions_all[:]
return ids
def get_distance(self, location, pokemon):
return great_circle(location,
(pokemon["latitude"], pokemon["longitude"])).meters
def get_search_points(self, cell_id):
points = []
# For cell level 15
for c in Cell(CellId(cell_id)).subdivide():
for cc in c.subdivide():
latlng = LatLng.from_point(cc.get_center())
point = (latlng.lat().degrees, latlng.lng().degrees)
points.append(point)
points[0], points[1] = points[1], points[0]
points[14], points[15] = points[15], points[14]
point = points.pop(2)
points.insert(7, point)
point = points.pop(13)
points.insert(8, point)
closest = min(points,
key=lambda p: great_circle(self.bot.position, p).meters)
index = points.index(closest)
return points[index:] + points[:index]
def destination_caught(self):
# self.logger.info("Searching for a {} since {}".format(self.destination["name"], self.hunt_started_at.strftime("%Y-%m-%d %H:%M:%S")))
with self.bot.database as conn:
c = conn.cursor()
c.execute(
"SELECT COUNT(pokemon) FROM catch_log where pokemon = '{}' and datetime(dated, 'localtime') > Datetime('{}')"
.format(self.destination["name"],
self.hunt_started_at.strftime("%Y-%m-%d %H:%M:%S")))
# Now check if there is 1 or more caught
amount = c.fetchone()[0]
caught = amount > 0
if caught:
self.logger.info("We caught {} {}(s) since {}".format(
amount, self.destination["name"],
self.hunt_started_at.strftime("%Y-%m-%d %H:%M:%S")))
return caught
def work(self):
forts = self.bot.get_forts()
log_lure_avail_str = ''
log_lured_str = ''
if self.lured:
lured_forts = [x for x in forts if 'active_fort_modifier' in x]
if len(lured_forts) > 0:
log_lured_str = 'lured '
self.dest = find_biggest_cluster(self.radius, lured_forts,
'9QM=')
else:
log_lure_avail_str = 'No lured pokestops in vicinity. Search for normal ones instead. '
self.dest = find_biggest_cluster(self.radius, forts)
else:
self.dest = find_biggest_cluster(self.radius, forts)
if self.dest is not None:
lat = self.dest['latitude']
lng = self.dest['longitude']
cnt = self.dest['num_points']
if not self.is_at_destination:
msg = log_lure_avail_str + (
"Move to cluster: {num_points} {forts} "
"pokestops will be in range of {radius}. Walking {distance}m."
)
self.emit_event('found_cluster',
formatted=msg,
data={
'num_points':
cnt,
'forts':
log_lured_str,
'radius':
str(self.radius),
'distance':
str(
round(
distance(self.bot.position[0],
self.bot.position[1], lat,
lng), 2))
})
self.announced = False
step_walker = StepWalker(self.bot, lat, lng)
self.is_at_destination = False
if step_walker.step():
self.is_at_destination = True
elif not self.announced:
self.emit_event(
'arrived_at_cluster',
formatted=
"Arrived at cluster. {num_points} {forts} pokestops are in a range of {radius}m radius.",
data={
'num_points': cnt,
'forts': log_lured_str,
'radius': self.radius
})
self.announced = True
else:
lat = self.bot.position[0]
lng = self.bot.position[1]
return [lat, lng]
def work(self):
forts = self.bot.get_forts()
log_lure_avail_str = ''
log_lured_str = ''
if self.lured:
lured_forts = [x for x in forts if 'active_fort_modifier' in x]
if len(lured_forts) > 0:
log_lured_str = 'lured '
self.dest = find_biggest_cluster(self.radius, lured_forts, '9QM=')
else:
log_lure_avail_str = 'No lured pokestops in vicinity. Search for normal ones instead. '
self.dest = find_biggest_cluster(self.radius, forts)
else:
self.dest = find_biggest_cluster(self.radius, forts)
if self.dest is not None:
lat = self.dest['latitude']
lng = self.dest['longitude']
cnt = self.dest['num_points']
if not self.is_at_destination:
msg = log_lure_avail_str + (
"Move to cluster: {num_points} {forts} "
"pokestops will be in range of {radius}. Walking {distance}m."
)
self.emit_event(
'found_cluster',
formatted=msg,
data={
'num_points': cnt,
'forts': log_lured_str,
'radius': str(self.radius),
'distance': str(round(distance(self.bot.position[0], self.bot.position[1], lat, lng), 2))
}
)
self.announced = False
if self.bot.config.walk_max > 0:
step_walker = StepWalker(
self.bot,
lat,
lng
)
self.is_at_destination = False
if step_walker.step():
self.is_at_destination = True
else:
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
self.bot.api.set_position(lat, lng, alt)
elif not self.announced:
self.emit_event(
'arrived_at_cluster',
formatted="Arrived at cluster. {num_points} {forts} pokestops are in a range of {radius}m radius.",
data={
'num_points': cnt,
'forts': log_lured_str,
'radius': self.radius
}
)
self.announced = True
else:
lat = self.bot.position[0]
lng = self.bot.position[1]
return [lat, lng]
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'])
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
if 'alt' in point:
alt = float(point['alt'])
if self.bot.config.walk_max > 0:
step_walker = StepWalker(
self.bot,
lat,
lng
)
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 not self.enabled:
return WorkerResult.SUCCESS
if self.bot.catch_disabled:
# When catching is disabled, drop the target.
if self.destination is not None:
self.destination = None
self.last_cell_id = None
if not hasattr(self.bot, "hunter_disabled_global_warning") or \
(hasattr(self.bot, "hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info("All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled".format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.bot.softban:
# At softban, drop target
if self.destination is not None:
self.destination = None
self.last_cell_id = None
self.hunting_trash = False
if not hasattr(self.bot, "softban_global_warning") or \
(hasattr(self.bot, "softban_global_warning") and not self.bot.softban_global_warning):
self.logger.info("Possible softban! Not trying to catch Pokemon.")
self.bot.softban_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.softban_global_warning = False
if self.config_disabled_while_camping and hasattr(self.bot, 'camping_forts') and self.bot.camping_forts:
return WorkerResult.SUCCESS
if not self.config_lock_on_target:
self.bot.hunter_locked_target = None
if self.no_hunt_until != None and self.no_hunt_until > time.time():
# No hunting now, cooling down
return WorkerResult.SUCCESS
else:
# Resume hunting
self.no_hunt_until = None
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
self.hunting_trash = False
return WorkerResult.SUCCESS
if self.destination is not None:
if self.destination_caught():
self.logger.info("We found a %(name)s while hunting.", self.destination)
self.recent_tries.append(self.destination['pokemon_id'])
self.destination = None
self.hunting_trash = False
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
else:
self.logger.info("Electing new target....")
if self.destination_vanished():
self.logger.info("Darn, target got away!")
self.recent_tries.append(self.destination['pokemon_id'])
self.destination = None
self.hunting_trash = False
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
else:
self.logger.info("Electing new target....")
now = time.time()
pokemons = self.get_nearby_pokemons()
pokemons = filter(lambda x: x["pokemon_id"] not in self.recent_tries, pokemons)
if self.config_hunt_for_trash and self.hunting_trash is False and (self.destination is None or self._is_vip_pokemon(self.destination) is False ):
# Okay, we should hunt for trash if the bag is almost full
trash_mons = ["Caterpie", "Weedle", "Pidgey", "Pidgeotto", "Pidgeot", "Kakuna", "Beedrill", "Metapod", "Butterfree"]
if self.pokemon_slots_left() <= self.config_trash_hunt_open_slots:
if self.no_log_until < now:
self.logger.info("Less than %s slots left to fill, starting hunt for trash" % elf.config_trash_hunt_open_slots)
for pokemon in pokemons:
if pokemon["name"] in trash_mons:
self.hunting_trash = True
self.destination = pokemon
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("Hunting for trash at %(distance).2f meters: %(name)s", self.destination)
self.set_target()
# We have a target
return WorkerResult.SUCCESS
if self.config_hunt_for_trash and self.hunting_trash:
if self.pokemon_slots_left() > 20:
self.logger.info("No longer trying to fill the bag. Electing new target....")
self.hunting_trash = False
self.destination = None
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons, self.config_hunt_closest_first)
if len(worth_pokemons) > 0:
# Pick a random target from the list
# random.shuffle(worth_pokemons)
# Priotize closer pokemon
worth_pokemons.sort(key=lambda p: p["distance"])
# Prevents the bot from looping the same Pokemon
self.destination = worth_pokemons[0]
self.set_target()
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.logger.info("New destination at %(distance).2f meters: %(name)s", self.destination)
if self._is_vip_pokemon(self.destination):
self.logger.info("This is a VIP Pokemon! Starting hunt.")
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
elif self._is_needed_pokedex(self.destination):
self.logger.info("I need a %(name)s to complete the Pokedex! I have %(candies)s candies.", self.destination)
if self.config_lock_on_target and not self.config_lock_vip_only:
self.bot.hunter_locked_target = self.destination
else:
self.bot.hunter_locked_target = None
self.no_log_until = now + 60
# We have a target
return WorkerResult.SUCCESS
else:
if self.no_log_until < now:
# Show like "Pidgey (12), Zubat(2)"
names = Counter((p["name"] for p in pokemons))
sorted(names) # unicode object, no lower? , key=str.lower)
self.logger.info("There is no nearby pokemon worth hunting down [%s]", ", ".join('{}({})'.format(key, val) for key, val in names.items()))
self.no_log_until = now + 120
self.destination = None
if self.config_enable_cooldown:
wait = uniform(120, 360)
self.no_hunt_until = now + wait
self.logger.info("Will look again around {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
self.last_cell_id = None
return WorkerResult.SUCCESS
# Make sure a VIP is treated that way
if self.config_lock_on_target and self.destination is not None:
if self._is_vip_pokemon(self.destination) and self.bot.hunter_locked_target is None:
self.bot.hunter_locked_target = self.destination
# Check if there is a VIP around to hunt
if (self.destination is not None and
self.config_lock_on_target and
self.config_lock_vip_only and
self.bot.hunter_locked_target is None):
worth_pokemons = self.get_worth_pokemons(pokemons)
# We have a none VIP target set, check for VIP targets!
if len(worth_pokemons) > 0:
for pokemon in worth_pokemons:
if self._is_vip_pokemon(pokemon):
self.hunting_trash = False
self.destination = pokemon
self.lost_counter = 0
self.hunt_started_at = datetime.now()
self.set_target()
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
self.logger.info("Found a VIP Pokemon! Looking for a %(name)s at %(distance).2f.", self.destination)
return WorkerResult.SUCCESS
pass
if self.destination is None:
if self.no_log_until < now:
self.logger.info("Nothing to hunt.")
return WorkerResult.SUCCESS
if self.config_lock_on_target and not self.config_lock_vip_only:
if self.bot.hunter_locked_target == None:
self.logger.info("We found a %(name)s while hunting. Aborting the current search.", self.destination)
self.destination = None
self.hunting_trash = False
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"] for p in self.bot.cell["catchable_pokemons"] + self.bot.cell["wild_pokemons"]):
self.destination = None
self.hunting_trash = False
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"] for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.logger.info("I haven't found %(name)s", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
self.hunting_trash = False
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
else:
self.logger.info("Now searching for %(name)s", self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_points = self.search_points[1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
if round(distance, 2) == self.distance_to_target:
# Hmm, not moved toward the Pokemon?
self.distance_counter += 1
else:
self.distance_counter = 0
if self.distance_counter >= 3:
# Ignore last 3
if len(self.recent_tries) > 3:
self.recent_tries.pop()
self.recent_tries.append(self.destination['pokemon_id'])
self.logger.info("I cant move toward %(name)s! Aborting search.", self.destination)
self.hunting_trash = False
self.bot.hunter_locked_target = None
self.destination = None
if self.config_enable_cooldown:
wait = uniform(120, 600)
self.no_hunt_until = time.time() + wait
self.logger.info("Hunting on cooldown until {}.".format((datetime.now() + timedelta(seconds=wait)).strftime("%H:%M:%S")))
return WorkerResult.ERROR
else:
self.logger.info("Moving to destination at %s meters: %s", round(distance, 2), self.destination["name"])
# record the new distance...
self.distance_to_target = round(distance, 2)
if self.config_lock_on_target and not self.config_lock_vip_only:
# Just to ensure we stay on target
self.bot.hunter_locked_target = self.destination
self.no_log_until = now + 30
return WorkerResult.RUNNING
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
if self.bot.catch_disabled:
if not hasattr(self.bot,"hunter_disabled_global_warning") or \
(hasattr(self.bot,"hunter_disabled_global_warning") and not self.bot.hunter_disabled_global_warning):
self.logger.info("All catching tasks are currently disabled until {}. Pokemon Hunter will resume when catching tasks are re-enabled".format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.hunter_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.hunter_disabled_global_warning = False
if self.get_pokeball_count() <= 0:
self.destination = None
self.last_cell_id = None
return WorkerResult.SUCCESS
now = time.time()
pokemons = self.get_nearby_pokemons()
if self.destination is None:
worth_pokemons = self.get_worth_pokemons(pokemons)
if len(worth_pokemons) > 0:
self.destination = worth_pokemons[0]
self.lost_counter = 0
self.logger.info("New destination at %(distance).2f meters: %(name)s", self.destination)
self.no_log_until = now + 60
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
if self.destination["s2_cell_id"] != self.search_cell_id:
self.search_points = self.get_search_points(self.destination["s2_cell_id"])
self.walker = PolylineWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_cell_id = self.destination["s2_cell_id"]
self.search_points = self.search_points[1:] + self.search_points[:1]
else:
if self.no_log_until < now:
self.logger.info("There is no nearby pokemon worth hunting down [%s]", ", ".join(p["name"] for p in pokemons))
self.no_log_until = now + 120
self.last_cell_id = None
return WorkerResult.SUCCESS
if any(self.destination["encounter_id"] == p["encounter_id"] for p in self.bot.cell["catchable_pokemons"] + self.bot.cell["wild_pokemons"]):
self.destination = None
elif self.walker.step():
if not any(self.destination["encounter_id"] == p["encounter_id"] for p in pokemons):
self.lost_counter += 1
else:
self.lost_counter = 0
if self.lost_counter >= 3:
self.logger.info("I haven't found %(name)s", self.destination)
self.bot.hunter_locked_target = None
self.destination = None
else:
self.logger.info("Now searching for %(name)s", self.destination)
self.walker = StepWalker(self.bot, self.search_points[0][0], self.search_points[0][1])
self.search_points = self.search_points[1:] + self.search_points[:1]
elif self.no_log_until < now:
distance = great_circle(self.bot.position, (self.walker.dest_lat, self.walker.dest_lng)).meters
self.logger.info("Moving to destination at %s meters: %s", round(distance, 2), self.destination["name"])
if self.config_lock_on_target:
self.bot.hunter_locked_target = self.destination
self.no_log_until = now + 30
return WorkerResult.RUNNING