def _work_at_position(self,
lat,
lng,
alt,
seen_pokemon=False,
seen_pokestop=False,
seen_gym=False,
data=None):
if data is not None:
gym = self.session.query(Gym).get(data)
cell = {
'forts': [{
'id': gym.id,
'owned_by_team': 4,
'gym_points': 1,
'latitude': gym.latitude,
'longitude': gym.longitude
}]
}
sleep(5)
self.api.set_position(lat, lng, alt)
self.ai.work_on_cell(cell, (lat, lng, alt),
seen_pokemon=False,
seen_pokestop=False,
seen_gym=True)
else:
sleep(5)
def release_pokemon(self, pokemon_name, cp, iv, pokemon_id):
log.info('Обмен {} [CP {}] [Потенциал {}] на конфеты!'.format(
pokemon_name, cp, iv))
response_dict = self.api.release_pokemon(pokemon_id=pokemon_id).call()
#print response_dict
self.metrica.take_ping()
sleep(4)
def work(self):
lat = self.gym['latitude']
lng = self.gym['longitude']
gym_id = self.gym['id']
dist = distance(self.position[0], self.position[1], lat, lng)
log.info('[#] Видим GYM {} на удалении {}'.format(gym_id, format_dist(dist)))
if dist > 10:
log.info('[#] GYM дальше 10 метров, бежим...')
position = (lat, lng, 0.0)
if self.scanner.mode.walk > 0:
self.stepper._walk_to(self.scanner.mode.walk, *position)
else:
self.api.set_position(*position)
self.api.player_update(latitude=lat, longitude=lng)
self.position = position
response_dict = self.api.call()
log.info('[#] Прибыли к GYM\'у')
sleep(2)
return response_dict
return None
def work(self):
lat = self.pokestop['latitude']
lng = self.pokestop['longitude']
pokestop_id = self.pokestop['id']
dist = distance(self.position[0], self.position[1], lat, lng)
log.info('Видим покестоп {} на удалении {}'.format(
pokestop_id, format_dist(dist)))
if dist > 10:
log.info('Покестоп дальше 10 метров, бежим...')
position = (lat, lng, 0.0)
if self.scanner.mode.walk > 0:
self.stepper._walk_to(self.scanner.mode.walk, *position)
else:
self.api.set_position(*position)
self.api.player_update(latitude=lat, longitude=lng)
self.position = position
response_dict = self.api.call()
log.info('Прибыли к покестопу')
sleep(2)
return response_dict
return None
def _old_walk_to(self, speed, lat, lng, alt):
dist = distance(
i2f(self.api._position_lat), i2f(self.api._position_lng), lat, lng)
steps = (dist + 0.0) / (speed + 0.0) # may be rational number
intSteps = int(steps)
residuum = steps - intSteps
log.info('[#] Walking from ' + str((i2f(self.api._position_lat), i2f(
self.api._position_lng))) + " to " + str(str((lat, lng))) +
" for approx. " + str(format_time(ceil(steps))))
if steps != 0:
dLat = (lat - i2f(self.api._position_lat)) / steps
dLng = (lng - i2f(self.api._position_lng)) / steps
for i in range(intSteps):
cLat = i2f(self.api._position_lat) + \
dLat + random_lat_long_delta()
cLng = i2f(self.api._position_lng) + \
dLng + random_lat_long_delta()
self.api.set_position(cLat, cLng, alt)
self.ai.heartbeat()
sleep(1) # sleep one second plus a random delta
self._work_at_position(
i2f(self.api._position_lat), i2f(self.api._position_lng),
alt, False)
self.api.set_position(lat, lng, alt)
self.ai.heartbeat()
log.info("[#] Finished walking")
def take_step(self):
position = [self.origin_lat, self.origin_lon, 0]
coords = self.generate_coords(self.origin_lat, self.origin_lon,
self.step, self.distance)
self.metrica.take_position(
position, self.geolocation.get_google_polilyne(coords))
self.api.set_position(*position)
step = 1
for coord in coords:
self.metrica.take_status(
scanner_msg='Точечное сканирование P\S ({} / {})'.format(
step, len(coords)))
log.info('Точечное сканирование P\S ({} / {})'.format(
step, len(coords)))
position = (coord['lat'], coord['lng'], 0)
if self.walk > 0:
self._walk_to(self.walk, *position)
else:
self.api.set_position(*position)
sleep(1)
self._work_at_position(position[0],
position[1],
position[2],
seen_pokemon=False,
seen_pokestop=True,
seen_gym=False,
data=coord['id'])
sleep(1)
step += 1
def take_step(self):
position = [self.origin_lat, self.origin_lon, 0]
coords = self.generate_coords(self.origin_lat, self.origin_lon, self.step, self.distance)
self.metrica.take_position(position, self.geolocation.get_google_polilyne(coords))
self.api.set_position(*position)
step = 1
for coord in coords:
# starting at 0 index
self.metrica.take_status(scanner_msg='Квадратичное ({} / {})'.format(step, len(coords)))
log.info('Квадратичное сканирование ({} / {})'.format(step, len(coords)))
position = (coord['lat'], coord['lng'], 0)
if self.walk > 0:
self._walk_to(self.walk, *position)
else:
self.api.set_position(*position)
self.ai.heartbeat()
self._work_at_position(position[0], position[1], position[2], seen_pokemon=True, seen_pokestop=True, seen_gym=True)
sleep(2)
step += 1
def _walk_to(self, speed, lat, lng, alt):
dist = distance(i2f(self.api._position_lat),
i2f(self.api._position_lng), lat, lng)
steps = (dist + 0.0) / (speed + 0.0) # may be rational number
intSteps = int(steps)
residuum = steps - intSteps
log.info('Бежим из ' + str((i2f(self.api._position_lat),
i2f(self.api._position_lng))) + " в " +
str(str((lat, lng))) + " на " + str(round(dist, 2)) +
" по прямой. " + str(format_time(ceil(steps))))
if steps != 0:
dLat = (lat - i2f(self.api._position_lat)) / steps
dLng = (lng - i2f(self.api._position_lng)) / steps
for i in range(intSteps):
cLat = i2f(
self.api._position_lat) + dLat + random_lat_long_delta()
cLng = i2f(
self.api._position_lng) + dLng + random_lat_long_delta()
self.api.set_position(cLat, cLng, alt)
self.ai.heartbeat()
sleep(1)
self.api.set_position(lat, lng, alt)
self.ai.heartbeat()
def _work_at_position(self,
lat,
lng,
alt,
seen_pokemon=False,
seen_pokestop=False,
seen_gym=False,
data=None):
if data is not None:
pokestop = self.session.query(Pokestop).get(data)
cell = {
'forts': [{
'id': pokestop.id,
'type': 1,
'latitude': pokestop.latitude,
'longitude': pokestop.longitude
}]
}
sleep(5)
self.api.set_position(lat, lng, alt)
self.ai.work_on_cell(cell, (lat, lng, alt),
seen_pokemon=False,
seen_pokestop=True,
seen_gym=False)
else:
sleep(5)
def _walk_to(self, speed, lat, lng, alt):
dist = distance(i2f(self.api._position_lat),
i2f(self.api._position_lng), lat, lng)
steps = (dist + 0.0) / (speed + 0.0) # may be rational number
intSteps = int(steps)
residuum = steps - intSteps
log.info('Бежим из ' + str((i2f(self.api._position_lat),
i2f(self.api._position_lng))) + " в " +
str(str((lat, lng))) + " по прямой. " +
str(format_time(ceil(steps))))
if steps != 0:
dLat = (lat - i2f(self.api._position_lat)) / steps
dLng = (lng - i2f(self.api._position_lng)) / steps
for i in range(intSteps):
cLat = i2f(
self.api._position_lat) + dLat + random_lat_long_delta()
cLng = i2f(
self.api._position_lng) + dLng + random_lat_long_delta()
self.api.set_position(cLat, cLng, alt)
self.ai.heartbeat()
self._work_at_position(i2f(self.api._position_lat),
i2f(self.api._position_lng),
alt,
seen_pokemon=True,
seen_pokestop=False,
seen_gym=False)
sleep(2 * self.scanner.mode.is_human)
self.api.set_position(lat, lng, alt)
self.ai.heartbeat()
def take_step(self):
position = [self.origin_lat, self.origin_lon, 0]
coords = self.generate_coords(self.origin_lat, self.origin_lon,
self.step, self.distance)
self.metrica.take_position(
position, self.geolocation.get_google_polilyne(coords))
self.api.set_position(*position)
step = 1
for coord in coords:
# starting at 0 index
self.metrica.take_status(
scanner_msg='Квадратичное сканирование ({} / {})'.format(
step, len(coords)))
log.info('Квадратичное сканирование ({} / {})'.format(
step, len(coords)))
position = (coord['lat'], coord['lng'], 0)
if self.walk > 0:
self._walk_to(self.walk, *position)
else:
self.api.set_position(*position)
sleep(1)
self._work_at_position(position[0],
position[1],
position[2],
seen_pokemon=True,
seen_pokestop=True,
seen_gym=True)
sleep(10 * self.scanner.mode.is_human)
step += 1
def update(self):
log.info("Обновляем данные профиля.")
sleep(5)
response_dict = self.api.get_player()
#response_dict = self.api.call()
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_PLAYER' in response_dict['responses']:
if 'player_data' in response_dict['responses']['GET_PLAYER']:
try:
profile_res = response_dict['responses']['GET_PLAYER']['player_data']
self.scanner.account.statistic.username = profile_res['username']
self.scanner.account.statistic.date_start = datetime.datetime.fromtimestamp(profile_res['creation_timestamp_ms'] / 1e3)
if 'amount' in profile_res['currencies'][0]:
self.scanner.account.statistic.pokecoins = profile_res['currencies'][0]['amount']
if 'amount' in profile_res['currencies'][1]:
self.scanner.account.statistic.stardust = profile_res['currencies'][1]['amount']
except Exception as e:
log.error("Ошибка при обновлении провиля:{0}".fotmat(e))
self.session.commit()
else:
log.warning("Получен неверный статус: {0}".format(response_dict['status_code']))
def release_pokemon(self, pokemon_name, cp, iv, pokemon_id):
log.info('Обмен {} [CP {}] [Потенциал {}] на конфеты!'.format(pokemon_name,
cp,
iv))
response_dict = self.api.release_pokemon(pokemon_id=pokemon_id).call()
#print response_dict
self.metrica.take_ping()
sleep(4)
def _work_at_position(self, lat, lng, alt, seen_pokemon=False, seen_pokestop=False, seen_gym=False, data=None):
if data is not None:
pokestop = self.session.query(Pokestop).get(data)
cell = {
'forts': [
{
'id': pokestop.id,
'type': 1,
'latitude': pokestop.latitude,
'longitude': pokestop.longitude
}
]
}
self.metrica.take_search({'pokestops': 1})
self.api.set_position(lat, lng, alt)
self.ai.work_on_cell(cell, (lat, lng, alt), seen_pokemon=False, seen_pokestop=True, seen_gym=False)
position = (lat, lng, alt)
cellid = get_cell_ids(lat, lng)
timestamp = [0, ] * len(cellid)
map_cells = list()
sleep(self.ai.delay_scan)
response_dict = self.api.get_map_objects(latitude=f2i(lat), longitude=f2i(lng), since_timestamp_ms=timestamp, cell_id=cellid)
self.search.search(lat, lng)
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_MAP_OBJECTS' in response_dict['responses']:
if 'status' in response_dict['responses']['GET_MAP_OBJECTS']:
if response_dict['responses']['GET_MAP_OBJECTS']['status'] is 1:
map_cells = response_dict['responses']['GET_MAP_OBJECTS']['map_cells']
# Update current scanner location
self.metrica.take_position(position)
map_cells.sort(key=lambda x: distance(lat, lng, x['forts'][0]['latitude'], x['forts'][0]['longitude']) if 'forts' in x and x['forts'] != [] else 1e6)
log.debug("Получена информация о карте в размере {0} ячеек".format(len(map_cells)))
for cell in map_cells:
self.metrica.take_search(parse_map_cell(cell, self.session))
else:
log.warning("Получен неверный статус: {0}".format(response_dict['responses']['GET_MAP_OBJECTS']['status']))
else:
log.warning("Получен неверный статус: {0}".format(response_dict['status_code']))
self.api.set_position(lat, lng, alt)
for cell in map_cells:
self.ai.work_on_cell(cell, position, seen_pokemon=seen_pokemon, seen_pokestop=seen_pokestop, seen_gym=seen_gym)
def _work_at_position(self, lat, lng, alt, seen_pokemon=False, seen_pokestop=False, seen_gym=False, data=None):
position = (lat, lng, alt)
cellid = get_cell_ids(lat, lng)
timestamp = [0, ] * len(cellid)
map_cells = list()
self.api.get_map_objects(latitude=f2i(lat), longitude=f2i(lng), since_timestamp_ms=timestamp, cell_id=cellid)
response_dict = self.api.call()
sleep(0.2)
self.search.search(lat, lng)
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_MAP_OBJECTS' in response_dict['responses']:
if 'status' in response_dict['responses']['GET_MAP_OBJECTS']:
if response_dict['responses']['GET_MAP_OBJECTS']['status'] is 1:
map_cells = response_dict['responses']['GET_MAP_OBJECTS']['map_cells']
# Update current scanner location
self.metrica.take_position(position)
map_cells.sort(key=lambda x: distance(lat, lng, x['forts'][0]['latitude'], x['forts'][0]['longitude']) if 'forts' in x and x['forts'] != [] else 1e6)
log.debug("Получена информация о карте в размере {0} ячеек".format(len(map_cells)))
for cell in map_cells:
self.metrica.take_search(parse_map_cell(cell, self.session))
else:
log.warning("Получен неверный статус: {0}".format(response_dict['responses']['GET_MAP_OBJECTS']['status']))
else:
log.warning("Получен неверный статус: {0}".format(response_dict['status_code']))
log.info("Ожидаем конца сканирования, и по ходу парсим данные")
while not self.search.requests.empty():
if not self.search.response.empty():
cell = self.search.response.get()
self.metrica.take_search(parse_map_cell(cell, self.session))
self.search.response.task_done()
while not self.search.response.empty():
cell = self.search.response.get()
self.metrica.take_search(parse_map_cell(cell, self.session))
self.search.response.task_done()
self.api.set_position(lat, lng, alt)
for cell in map_cells:
self.ai.work_on_cell(cell, position, seen_pokemon=seen_pokemon, seen_pokestop=seen_pokestop, seen_gym=seen_gym)
def _walk_to(self, walk_speed, dest_lat, dest_lng, alt):
init_lat = self.api._position_lat
init_lng = self.api._position_lng
walk_distance = distance(init_lat, init_lng, dest_lat, dest_lng)
walk_distance_total = max(1, walk_distance)
walk_steps = (walk_distance + 0.0) / (walk_speed + 0.0)
if walk_distance < walk_speed or int(walk_steps) <= 1:
delta_lat = 0
delta_lng = 0
magnitude = 0
else:
delta_lat = (dest_lat - init_lat) / int(walk_steps)
delta_lng = (dest_lng - init_lng) / int(walk_steps)
magnitude = self._pythagorean(delta_lat, delta_lng)
log.info("Бежим из [{}, {}] в [{}, {}] на расстояние {}, со скоростью {}, ориентировочно за {}".format(init_lat, init_lng, dest_lat, dest_lng, round(walk_distance, 2), walk_speed, format_time(ceil(walk_steps))))
if (delta_lat == 0 and delta_lng == 0) or walk_distance < walk_speed:
self.api.set_position(dest_lat, dest_lng, 0)
return True
while True:
total_delta_step = walk_distance/int(walk_steps)
total_delta_lat = (dest_lat - self.api._position_lat)
total_delta_lng = (dest_lng - self.api._position_lng)
magnitude = self._pythagorean(total_delta_lat, total_delta_lng)
if distance(self.api._position_lat, self.api._position_lng, dest_lat, dest_lng) <= total_delta_step:
self.api.set_position(dest_lat, dest_lng, alt)
self.ai.heartbeat()
break
unit_lat = total_delta_lat / magnitude
unit_lng = total_delta_lng / magnitude
scaled_delta_lat = unit_lat * magnitude
scaled_delta_lng = unit_lng * magnitude
c_lat = init_lat + scaled_delta_lat + random_lat_long_delta()
c_lng = init_lng + scaled_delta_lng + random_lat_long_delta()
self.api.set_position(c_lat, c_lng, 0)
self.ai.heartbeat()
sleep(1)
def _walk_to(self, speed, lat, lng, alt):
origin = ','.join([str(self.api._position_lat), str(self.api._position_lng)])
destination = ','.join([str(lat), str(lng)])
polyline_walker = PolylineWalker(origin, destination, self.walk)
proposed_origin = polyline_walker.points[0]
proposed_destination = polyline_walker.points[-1]
proposed_lat = proposed_origin[0]
proposed_lng = proposed_origin[1]
if proposed_lat != lat and proposed_lng != lng:
self._old_walk_to(speed, proposed_lat, proposed_lng, alt)
while proposed_destination != polyline_walker.get_pos()[0]:
cLat, cLng = polyline_walker.get_pos()[0]
self.api.set_position(cLat, cLng, alt)
self.ai.heartbeat()
self._work_at_position(i2f(self.api._position_lat), i2f(self.api._position_lng), alt, False)
sleep(1) # sleep one second plus a random delta
if proposed_lat != self.api._position_lat and proposed_lng != self.api._position_lng:
self._old_walk_to(speed, lat, lng, alt)
def _work_at_position(self, lat, lng, alt, seen_pokemon=False, seen_pokestop=False, seen_gym=False, data=None):
if data is not None:
pokestop = self.session.query(Pokestop).get(data)
cell = {
'forts': [
{
'id': pokestop.id,
'type': 1,
'latitude': pokestop.latitude,
'longitude': pokestop.longitude
}
]
}
sleep(5)
self.api.set_position(lat, lng, alt)
self.ai.work_on_cell(cell, (lat, lng, alt), seen_pokemon=False, seen_pokestop=True, seen_gym=False)
else:
sleep(5)
def work(self):
lat = self.gym['latitude']
lng = self.gym['longitude']
if self.gym['owned_by_team'] !=0:
log.info("GYM ownered by {0}, analyse".format(self.gym['owned_by_team']))
self.api.fort_details(fort_id=self.gym['id'], latitude=lat, longitude=lng)
response_dict = self.api.call()
print response_dict
if 'responses' in response_dict \
and'FORT_DETAILS' in response_dict['responses'] \
and 'name' in response_dict['responses']['FORT_DETAILS']:
fort_details = response_dict['responses']['FORT_DETAILS']
fort_name = fort_details['name'].encode('utf8', 'replace')
parse_fort_details(self.gym['id'], 0, fort_details, self.session)
else:
fort_name = 'Unknown'
log.info('[#] Now at GYM: ' + fort_name)
sleep(5)
self.api.get_gym_details(gym_id=self.gym['id'],
gym_latitude=lat,
gym_longitude=lng,
player_latitude=f2i(self.position[0]),
player_longitude=f2i(self.position[1]))
response_dict = self.api.call()
print response_dict
if 'responses' in response_dict \
and'GET_GYM_DETAILS' in response_dict['responses'] \
and 'gym_state' in response_dict['responses']['GET_GYM_DETAILS']\
and 'memberships' in response_dict['responses']['GET_GYM_DETAILS']['gym_state']:
clear_gym_membership(self.gym['id'], self.session)
for membership in response_dict['responses']['GET_GYM_DETAILS']['gym_state']['memberships']:
parse_gym_membership(membership, self.gym['id'], self.gym['owned_by_team'], self.session)
else:
parse_gym_membership(None, self.gym['id'], 0, self.session)
log.info("GYM Unused, skipped")
def take_step(self):
position = [self.origin_lat, self.origin_lon, 0]
coords = self.generate_coords(self.origin_lat, self.origin_lon, self.step, self.distance)
self.metrica.take_position(position, self.geolocation.get_google_polilyne(coords))
self.api.set_position(*position)
step = 1
for coord in coords:
self.metrica.take_status(scanner_msg='Точечное сканирование P\S ({} / {})'.format(step, len(coords)))
log.info('Точечное сканирование P\S ({} / {})'.format(step, len(coords)))
position = (coord['lat'], coord['lng'], 0)
if self.walk > 0:
self._walk_to(self.walk, *position)
else:
self.api.set_position(*position)
sleep(1)
self._work_at_position(position[0], position[1], position[2], seen_pokemon=False, seen_pokestop=True, seen_gym=False, data=coord['id'])
sleep(1)
step += 1
def _walk_to(self, speed, lat, lng, alt):
dist = distance(i2f(self.api._position_lat), i2f(self.api._position_lng), lat, lng)
steps = (dist + 0.0) / (speed + 0.0) # may be rational number
intSteps = int(steps)
residuum = steps - intSteps
log.info('Бежим из ' + str((i2f(self.api._position_lat), i2f(self.api._position_lng))) + " в " + str(str((lat, lng))) +
" на " + str(round(dist, 2)) + " по прямой. " + str(format_time(ceil(steps))))
if steps != 0:
dLat = (lat - i2f(self.api._position_lat)) / steps
dLng = (lng - i2f(self.api._position_lng)) / steps
for i in range(intSteps):
cLat = i2f(self.api._position_lat) + dLat + random_lat_long_delta()
cLng = i2f(self.api._position_lng) + dLng + random_lat_long_delta()
self.api.set_position(cLat, cLng, alt)
self.ai.heartbeat()
sleep(1)
self.api.set_position(lat, lng, alt)
self.ai.heartbeat()
def _walk_to(self, speed, lat, lng, alt):
dist = distance(i2f(self.api._position_lat), i2f(self.api._position_lng), lat, lng)
steps = (dist + 0.0) / (speed + 0.0) # may be rational number
intSteps = int(steps)
residuum = steps - intSteps
log.info('Бежим из ' + str((i2f(self.api._position_lat), i2f(self.api._position_lng))) + " в " + str(str((lat, lng))) +
" по прямой. " + str(format_time(ceil(steps))))
if steps != 0:
dLat = (lat - i2f(self.api._position_lat)) / steps
dLng = (lng - i2f(self.api._position_lng)) / steps
for i in range(intSteps):
cLat = i2f(self.api._position_lat) + dLat + random_lat_long_delta()
cLng = i2f(self.api._position_lng) + dLng + random_lat_long_delta()
self.api.set_position(cLat, cLng, alt)
self.ai.heartbeat()
self._work_at_position(i2f(self.api._position_lat), i2f(self.api._position_lng), alt, seen_pokemon=True, seen_pokestop=False, seen_gym=False)
sleep(2*self.scanner.mode.is_human)
self.api.set_position(lat, lng, alt)
self.ai.heartbeat()
def take_step_at_position(self):
lat = self.api._position_lat + random_lat_long_delta()
lng = self.api._position_lng + random_lat_long_delta()
self.metrica.take_position((lat, lng, 0))
self.api.set_position(lat, lng, 0)
self.ai.heartbeat()
sleep(self.ai.delay_scan)
cellid = get_cell_ids(lat, lng, radius=70)
timestamp = [0, ] * len(cellid)
self.api.set_position(lat, lng, 0)
response_dict = self.api.get_map_objects(latitude=lat, longitude=lng, since_timestamp_ms=timestamp, cell_id=cellid)
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_MAP_OBJECTS' in response_dict['responses']:
if 'status' in response_dict['responses']['GET_MAP_OBJECTS']:
if response_dict['responses']['GET_MAP_OBJECTS']['status'] is 1:
for map_cell in response_dict['responses']['GET_MAP_OBJECTS']['map_cells']:
parse_map_cell(map_cell, self.session)
def thread_search(self, requests, response, api_orig,event):
log.info("Поток начал свою работу")
sleep(5)
while not event.isSet():
position = requests.get()
log.debug("Put work at {} {}".format(position['lat'], position['lng']))
sleep(4)
api = api_orig.copy()
try:
response_index = 0
while response_index < 5:
cellid = get_cell_ids(position['lat'], position['lng'])
timestamp = [1, ] * len(cellid)
api.set_position(position['lat'], position['lng'], 0)
api.get_map_objects(latitude=f2i(position['lat']), longitude=f2i(position['lng']), since_timestamp_ms=timestamp, cell_id=cellid)
response_dict = api.call()
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_MAP_OBJECTS' in response_dict['responses']:
if 'status' in response_dict['responses']['GET_MAP_OBJECTS']:
if response_dict['responses']['GET_MAP_OBJECTS']['status'] is 1:
map_cells = response_dict['responses']['GET_MAP_OBJECTS']['map_cells']
log.debug("Получена информация о карте в размере {0} ячеек".format(len(map_cells)))
for map_cell in map_cells:
self.response.put(map_cell)
response_index = 999
else:
log.warning("Получен неверный статус: {0}".format(response_dict['responses']['GET_MAP_OBJECTS']['status']))
else:
log.debug("Получен неверный статус: {0}".format(response_dict['status_code']))
if response_dict['status_code'] == 52:
response_index += 1
sleep(5)
except Exception as e:
log.error("Ошибка в обработке дочернего потока: {}".format(e))
finally:
requests.task_done()
log.info("Поток завершил работу")
def work_on_cell(self, cell, position, seen_pokemon=False, seen_pokestop=False, seen_gym=False):
self.position = position
#
# Искать ли покемонов на пути следования
#
if seen_pokemon:
if self.scanner.mode.is_catch:
if 'catchable_pokemons' in cell and len(cell['catchable_pokemons']) > 0:
cell['catchable_pokemons'].sort(key=lambda x: distance(position[0], position[1], x['latitude'], x['longitude']))
for pokemon in cell['catchable_pokemons']:
if self.catch_pokemon(pokemon) == PokemonCatch.NO_POKEBALLS:
break
if 'wild_pokemons' in cell and len(cell['wild_pokemons']) > 0:
cell['wild_pokemons'].sort(key=lambda x: distance(position[0], position[1], x['latitude'], x['longitude']))
for pokemon in cell['wild_pokemons']:
if self.catch_pokemon(pokemon) == PokemonCatch.NO_POKEBALLS:
break
#
# Отвлекаться ли на покестопы
#
if seen_pokestop:
if 'forts' in cell:
# Only include those with a lat/long
pokestops = [pokestop for pokestop in cell['forts'] if 'latitude' in pokestop and 'type' in pokestop]
pokestops.sort(key=lambda x: distance(position[0], position[1], x['latitude'], x['longitude']))
if self.scanner.mode.is_farm:
for pokestop in pokestops:
pokestop_distance = round(distance(position[0], position[1], pokestop['latitude'], pokestop['longitude']))
if pokestop_distance > self.scanner.mode.step*150000:
log.debug("Покестоп находится на большом растоянии ({0}), вернемся к нему позже.".format(pokestop_distance))
continue
pokestop_id = str(pokestop['id'])
if pokestop_id in self.seen_pokestop:
if self.seen_pokestop[pokestop_id] + 350 > time.time():
continue
worker = MoveToPokestop(pokestop, self)
worker.work()
worker = SeenPokestop(pokestop, self)
hack_chain = worker.work()
if hack_chain > 10:
sleep(10)
self.seen_pokestop[pokestop_id] = time.time()
self.inventory.update()
self.inventory.recycle()
self.metrica.take_ping()
if seen_gym:
if 'forts' in cell:
gyms = [gym for gym in cell['forts'] if 'gym_points' in gym]
gyms.sort(key=lambda x: distance(position[0], position[1], x['latitude'], x['longitude']))
if self.scanner.mode.is_lookup or self.scanner.mode.is_defender:
for gym in gyms:
gym_distance = round(distance(position[0], position[1], gym['latitude'], gym['longitude']))
if gym_distance > self.scanner.mode.step*150000:
log.debug("Gym находится на большом растоянии ({0}), вернемся к нему позже.".format(gym_distance))
continue
gym_id = str(gym['id'])
if self.scanner.mode.is_defender or self.scanner.mode.is_farm or self.scanner.mode.is_catch:
if gym_id in self.seen_gym:
if self.seen_gym[gym_id] + 350 > time.time():
continue
worker = MoveToGym(gym, self)
worker.work()
worker = SeenGym(gym, self)
hack_chain = worker.work()
if hack_chain > 10:
sleep(10)
self.seen_gym[gym_id] = time.time()
self.metrica.take_ping()
self.metrica.take_ping()
def work(self):
lat = self.pokestop['latitude']
lng = self.pokestop['longitude']
self.api.fort_details(fort_id=self.pokestop['id'], latitude=lat, longitude=lng)
response_dict = self.api.call()
print response_dict
if 'responses' in response_dict \
and'FORT_DETAILS' in response_dict['responses'] \
and 'name' in response_dict['responses']['FORT_DETAILS']:
fort_details = response_dict['responses']['FORT_DETAILS']
fort_name = fort_details['name'].encode('utf8', 'replace')
parse_fort_details(self.pokestop['id'], 1, fort_details, self.session)
else:
fort_name = 'Unknown'
log.info('[#] Now at Pokestop: ' + fort_name + ' - Spinning...')
sleep(1)
self.api.fort_search(fort_id=self.pokestop['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.position[0]),
player_longitude=f2i(self.position[1]))
response_dict = self.api.call()
if 'responses' in response_dict and \
'FORT_SEARCH' in response_dict['responses']:
spin_details = response_dict['responses']['FORT_SEARCH']
if spin_details['result'] == 1:
log.info("[+] Loot: ")
experience_awarded = spin_details.get('experience_awarded', False)
if experience_awarded:
log.info("[+] " + str(experience_awarded) + " xp")
items_awarded = spin_details.get('items_awarded', False)
if items_awarded:
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():
log.info("[+] Loot: {0} count {1}".format(item_id, item_count))
else:
log.info("[#] Nothing found.")
pokestop_cooldown = spin_details.get('cooldown_complete_timestamp_ms')
if pokestop_cooldown:
seconds_since_epoch = time.time()
log.info('[#] PokeStop on cooldown. Time left: ' + str(
format_time((pokestop_cooldown / 1000) - seconds_since_epoch)))
if not items_awarded and not experience_awarded and not pokestop_cooldown:
log.warning(
'Stopped at Pokestop and did not find experience, items '
'or information about the stop cooldown. You are '
'probably softbanned. Try to play on your phone, '
'if pokemons always ran away and you find nothing in '
'PokeStops you are indeed softbanned. Please try again '
'in a few hours.')
elif spin_details['result'] == 2:
log.info("[#] Pokestop out of range")
elif spin_details['result'] == 3:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
seconds_since_epoch = time.time()
log.info('[#] PokeStop on cooldown. Time left: ' + str(
format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)))
elif spin_details['result'] == 4:
log.info("[#] Inventory is full, switching to catch mode...")
#self.config.mode = 'poke'
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:
log.info('[#] may search too often, lets have a rest')
return 11
sleep(8)
return 0
def work(self):
encounter_id = self.pokemon['encounter_id']
spawnpoint_id = self.pokemon['spawnpoint_id']
player_latitude = self.pokemon['latitude']
player_longitude = self.pokemon['longitude']
self.api.encounter(encounter_id=encounter_id, spawnpoint_id=spawnpoint_id,
player_latitude=player_latitude, player_longitude=player_longitude)
response_dict = self.api.call()
if response_dict and 'responses' in response_dict:
if 'ENCOUNTER' in response_dict['responses']:
if 'status' in response_dict['responses']['ENCOUNTER']:
if response_dict['responses']['ENCOUNTER']['status'] is 7:
log.warning('[x] Pokemon Bag is full!')
return PokemonCatch.BAG_FULL
if response_dict['responses']['ENCOUNTER']['status'] is 1:
cp = 0
total_IV = 0
if 'wild_pokemon' in response_dict['responses']['ENCOUNTER']:
pokemon = response_dict['responses']['ENCOUNTER']['wild_pokemon']
catch_rate = response_dict['responses']['ENCOUNTER']['capture_probability']['capture_probability'] # 0 = pokeballs, 1 great balls, 3 ultra balls
if 'pokemon_data' in pokemon and 'cp' in pokemon['pokemon_data']:
cp = pokemon['pokemon_data']['cp']
iv_stats = ['individual_attack', 'individual_defense', 'individual_stamina']
for individual_stat in iv_stats:
try:
total_IV += pokemon['pokemon_data'][individual_stat]
except:
pokemon['pokemon_data'][individual_stat] = 0
continue
pokemon_potential = round((total_IV / 45.0), 2)
pokemon_num = int(pokemon['pokemon_data']['pokemon_id']) - 1
pokemon_name = self.data_pokemon[int(pokemon_num)]['Name']
log.info('A Wild {} appeared! [CP {}] [Potential {}]'.format(pokemon_name, cp, pokemon_potential))
log.info('IV [Stamina/Attack/Defense] = [{}/{}/{}]'.format(
pokemon['pokemon_data']['individual_stamina'],
pokemon['pokemon_data']['individual_attack'],
pokemon['pokemon_data']['individual_defense']
))
# Simulate app
sleep(3)
balls_stock = self.inventory.pokeball()
while(True):
pokeball = 1 # default:poke ball
if balls_stock[1] <= 0: # if poke ball are out of stock
if balls_stock[2] > 0: # and player has great balls in stock...
pokeball = 2 # then use great balls
elif balls_stock[3] > 0: # or if great balls are out of stock too, and player has ultra balls...
pokeball = 3 # then use ultra balls
else:
pokeball = 0 # player doesn't have any of pokeballs, great balls or ultra balls
while(pokeball < 3):
if catch_rate[pokeball-1] < 0.35 and balls_stock[pokeball+1] > 0:
# if current ball chance to catch is under 35%, and player has better ball - then use it
pokeball = pokeball+1 # use better ball
else:
break
# @TODO, use the best ball in stock to catch VIP (Very Important Pokemon: Configurable)
if pokeball is 0:
log.warning(balls_stock)
log.warning('Out of pokeballs, switching to farming mode...')
# Begin searching for pokestops.
return PokemonCatch.NO_POKEBALLS
balls_stock[pokeball] = balls_stock[pokeball] - 1
success_percentage = '{0:.2f}'.format(catch_rate[pokeball-1]*100)
log.info('Using {} (chance: {}%)... ({} left!)'.format(
pokeball,
success_percentage,
balls_stock[pokeball]
))
id_list1 = self.count_pokemon_inventory()
self.api.catch_pokemon(encounter_id=encounter_id,
pokeball=pokeball,
normalized_reticle_size=1.950,
spawn_point_guid=spawnpoint_id,
hit_pokemon=1,
spin_modifier=1,
NormalizedHitPosition=1)
response_dict = self.api.call()
if response_dict and \
'responses' in response_dict and \
'CATCH_POKEMON' in response_dict['responses'] and \
'status' in response_dict['responses']['CATCH_POKEMON']:
status = response_dict['responses']['CATCH_POKEMON']['status']
if status is 2:
log.warning('Attempted to capture {}- failed.. trying again!'.format(pokemon_name))
sleep(2)
continue
if status is 3:
log.warning('Oh no! {} vanished! :('.format(pokemon_name))
if status is 1:
log.info('Captured {}! [CP {}] [IV {}]'.format(pokemon_name, cp, pokemon_potential))
id_list2 = self.count_pokemon_inventory()
if self.pokemon_evolve:
try:
pokemon_to_transfer = list(Set(id_list2) - Set(id_list1))
self.api.evolve_pokemon(pokemon_id=pokemon_to_transfer[0])
response_dict = self.api.call()
status = response_dict['responses']['EVOLVE_POKEMON']['result']
if status == 1:
log.info('{} has been evolved!'.format(pokemon_name))
else:
log.warning('Failed to evolve {}!'.format(pokemon_name))
except Exception as e:
log.error('Failed while evolve {}!'.format(e))
if self.should_release_pokemon(pokemon_name, cp, pokemon_potential, response_dict):
# Transfering Pokemon
pokemon_to_transfer = list(
Set(id_list2) - Set(id_list1))
if len(pokemon_to_transfer) == 0:
raise RuntimeError(
'Trying to transfer 0 pokemons!')
self.transfer_pokemon(pokemon_to_transfer[0])
log.info('{} has been exchanged for candy!'.format(pokemon_name))
else:
log.info('Captured {}! [CP {}]'.format(pokemon_name, cp))
break
time.sleep(5)
def thread_search(self, requests, response, api_orig, event):
log.info("Поток начал свою работу")
sleep(5)
while not event.isSet():
position = requests.get()
log.debug("Put work at {} {}".format(position['lat'],
position['lng']))
sleep(4)
api = api_orig.copy()
try:
response_index = 0
while response_index < 5:
cellid = get_cell_ids(position['lat'], position['lng'])
timestamp = [
1,
] * len(cellid)
api.set_position(position['lat'], position['lng'], 0)
api.get_map_objects(latitude=f2i(position['lat']),
longitude=f2i(position['lng']),
since_timestamp_ms=timestamp,
cell_id=cellid)
response_dict = api.call()
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_MAP_OBJECTS' in response_dict[
'responses']:
if 'status' in response_dict['responses'][
'GET_MAP_OBJECTS']:
if response_dict['responses'][
'GET_MAP_OBJECTS'][
'status'] is 1:
map_cells = response_dict[
'responses'][
'GET_MAP_OBJECTS'][
'map_cells']
log.debug(
"Получена информация о карте в размере {0} ячеек"
.format(len(map_cells)))
for map_cell in map_cells:
self.response.put(map_cell)
response_index = 999
else:
log.warning(
"Получен неверный статус: {0}".
format(
response_dict['responses']
['GET_MAP_OBJECTS']
['status']))
else:
log.debug("Получен неверный статус: {0}".format(
response_dict['status_code']))
if response_dict['status_code'] == 52:
response_index += 1
sleep(5)
except Exception as e:
log.error("Ошибка в обработке дочернего потока: {}".format(e))
finally:
requests.task_done()
log.info("Поток завершил работу")
def _work_at_position(self, lat, lng, alt, seen_pokemon=False, seen_pokestop=False, seen_gym=False, data=None):
position = (lat, lng, alt)
map_cells = []
map_cells_timestamp = time.time()
if self.use_search:
self.search.search(lat, lng)
try:
radius_array = []
if seen_pokemon:
radius_array.append(190)
if (seen_pokestop | seen_gym) & self.use_long_radius:
radius_array.append(1000)
for radius in radius_array:
log.debug("Сканируем область в радиусе {} метров.".format(radius))
response_index = 0
sleep(self.ai.delay_scan)
while response_index < 5:
cellid = get_cell_ids(lat, lng, radius=radius)
timestamp = [0, ] * len(cellid)
self.api.set_position(lat, lng, 0)
self.ai.heartbeat()
response_dict = self.api.get_map_objects(latitude=lat, longitude=lng, since_timestamp_ms=timestamp, cell_id=cellid)
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_MAP_OBJECTS' in response_dict['responses']:
if 'status' in response_dict['responses']['GET_MAP_OBJECTS']:
if response_dict['responses']['GET_MAP_OBJECTS']['status'] is 1:
map_cells.extend(response_dict['responses']['GET_MAP_OBJECTS']['map_cells'])
log.debug('Response dictionary: \r\n{}'.format(pprint.PrettyPrinter(indent=4).pformat(response_dict['responses']['GET_MAP_OBJECTS'])))
break
response_index += 1
action_delay(self.ai.delay_scan, self.ai.delay_scan*2)
except Exception as e:
log.error("Ошибка в обработке дочернего потока: {}".format(e))
if self.use_search:
log.info("Ожидаем конца сканирования, и по ходу парсим данные")
while not self.search.requests.empty():
if not self.search.response.empty():
cell = self.search.response.get()
self.metrica.take_search(parse_map_cell(cell, self.session))
self.search.response.task_done()
while not self.search.response.empty():
cell = self.search.response.get()
self.metrica.take_search(parse_map_cell(cell, self.session))
self.search.response.task_done()
# Update current scanner location
self.metrica.take_position(position)
self.api.set_position(lat, lng, alt)
map_cells.sort(key=lambda x: distance(lat, lng, x['forts'][0]['latitude'], x['forts'][0]['longitude']) if 'forts' in x and x['forts'] != [] else 1e6)
log.debug("Получена информация о карте в размере {0} ячеек".format(len(map_cells)))
for cell in map_cells:
self.metrica.take_search(parse_map_cell(cell, self.session), timestamp=map_cells_timestamp)
if self.use_work_on_cell:
for cell in map_cells:
self.ai.work_on_cell(cell, position, seen_pokemon=seen_pokemon, seen_pokestop=seen_pokestop, seen_gym=seen_gym)
def work(self):
lat = self.pokestop['latitude']
lng = self.pokestop['longitude']
self.api.fort_details(fort_id=self.pokestop['id'],
latitude=lat,
longitude=lng)
response_dict = self.api.call()
print response_dict
if 'responses' in response_dict \
and'FORT_DETAILS' in response_dict['responses'] \
and 'name' in response_dict['responses']['FORT_DETAILS']:
fort_details = response_dict['responses']['FORT_DETAILS']
fort_name = fort_details['name'].encode('utf8', 'replace')
parse_fort_details(self.pokestop['id'], 1, fort_details,
self.session)
else:
fort_name = 'Unknown'
log.info('[#] Now at Pokestop: ' + fort_name + ' - Spinning...')
sleep(1)
self.api.fort_search(fort_id=self.pokestop['id'],
fort_latitude=lat,
fort_longitude=lng,
player_latitude=f2i(self.position[0]),
player_longitude=f2i(self.position[1]))
response_dict = self.api.call()
if 'responses' in response_dict and \
'FORT_SEARCH' in response_dict['responses']:
spin_details = response_dict['responses']['FORT_SEARCH']
if spin_details['result'] == 1:
log.info("[+] Loot: ")
experience_awarded = spin_details.get('experience_awarded',
False)
if experience_awarded:
log.info("[+] " + str(experience_awarded) + " xp")
items_awarded = spin_details.get('items_awarded', False)
if items_awarded:
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():
log.info("[+] Loot: {0} count {1}".format(
item_id, item_count))
else:
log.info("[#] Nothing found.")
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
seconds_since_epoch = time.time()
log.info('[#] PokeStop on cooldown. Time left: ' + str(
format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)))
if not items_awarded and not experience_awarded and not pokestop_cooldown:
log.warning(
'Stopped at Pokestop and did not find experience, items '
'or information about the stop cooldown. You are '
'probably softbanned. Try to play on your phone, '
'if pokemons always ran away and you find nothing in '
'PokeStops you are indeed softbanned. Please try again '
'in a few hours.')
elif spin_details['result'] == 2:
log.info("[#] Pokestop out of range")
elif spin_details['result'] == 3:
pokestop_cooldown = spin_details.get(
'cooldown_complete_timestamp_ms')
if pokestop_cooldown:
seconds_since_epoch = time.time()
log.info('[#] PokeStop on cooldown. Time left: ' + str(
format_time((pokestop_cooldown / 1000) -
seconds_since_epoch)))
elif spin_details['result'] == 4:
log.info("[#] Inventory is full, switching to catch mode...")
#self.config.mode = 'poke'
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:
log.info('[#] may search too often, lets have a rest')
return 11
sleep(8)
return 0
def update(self):
log.info("Обновляем данные сундука")
sleep(5)
response_dict = self.api.get_inventory()
#response_dict = self.api.call()
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_INVENTORY' in response_dict['responses']:
if 'inventory_delta' in response_dict['responses']['GET_INVENTORY']:
inventory_res = response_dict['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']
pokecount = 0
itemcount = 1
for item in inventory_res:
try:
if 'inventory_item_data' in item:
if 'pokemon_data' in item['inventory_item_data']:
pokecount = pokecount + 1
if 'item' in item['inventory_item_data']:
if 'count' in item['inventory_item_data']['item']:
itemcount = itemcount + item['inventory_item_data']['item']['count']
except Exception as e:
log.error("Ошибка:{0}".format(e))
try:
if 'inventory_item_data' in item:
if 'player_stats' in item['inventory_item_data']:
playerdata = item['inventory_item_data']['player_stats']
if 'level' in playerdata: self.scanner.account.statistic.level = playerdata['level']
if 'experience' in playerdata: self.scanner.account.statistic.experience = playerdata['experience']
if 'next_level_xp' in playerdata and 'experience' in playerdata: self.scanner.account.statistic.experience_to_level = (int(playerdata.get('next_level_xp', 0)) -int(playerdata.get('experience', 0)))
if 'pokemons_captured' in playerdata: self.scanner.account.statistic.catched_pokemons = playerdata['pokemons_captured']
if 'poke_stop_visits' in playerdata: self.scanner.account.statistic.visited_pokestops = playerdata['poke_stop_visits']
#if 'km_walked' in playerdata: self.scanner.account.statistic.walked = playerdata['km_walked']
except Exception as e:
log.error("Ошибка:{0}".format(e))
try:
if 'inventory_item_data' in item:
if 'item' in item['inventory_item_data']:
try:
self.inventory.append(item['inventory_item_data']['item'])
except Exception as e:
log.error("Ошибка:{0}".format(e))
if 'item_id' in item['inventory_item_data']['item'] and 'count' in item['inventory_item_data']['item']:
item_id = item['inventory_item_data']['item']['item_id']
item_count = item['inventory_item_data']['item']['count']
if item_id == InventoryItem.ITEM_POKE_BALL: self.scanner.account.statistic.item_ball_poke = item_count
if item_id == InventoryItem.ITEM_GREAT_BALL: self.scanner.account.statistic.item_ball_great = item_count
if item_id == InventoryItem.ITEM_ULTRA_BALL: self.scanner.account.statistic.item_ball_ultra = item_count
if item_id == InventoryItem.ITEM_MASTER_BALL: self.scanner.account.statistic.item_ball_master = item_count
if item_id == InventoryItem.ITEM_POTION: self.scanner.account.statistic.item_potion = item_count
if item_id == InventoryItem.ITEM_SUPER_POTION: self.scanner.account.statistic.item_potion_super = item_count
if item_id == InventoryItem.ITEM_HYPER_POTION: self.scanner.account.statistic.item_potion_hyper = item_count
if item_id == InventoryItem.ITEM_MAX_POTION: self.scanner.account.statistic.item_potion_master = item_count
if item_id == InventoryItem.ITEM_REVIVE: self.scanner.account.statistic.item_revive = item_count
if item_id == InventoryItem.ITEM_MAX_REVIVE: self.scanner.account.statistic.item_revive_master = item_count
if item_id == InventoryItem.ITEM_RAZZ_BERRY: self.scanner.account.statistic.item_berry_razz = item_count
if item_id == InventoryItem.ITEM_BLUK_BERRY: self.scanner.account.statistic.item_berry_bluk = item_count
if item_id == InventoryItem.ITEM_NANAB_BERRY: self.scanner.account.statistic.item_berry_nanab = item_count
if item_id == InventoryItem.ITEM_WEPAR_BERRY: self.scanner.account.statistic.item_berry_wepar = item_count
if item_id == InventoryItem.ITEM_PINAP_BERRY: self.scanner.account.statistic.item_berry_pinap = item_count
except Exception as e:
log.error("Ошибка:{0}".format(e))
self.scanner.account.statistic.bag_pokemons = pokecount
self.scanner.account.statistic.bag_items = itemcount
self.session.commit()
else:
log.warning("Получен неверный статус: {0}".format(response_dict['status_code']))
def _work_at_position(self,
lat,
lng,
alt,
seen_pokemon=False,
seen_pokestop=False,
seen_gym=False,
data=None):
position = (lat, lng, alt)
cellid = get_cell_ids(lat, lng)
timestamp = [
0,
] * len(cellid)
map_cells = list()
self.api.get_map_objects(latitude=f2i(lat),
longitude=f2i(lng),
since_timestamp_ms=timestamp,
cell_id=cellid)
response_dict = self.api.call()
sleep(0.2)
self.search.search(lat, lng)
if response_dict and 'status_code' in response_dict:
if response_dict['status_code'] is 1:
if 'responses' in response_dict:
if 'GET_MAP_OBJECTS' in response_dict['responses']:
if 'status' in response_dict['responses'][
'GET_MAP_OBJECTS']:
if response_dict['responses']['GET_MAP_OBJECTS'][
'status'] is 1:
map_cells = response_dict['responses'][
'GET_MAP_OBJECTS']['map_cells']
# Update current scanner location
self.metrica.take_position(position)
map_cells.sort(key=lambda x: distance(
lat, lng, x['forts'][0]['latitude'],
x['forts'][0]['longitude']) if 'forts' in x
and x['forts'] != [] else 1e6)
log.debug(
"Получена информация о карте в размере {0} ячеек"
.format(len(map_cells)))
for cell in map_cells:
self.metrica.take_search(
parse_map_cell(cell, self.session))
else:
log.warning(
"Получен неверный статус: {0}".format(
response_dict['responses']
['GET_MAP_OBJECTS']['status']))
else:
log.warning("Получен неверный статус: {0}".format(
response_dict['status_code']))
log.info("Ожидаем конца сканирования, и по ходу парсим данные")
while not self.search.requests.empty():
if not self.search.response.empty():
cell = self.search.response.get()
self.metrica.take_search(parse_map_cell(cell, self.session))
self.search.response.task_done()
while not self.search.response.empty():
cell = self.search.response.get()
self.metrica.take_search(parse_map_cell(cell, self.session))
self.search.response.task_done()
self.api.set_position(lat, lng, alt)
for cell in map_cells:
self.ai.work_on_cell(cell,
position,
seen_pokemon=seen_pokemon,
seen_pokestop=seen_pokestop,
seen_gym=seen_gym)