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)