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
)
if dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE:
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="Di chuyen toi pokestop {fort_name} - {distance}",
data=fort_event_data
)
else:
self.emit_event(
'moving_to_fort',
formatted="Di chuyen toi pokestop {fort_name} - {distance}",
data=fort_event_data
)
step_walker = StepWalker(
self.bot,
self.bot.config.walk,
lat,
lng
)
if not step_walker.step():
return WorkerResult.RUNNING
self.emit_event(
'arrived_at_fort',
formatted='Arrived at fort.'
)
return WorkerResult.SUCCESS
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 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
)
if dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE:
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 = StepWalker(
self.bot,
lat,
lng
)
if not step_walker.step():
return WorkerResult.RUNNING
self.emit_event(
'arrived_at_fort',
formatted='Arrived at fort.'
)
return WorkerResult.SUCCESS
def get_lured_pokemon(self):
forts_in_range = []
forts = self.bot.get_forts(order_by_distance=False)
if len(forts) == 0:
return []
for fort in forts:
distance_to_fort = distance(
self.bot.position[0],
self.bot.position[1],
fort['latitude'],
fort['longitude']
)
# See if we have an encounter at this fort
encounter_id = fort.get('lure_info', {}).get('encounter_id', None)
if distance_to_fort < Constants.MAX_DISTANCE_FORT_IS_REACHABLE and encounter_id:
forts_in_range.append(fort)
for fort in forts_in_range:
details = fort_details(self.bot, fort_id=fort['id'],
latitude=fort['latitude'],
longitude=fort['longitude'])
fort_name = details.get('name', 'Unknown')
encounter_id = fort['lure_info']['encounter_id']
pokemon = {
'encounter_id': encounter_id,
'fort_id': fort['id'],
'fort_name': u"{}".format(fort_name),
'latitude': fort['latitude'],
'longitude': fort['longitude']
}
self.emit_event(
'lured_pokemon_found',
level='info',
formatted='Lured pokemon at fort {fort_name} ({fort_id})',
data=pokemon
)
self.add_pokemon(pokemon)
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').encode('utf8', 'replace')
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:
if self.is_attracted() > 0:
add_str = ' (attraction of lure {})'.format(format_dist(self.lure_distance, unit))
else:
add_str = ''
logger.log('Moving towards fort {}, {} left{}'.format(fort_name, format_dist(dist, unit), add_str))
step_walker = StepWalker(
self.bot,
self.bot.config.walk,
lat,
lng
)
if not step_walker.step():
return WorkerResult.RUNNING
logger.log('Arrived at pokestop.')
return WorkerResult.SUCCESS
def get_lured_pokemon(self):
forts_in_range = []
pokemon_to_catch = []
forts = self.bot.get_forts(order_by_distance=True)
if len(forts) == 0:
return []
for fort in forts:
distance_to_fort = distance(
self.bot.position[0],
self.bot.position[1],
fort['latitude'],
fort['longitude']
)
encounter_id = fort.get('lure_info', {}).get('encounter_id', None)
if distance_to_fort < Constants.MAX_DISTANCE_FORT_IS_REACHABLE and encounter_id:
forts_in_range.append(fort)
for fort in forts_in_range:
details = fort_details(self.bot, fort_id=fort['id'],
latitude=fort['latitude'],
longitude=fort['longitude'])
fort_name = details.get('name', 'Unknown')
encounter_id = fort['lure_info']['encounter_id']
result = {
'encounter_id': encounter_id,
'fort_id': fort['id'],
'fort_name': u"{}".format(fort_name),
'latitude': fort['latitude'],
'longitude': fort['longitude']
}
pokemon_to_catch.append(result)
self.emit_event(
'lured_pokemon_found',
level='info',
formatted='Lured pokemon at fort {fort_name} ({fort_id})',
data=result
)
return pokemon_to_catch
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)
if dist > Constants.MAX_DISTANCE_FORT_IS_REACHABLE:
fort_event_data = {"fort_name": "{}".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 = StepWalker(self.bot, self.bot.config.walk, lat, lng)
if not step_walker.step():
return WorkerResult.RUNNING
self.emit_event("arrived_at_fort", formatted="Arrived at fort.")
return WorkerResult.SUCCESS
def work(self):
forts = self.get_forts_in_range()
if not self.should_run() or len(forts) == 0:
return WorkerResult.SUCCESS
fort = forts[0]
lat = fort['latitude']
lng = fort['longitude']
details = fort_details(self.bot, fort['id'], lat, lng)
fort_name = details.get('name', 'Unknown')
response_dict = self.bot.api.fort_search(
fort_id=fort['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.bot.position[0]),
player_longitude=f2i(self.bot.position[1]))
if ('responses' in response_dict) and ('FORT_SEARCH'
in response_dict['responses']):
spin_details = response_dict['responses']['FORT_SEARCH']
spin_result = spin_details.get('result', -1)
if (spin_result == SPIN_REQUEST_RESULT_SUCCESS) or (
spin_result == SPIN_REQUEST_RESULT_INVENTORY_FULL):
self.bot.softban = False
experience_awarded = spin_details.get('experience_awarded', 0)
items_awarded = self.get_items_awarded_from_fort_spinned(
response_dict)
egg_awarded = spin_details.get('pokemon_data_egg', None)
if egg_awarded is not None:
items_awarded[u'Egg'] = egg_awarded['egg_km_walked_target']
if experience_awarded or items_awarded:
awards = ', '.join([
"{}x {}".format(items_awarded[x], x)
for x in items_awarded if x != u'Egg'
])
if egg_awarded is not None:
awards += u', {} Egg'.format(
egg_awarded['egg_km_walked_target'])
self.emit_event(
'spun_pokestop',
formatted=
"Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}",
data={
'pokestop': fort_name,
'exp': experience_awarded,
'items': awards
})
else:
self.emit_event(
'pokestop_empty',
formatted='Found nothing in pokestop {pokestop}.',
data={'pokestop': fort_name})
with self.bot.database as conn:
c = conn.cursor()
c.execute(
"SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='pokestop_log'"
)
result = c.fetchone()
c.execute(
"SELECT DISTINCT COUNT(pokestop) FROM pokestop_log WHERE dated >= datetime('now','-1 day')"
)
if c.fetchone()[0] >= self.config.get('daily_spin_limit',
2000):
self.emit_event(
'spin_limit',
formatted=
'WARNING! You have reached your daily spin limit')
sys.exit(2)
while True:
if result[0] == 1:
conn.execute(
'''INSERT INTO pokestop_log (pokestop, exp, items) VALUES (?, ?, ?)''',
(fort_name, str(experience_awarded),
str(items_awarded)))
break
else:
self.emit_event(
'pokestop_log',
sender=self,
level='info',
formatted=
"pokestop_log table not found, skipping log")
break
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
self.bot.recent_forts = self.bot.recent_forts[1:] + [
fort['id']
]
elif spin_result == SPIN_REQUEST_RESULT_OUT_OF_RANGE:
self.emit_event('pokestop_out_of_range',
formatted="Pokestop {pokestop} out of range.",
data={'pokestop': fort_name})
elif spin_result == SPIN_REQUEST_RESULT_IN_COOLDOWN_PERIOD:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
self.bot.fort_timeouts.update(
{fort["id"]: pokestop_cooldown})
seconds_since_epoch = time.time()
minutes_left = format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)
self.emit_event(
'pokestop_on_cooldown',
formatted=
"Pokestop {pokestop} on cooldown. Time left: {minutes_left}.",
data={
'pokestop': fort_name,
'minutes_left': minutes_left
})
else:
self.emit_event('unknown_spin_result',
formatted="Unknown spint result {status_code}",
data={'status_code': str(spin_result)})
if 'chain_hack_sequence_number' in response_dict['responses'][
'FORT_SEARCH']:
action_delay(self.spin_wait_min, self.spin_wait_max)
return response_dict['responses']['FORT_SEARCH'][
'chain_hack_sequence_number']
else:
self.emit_event(
'pokestop_searching_too_often',
formatted="Possibly searching too often, take a rest.")
if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown:
self.bot.softban = True
self.emit_event('softban',
formatted='Probably got softban.')
with self.bot.database as conn:
c = conn.cursor()
c.execute(
"SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='softban_log'"
)
result = c.fetchone()
if result[0] == 1:
source = str("PokemonCatchWorker")
status = str("Possible Softban")
conn.execute(
'''INSERT INTO softban_log (status, source) VALUES (?, ?)''',
(status, source))
else:
self.emit_event(
'softban_log',
sender=self,
level='info',
formatted=
"softban_log table not found, skipping log")
self.bot.fort_timeouts[fort["id"]] = (
time.time() + 300) * 1000 # Don't spin for 5m
return WorkerResult.ERROR
action_delay(self.spin_wait_min, self.spin_wait_max)
if len(forts) > 1:
return WorkerResult.RUNNING
return WorkerResult.SUCCESS
def work(self):
forts = self.get_forts_in_range()
if not self.should_run() or len(forts) == 0:
return WorkerResult.SUCCESS
fort = forts[0]
lat = fort['latitude']
lng = fort['longitude']
details = fort_details(self.bot, fort['id'], lat, lng)
fort_name = details.get('name', 'Unknown')
response_dict = self.bot.api.fort_search(
fort_id=fort['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.bot.position[0]),
player_longitude=f2i(self.bot.position[1])
)
if ('responses' in response_dict) and ('FORT_SEARCH' in response_dict['responses']):
spin_details = response_dict['responses']['FORT_SEARCH']
spin_result = spin_details.get('result', -1)
if (spin_result == SPIN_REQUEST_RESULT_SUCCESS) or (spin_result == SPIN_REQUEST_RESULT_INVENTORY_FULL):
self.bot.softban = False
experience_awarded = spin_details.get('experience_awarded', 0)
items_awarded = self.get_items_awarded_from_fort_spinned(response_dict)
egg_awarded = spin_details.get('pokemon_data_egg', None)
if egg_awarded is not None:
items_awarded[u'Egg'] = egg_awarded['egg_km_walked_target']
if experience_awarded or items_awarded:
awards = ', '.join(["{}x {}".format(items_awarded[x], x) for x in items_awarded if x != u'Egg'])
if egg_awarded is not None:
awards += u', {} Egg'.format(egg_awarded['egg_km_walked_target'])
self.emit_event(
'spun_pokestop',
formatted="Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}",
data={
'pokestop': fort_name,
'exp': experience_awarded,
'items': awards
}
)
else:
self.emit_event(
'pokestop_empty',
formatted='Found nothing in pokestop {pokestop}.',
data={'pokestop': fort_name}
)
with self.bot.database as conn:
c = conn.cursor()
c.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='pokestop_log'")
result = c.fetchone()
c.execute("SELECT DISTINCT COUNT(pokestop) FROM pokestop_log WHERE dated >= datetime('now','-1 day')")
if c.fetchone()[0] >= self.config.get('daily_spin_limit', 2000):
self.emit_event('spin_limit', formatted='WARNING! You have reached your daily spin limit')
sys.exit(2)
while True:
if result[0] == 1:
conn.execute('''INSERT INTO pokestop_log (pokestop, exp, items) VALUES (?, ?, ?)''', (fort_name, str(experience_awarded), str(items_awarded)))
break
else:
self.emit_event('pokestop_log',
sender=self,
level='info',
formatted="pokestop_log table not found, skipping log")
break
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']]
elif spin_result == SPIN_REQUEST_RESULT_OUT_OF_RANGE:
self.emit_event(
'pokestop_out_of_range',
formatted="Pokestop {pokestop} out of range.",
data={'pokestop': fort_name}
)
elif spin_result == SPIN_REQUEST_RESULT_IN_COOLDOWN_PERIOD:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
seconds_since_epoch = time.time()
minutes_left = format_time(
(pokestop_cooldown / 1000) - seconds_since_epoch
)
self.emit_event(
'pokestop_on_cooldown',
formatted="Pokestop {pokestop} on cooldown. Time left: {minutes_left}.",
data={'pokestop': fort_name, 'minutes_left': minutes_left}
)
else:
self.emit_event(
'unknown_spin_result',
formatted="Unknown spint result {status_code}",
data={'status_code': str(spin_result)}
)
if 'chain_hack_sequence_number' in response_dict['responses'][
'FORT_SEARCH']:
action_delay(self.spin_wait_min, self.spin_wait_max)
return response_dict['responses']['FORT_SEARCH'][
'chain_hack_sequence_number']
else:
self.emit_event(
'pokestop_searching_too_often',
formatted="Possibly searching too often, take a rest."
)
if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown:
self.bot.softban = True
self.emit_event(
'softban',
formatted='Probably got softban.'
)
with self.bot.database as conn:
c = conn.cursor()
c.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='softban_log'")
result = c.fetchone()
if result[0] == 1:
source = str("PokemonCatchWorker")
status = str("Possible Softban")
conn.execute('''INSERT INTO softban_log (status, source) VALUES (?, ?)''', (status, source))
else:
self.emit_event('softban_log',
sender=self,
level='info',
formatted="softban_log table not found, skipping log")
self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m
return WorkerResult.ERROR
action_delay(self.spin_wait_min, self.spin_wait_max)
if len(forts) > 1:
return WorkerResult.RUNNING
return WorkerResult.SUCCESS
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 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 work(self):
fort = self.get_fort_in_range()
if not self.should_run() or fort is None:
return WorkerResult.SUCCESS
lat = fort['latitude']
lng = fort['longitude']
details = fort_details(self.bot, fort['id'], lat, lng)
fort_name = details.get('name', 'Unknown').encode('utf8', 'replace')
logger.log('Now at Pokestop: {0}'.format(fort_name), 'cyan')
logger.log('Spinning ...', 'cyan')
self.bot.api.fort_search(fort_id=fort['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.bot.position[0]),
player_longitude=f2i(self.bot.position[1]))
response_dict = self.bot.api.call()
if 'responses' in response_dict and \
'FORT_SEARCH' in response_dict['responses']:
spin_details = response_dict['responses']['FORT_SEARCH']
spin_result = spin_details.get('result', -1)
if spin_result == 1:
self.bot.softban = False
logger.log("Loot: ", 'green')
experience_awarded = spin_details.get('experience_awarded',
False)
if experience_awarded:
logger.log(str(experience_awarded) + " xp",
'green')
items_awarded = spin_details.get('items_awarded', False)
if items_awarded:
self.bot.latest_inventory = None
tmp_count_items = {}
for item in items_awarded:
item_id = item['item_id']
if not item_id in tmp_count_items:
tmp_count_items[item_id] = item['item_count']
else:
tmp_count_items[item_id] += item['item_count']
for item_id, item_count in tmp_count_items.iteritems():
item_name = self.bot.item_list[str(item_id)]
logger.log(
'- ' + str(item_count) + "x " + item_name +
" (Total: " + str(self.bot.item_inventory_count(item_id)) + ")", 'yellow'
)
else:
logger.log("[#] Nothing found.", 'yellow')
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
if pokestop_cooldown:
seconds_since_epoch = time.time()
logger.log('PokeStop on cooldown. Time left: ' + str(
format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)))
self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']]
elif spin_result == 2:
logger.log("[#] Pokestop out of range")
elif spin_result == 3:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
seconds_since_epoch = time.time()
logger.log('PokeStop on cooldown. Time left: ' + str(
format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)))
elif spin_result == 4:
logger.log("Inventory is full", 'red')
else:
logger.log("Unknown spin result: " + str(spin_result), 'red')
if 'chain_hack_sequence_number' in response_dict['responses'][
'FORT_SEARCH']:
time.sleep(2)
return response_dict['responses']['FORT_SEARCH'][
'chain_hack_sequence_number']
else:
logger.log('Possibly searching too often - taking a short rest :)', 'yellow')
if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown:
self.bot.softban = True
logger.log('[!] Possibly got softban too...', 'red')
else:
self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m
return 11
sleep(2)
return 0
def work(self):
fort = self.get_fort_in_range()
if not self.should_run() or fort is None:
return WorkerResult.SUCCESS
lat = fort['latitude']
lng = fort['longitude']
details = fort_details(self.bot, fort['id'], lat, lng)
fort_name = details.get('name', 'Unknown')
response_dict = self.bot.api.fort_search(
fort_id=fort['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.bot.position[0]),
player_longitude=f2i(self.bot.position[1])
)
if 'responses' in response_dict and \
'FORT_SEARCH' in response_dict['responses']:
spin_details = response_dict['responses']['FORT_SEARCH']
spin_result = spin_details.get('result', -1)
if spin_result == 1:
self.bot.softban = False
experience_awarded = spin_details.get('experience_awarded', 0)
items_awarded = spin_details.get('items_awarded', {})
if items_awarded:
self.bot.latest_inventory = None
tmp_count_items = {}
for item in items_awarded:
item_id = item['item_id']
item_name = self.bot.item_list[str(item_id)]
if not item_name in tmp_count_items:
tmp_count_items[item_name] = item['item_count']
else:
tmp_count_items[item_name] += item['item_count']
if experience_awarded or items_awarded:
self.emit_event(
'spun_pokestop',
formatted="Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}",
data={
'pokestop': fort_name,
'exp': experience_awarded,
'items': tmp_count_items
}
)
else:
self.emit_event(
'pokestop_empty',
formatted='Found nothing in pokestop {pokestop}.',
data={'pokestop': fort_name}
)
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']]
elif spin_result == 2:
self.emit_event(
'pokestop_out_of_range',
formatted="Pokestop {pokestop} out of range.",
data={'pokestop': fort_name}
)
elif spin_result == 3:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
seconds_since_epoch = time.time()
minutes_left = format_time(
(pokestop_cooldown / 1000) - seconds_since_epoch
)
self.emit_event(
'pokestop_on_cooldown',
formatted="Pokestop {pokestop} on cooldown. Time left: {minutes_left}.",
data={'pokestop': fort_name, 'minutes_left': minutes_left}
)
elif spin_result == 4:
if not self.ignore_item_count:
self.emit_event(
'inventory_full',
formatted="Inventory is full!"
)
else:
self.emit_event(
'unknown_spin_result',
formatted="Unknown spint result {status_code}",
data={'status_code': str(spin_result)}
)
if 'chain_hack_sequence_number' in response_dict['responses'][
'FORT_SEARCH']:
time.sleep(2)
return response_dict['responses']['FORT_SEARCH'][
'chain_hack_sequence_number']
else:
self.emit_event(
'pokestop_searching_too_often',
formatted="Possibly searching too often, take a rest."
)
if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown:
self.bot.softban = True
self.emit_event(
'softban',
formatted='Probably got softban.'
)
else:
self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m
return 11
sleep(2)
return 0
def work(self):
forts = self.get_forts_in_range()
if not self.should_run() or len(forts) == 0:
return WorkerResult.SUCCESS
fort = forts[0]
lat = fort['latitude']
lng = fort['longitude']
details = fort_details(self.bot, fort['id'], lat, lng)
fort_name = details.get('name', 'Unknown')
response_dict = self.bot.api.fort_search(
fort_id=fort['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.bot.position[0]),
player_longitude=f2i(self.bot.position[1])
)
if ('responses' in response_dict) and ('FORT_SEARCH' in response_dict['responses']):
spin_details = response_dict['responses']['FORT_SEARCH']
spin_result = spin_details.get('result', -1)
if (spin_result == SPIN_REQUEST_RESULT_SUCCESS) or (spin_result == SPIN_REQUEST_RESULT_INVENTORY_FULL):
self.bot.softban = False
experience_awarded = spin_details.get('experience_awarded', 0)
items_awarded = self.get_items_awarded_from_fort_spinned(response_dict)
if experience_awarded or items_awarded:
self.emit_event(
'spun_pokestop',
formatted="Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}",
data={
'pokestop': fort_name,
'exp': experience_awarded,
'items': items_awarded
}
)
else:
self.emit_event(
'pokestop_empty',
formatted='Found nothing in pokestop {pokestop}.',
data={'pokestop': fort_name}
)
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']]
elif spin_result == SPIN_REQUEST_RESULT_OUT_OF_RANGE:
self.emit_event(
'pokestop_out_of_range',
formatted="Pokestop {pokestop} out of range.",
data={'pokestop': fort_name}
)
elif spin_result == SPIN_REQUEST_RESULT_IN_COOLDOWN_PERIOD:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
seconds_since_epoch = time.time()
minutes_left = format_time(
(pokestop_cooldown / 1000) - seconds_since_epoch
)
self.emit_event(
'pokestop_on_cooldown',
formatted="Pokestop {pokestop} on cooldown. Time left: {minutes_left}.",
data={'pokestop': fort_name, 'minutes_left': minutes_left}
)
else:
self.emit_event(
'unknown_spin_result',
formatted="Unknown spint result {status_code}",
data={'status_code': str(spin_result)}
)
if 'chain_hack_sequence_number' in response_dict['responses'][
'FORT_SEARCH']:
action_delay(self.spin_wait_min, self.spin_wait_max)
return response_dict['responses']['FORT_SEARCH'][
'chain_hack_sequence_number']
else:
self.emit_event(
'pokestop_searching_too_often',
formatted="Possibly searching too often, take a rest."
)
if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown:
self.bot.softban = True
self.emit_event(
'softban',
formatted='Probably got softban.'
)
else:
self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m
return WorkerResult.ERROR
action_delay(self.spin_wait_min, self.spin_wait_max)
if len(forts) > 1:
return WorkerResult.RUNNING
return WorkerResult.SUCCESS
def work(self):
fort = self.get_fort_in_range()
if not self.should_run() or fort is None:
return WorkerResult.SUCCESS
lat = fort['latitude']
lng = fort['longitude']
details = fort_details(self.bot, fort['id'], lat, lng)
fort_name = details.get('name', 'Unknown')
response_dict = self.bot.api.fort_search(
fort_id=fort['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.bot.position[0]),
player_longitude=f2i(self.bot.position[1]))
if 'responses' in response_dict and \
'FORT_SEARCH' in response_dict['responses']:
spin_details = response_dict['responses']['FORT_SEARCH']
spin_result = spin_details.get('result', -1)
if spin_result == 1:
self.bot.softban = False
experience_awarded = spin_details.get('experience_awarded', 0)
items_awarded = spin_details.get('items_awarded', {})
if items_awarded:
self.bot.latest_inventory = None
tmp_count_items = {}
for item in items_awarded:
item_id = item['item_id']
item_name = self.bot.item_list[str(item_id)]
if not item_name in tmp_count_items:
tmp_count_items[item_name] = item['item_count']
else:
tmp_count_items[item_name] += item['item_count']
if experience_awarded or items_awarded:
self.emit_event(
'spun_pokestop',
formatted=
"Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}",
data={
'pokestop': fort_name,
'exp': experience_awarded,
'items': tmp_count_items
})
else:
self.emit_event(
'pokestop_empty',
formatted='Found nothing in pokestop {pokestop}.',
data={'pokestop': fort_name})
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
self.bot.recent_forts = self.bot.recent_forts[1:] + [
fort['id']
]
elif spin_result == 2:
self.emit_event('pokestop_out_of_range',
formatted="Pokestop {pokestop} out of range.",
data={'pokestop': fort_name})
elif spin_result == 3:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
self.bot.fort_timeouts.update(
{fort["id"]: pokestop_cooldown})
seconds_since_epoch = time.time()
minutes_left = format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)
self.emit_event(
'pokestop_on_cooldown',
formatted=
"Pokestop {pokestop} on cooldown. Time left: {minutes_left}.",
data={
'pokestop': fort_name,
'minutes_left': minutes_left
})
elif spin_result == 4:
self.emit_event('inventory_full',
formatted="Inventory is full!")
else:
self.emit_event('unknown_spin_result',
formatted="Unknown spint result {status_code}",
data={'status_code': str(spin_result)})
if 'chain_hack_sequence_number' in response_dict['responses'][
'FORT_SEARCH']:
time.sleep(2)
return response_dict['responses']['FORT_SEARCH'][
'chain_hack_sequence_number']
else:
self.emit_event(
'pokestop_searching_too_often',
formatted="Possibly searching too often, take a rest.")
if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown:
self.bot.softban = True
self.emit_event('softban',
formatted='Probably got softban.')
else:
self.bot.fort_timeouts[fort["id"]] = (
time.time() + 300) * 1000 # Don't spin for 5m
return 11
sleep(2)
return 0
def work(self):
forts = self.get_forts_in_range()
if not self.should_run() or len(forts) == 0:
return WorkerResult.SUCCESS
fort = forts[0]
lat = fort['latitude']
lng = fort['longitude']
details = fort_details(self.bot, fort['id'], lat, lng)
fort_name = details.get('name', 'Unknown')
response_dict = self.bot.api.fort_search(
fort_id=fort['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.bot.position[0]),
player_longitude=f2i(self.bot.position[1]))
if ('responses' in response_dict) and ('FORT_SEARCH'
in response_dict['responses']):
spin_details = response_dict['responses']['FORT_SEARCH']
spin_result = spin_details.get('result', -1)
if (spin_result == SPIN_REQUEST_RESULT_SUCCESS) or (
spin_result == SPIN_REQUEST_RESULT_INVENTORY_FULL):
self.bot.softban = False
experience_awarded = spin_details.get('experience_awarded', 0)
items_awarded = self.get_items_awarded_from_fort_spinned(
response_dict)
if experience_awarded or items_awarded:
self.emit_event(
'spun_pokestop',
formatted=
"Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}",
data={
'pokestop': fort_name,
'exp': experience_awarded,
'items': items_awarded
})
else:
self.emit_event(
'pokestop_empty',
formatted='Found nothing in pokestop {pokestop}.',
data={'pokestop': fort_name})
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown})
self.bot.recent_forts = self.bot.recent_forts[1:] + [
fort['id']
]
elif spin_result == SPIN_REQUEST_RESULT_OUT_OF_RANGE:
self.emit_event('pokestop_out_of_range',
formatted="Pokestop {pokestop} out of range.",
data={'pokestop': fort_name})
elif spin_result == SPIN_REQUEST_RESULT_IN_COOLDOWN_PERIOD:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
self.bot.fort_timeouts.update(
{fort["id"]: pokestop_cooldown})
seconds_since_epoch = time.time()
minutes_left = format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)
self.emit_event(
'pokestop_on_cooldown',
formatted=
"Pokestop {pokestop} on cooldown. Time left: {minutes_left}.",
data={
'pokestop': fort_name,
'minutes_left': minutes_left
})
else:
self.emit_event('unknown_spin_result',
formatted="Unknown spint result {status_code}",
data={'status_code': str(spin_result)})
if 'chain_hack_sequence_number' in response_dict['responses'][
'FORT_SEARCH']:
action_delay(self.spin_wait_min, self.spin_wait_max)
return response_dict['responses']['FORT_SEARCH'][
'chain_hack_sequence_number']
else:
self.emit_event(
'pokestop_searching_too_often',
formatted="Possibly searching too often, take a rest.")
if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown:
self.bot.softban = True
self.emit_event('softban',
formatted='Probably got softban.')
else:
self.bot.fort_timeouts[fort["id"]] = (
time.time() + 300) * 1000 # Don't spin for 5m
return WorkerResult.ERROR
action_delay(self.spin_wait_min, self.spin_wait_max)
if len(forts) > 1:
return WorkerResult.RUNNING
return WorkerResult.SUCCESS
