def _execute_pokemon_evolve(self, pokemon, candy_list, cache): pokemon_id = pokemon["id"] pokemon_name = pokemon["name"] pokemon_cp = pokemon["cp"] pokemon_iv = pokemon["iv"] if pokemon_name in cache: return False response_dict = self.api.evolve_pokemon(pokemon_id=pokemon_id) if response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('result', 0) == 1: self.emit_event( 'pokemon_evolved', formatted="Successfully evolved {pokemon} with CP {cp} and IV {iv}!", data={ 'pokemon': pokemon_name, 'iv': pokemon_iv, 'cp': pokemon_cp } ) candy_list[pokemon["candies_family"]] -= pokemon["candies_amount"] sleep(self.evolve_speed) return True else: # cache pokemons we can't evolve. Less server calls cache[pokemon_name] = 1 sleep(0.7) return False
def work(self): lat = self.fort.latitude lng = self.fort.longitude unit = self.config.distance_unit # Unit to use when printing formatted distance fort_id = self.fort.fort_id dist = distance(self.position[0], self.position[1], lat, lng) self.api_wrapper.fort_details(fort_id=fort_id, latitude=lat, longitude=lng) response_dict = self.api_wrapper.call() if response_dict is None: return fort_details = response_dict["fort"] fort_name = fort_details.fort_name logger.log(u"[#] Found fort {} at distance {}".format(fort_name, format_dist(dist, unit))) if dist > 0: logger.log(u"[#] Moving closer to {}".format(fort_name)) position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper.walk_to(self.config.walk, *position) else: self.api_wrapper.set_position(*position) self.api_wrapper.player_update(latitude=lat, longitude=lng) sleep(2) logger.log(u"[#] Now at Pokestop: {}".format(fort_name))
def work(self): lat = self.fort["latitude"] lng = self.fort["longitude"] unit = self.config.distance_unit # Unit to use when printing formatted distance fort_id = self.fort["id"] dist = distance(self.position[0], self.position[1], lat, lng) logger.log("[#] Found fort {} at distance {}".format(fort_id, format_dist(dist, unit))) if dist > 0: logger.log("[#] Need to move closer to Pokestop") position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper.walk_to(self.config.walk, *position) else: self.api.set_position(*position) self.api.player_update(latitude=lat, longitude=lng) logger.log("[#] Arrived at Pokestop") sleep(2) self.api.fort_details(fort_id=self.fort["id"], latitude=lat, longitude=lng) response_dict = self.api.call() if response_dict is None: return fort_details = response_dict.get("responses", {}).get("FORT_DETAILS", {}) fort_name = fort_details.get("name") if fort_details.get("name") else "Unknown" logger.log(u"[#] Now at Pokestop: " + fort_name)
def work(self): lat = self.fort.latitude lng = self.fort.longitude unit = self.config.distance_unit # Unit to use when printing formatted distance fort_id = self.fort.fort_id dist = distance(self.position[0], self.position[1], lat, lng) self.api_wrapper.fort_details(fort_id=fort_id, latitude=lat, longitude=lng) response_dict = self.api_wrapper.call() if response_dict is None: return fort_details = response_dict["fort"] fort_name = fort_details.fort_name self.bot.fire("fort_found", fort_name=fort_name, fort_distance=format_dist(dist, unit)) if dist > 0: self.bot.fire("fort_moving", fort_name=fort_name) position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper.walk_to(self.config.walk, *position) else: self.api_wrapper.set_position(*position) self.api_wrapper.player_update(latitude=lat, longitude=lng) sleep(2) self.bot.fire("fort_arrived", fort_name=fort_name)
def transfer_pokemon(bot, transfer_list=None): # type: (PokemonGoBot, Optional[List[Pokemon]]) -> None def log(text, color="black"): logger.log(text, color=color, prefix="Transfer") if transfer_list is None or len(transfer_list) == 0: log("No Pokemon to transfer.", color="yellow") for index, pokemon in enumerate(transfer_list): pokemon_num = pokemon.pokemon_id pokemon_name = bot.pokemon_list[pokemon_num - 1]["Name"] pokemon_cp = pokemon.combat_power pokemon_potential = pokemon.potential log("Transferring {0} (#{1}) with CP {2} and IV {3} ({4}/{5})".format(pokemon_name, pokemon_num, pokemon_cp, pokemon_potential, index+1, len(transfer_list))) bot.api_wrapper.release_pokemon(pokemon_id=pokemon.unique_id).call() sleep(2) log("Transferred {} Pokemon.".format(len(transfer_list)))
def _execute_pokemon_evolve(self, pokemon, cache): if pokemon.name in cache: return False response_dict = self.api.evolve_pokemon(pokemon_id=pokemon.id) if response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('result', 0) == 1: self.emit_event( 'pokemon_evolved', formatted="Successfully evolved {pokemon} with CP {cp} and IV {iv}!", data={ 'pokemon': pokemon.name, 'iv': pokemon.iv, 'cp': pokemon.cp, 'ncp': '?', 'dps': '?', 'xp': '?' } ) awarded_candies = response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('candy_awarded', 0) inventory.candies().get(pokemon.pokemon_id).consume(pokemon.evolution_cost - awarded_candies) inventory.pokemons().remove(pokemon.id) pokemon = Pokemon(response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('evolved_pokemon_data', {})) inventory.pokemons().add(pokemon) sleep(self.evolve_speed) return True else: # cache pokemons we can't evolve. Less server calls cache[pokemon.name] = 1 sleep(0.7) return False
def update(self, do_sleep=True): response_dict = self._api_wrapper.get_player().get_inventory().call() if do_sleep: sleep(2) if response_dict is None: self._log('Failed to retrieve player and inventory stats', color='red') return False self._player = response_dict['player'] self._inventory = response_dict['inventory'] self._candies = response_dict['candy'] self._pokemon = response_dict['pokemon'] self._candies = response_dict['candy'] self._eggs = response_dict['eggs'] self._egg_incubators = response_dict['egg_incubators'] for item_id in self._inventory: if item_id in self._pokeballs: self._pokeballs[item_id] = self._inventory[item_id] self._event_manager.fire('service_player_updated', data=self) return True
def _do_walk_to(self, speed, from_lat, from_lng, to_lat, to_lng, alt, delta_factor): # type: (float, float, float, float, float, float, float) -> None dist = distance(from_lat, from_lng, to_lat, to_lng) steps = (dist / (self.AVERAGE_STRIDE_LENGTH_IN_METRES * speed)) logger.log("[#] Walking from " + str((from_lat, from_lng)) + " to " + str( str((to_lat, to_lng))) + " for approx. " + str(format_time(ceil(steps)))) if steps != 0: d_lat = (to_lat - from_lat) / steps d_long = (to_lng - from_lng) / steps for _ in range(int(steps)): position_lat, position_lng, _ = self.api_wrapper.get_position() c_lat = position_lat + d_lat + random_lat_long_delta(delta_factor) c_long = position_lng + d_long + random_lat_long_delta(delta_factor) self.api_wrapper.set_position(c_lat, c_long, alt) self.bot.heartbeat() sleep(1) # sleep one second plus a random delta position_lat, position_lng, _ = self.api_wrapper.get_position() self._work_at_position(position_lat, position_lng) self.bot.heartbeat()
def throw_pokeball(self, bot, encounter_id, pokeball, spawn_point_id, pokemon, pos): # type: (PokemonGoBot, int, int, str, Pokemon) -> bool response = bot.api_wrapper.catch_pokemon(encounter_id=encounter_id, pokeball=pokeball, normalized_reticle_size=1.950 - random.random() / 200, spawn_point_id=spawn_point_id, hit_pokemon=True, spin_modifier=1, normalized_hit_position=1) if response is None: return False pokemon_catch_response = response["encounter"] status = pokemon_catch_response.status pokemon_data = bot.pokemon_list[pokemon.pokemon_id - 1] pokemon_name = pokemon_data["Name"] pokemon_id = pokemon_data["Number"] if status is 2: self.log('Failed to capture {}. Trying again!'.format(pokemon_name), 'yellow') bot.fire("pokemon_catch_failed", pokemon=pokemon) sleep(2) return True elif status is 3: self.log('Oh no! {} fled! :('.format(pokemon_name), 'red') bot.fire("pokemon_fled", pokemon=pokemon) return False elif status is 1: self.log('{} has been caught! (CP {}, IV {})'.format(pokemon_name, pokemon.combat_power, pokemon.potential), 'green') xp = pokemon_catch_response.xp stardust = pokemon_catch_response.stardust candy = pokemon_catch_response.candy bot.player_service.add_candy(pokemon_id, candy) self.log("Rewards: {} XP, {} Stardust, {} Candy".format(xp, stardust, candy), "green") bot.fire("pokemon_caught", pokemon=pokemon, position=pos) return False
def _set_team(self): if self.team == 0: return True if self.bot.player_data.get('team', 0) != 0: self.logger.info(u'Team already picked') return True sleep(10) response_dict = self.api.set_player_team(team=self.team) try: result = response_dict['responses']['SET_PLAYER_TEAM']['status'] if result == 1: team_codes = { 1: 'Mystic (BLUE)', 2: 'Valor (RED)', 3: 'Instinct (YELLOW)' } self.logger.info(u'Picked Team {}.'.format( team_codes[self.team])) return True else: error_codes = { 0: 'UNSET', 1: 'SUCCESS', 2: 'TEAM_ALREADY_SET', 3: 'FAILURE' } self.logger.error(u'Error while picking team : {}'.format( error_codes[result])) return False except KeyError: return False
def work(self): lat = self.fort['latitude'] lng = self.fort['longitude'] fortID = self.fort['id'] unit = self.config.distance_unit # Unit to use when printing formatted distance dist = distance(self.position[0], self.position[1], lat, lng) # print('[#] Found fort {} at distance {}m'.format(fortID, dist)) logger.log('[#] Found fort {} at distance {}'.format( fortID, format_dist(dist, unit))) if dist > 10: logger.log('[#] Need to move closer to Pokestop') position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper._walk_to(self.config.walk, *position) else: self.api.set_position(*position) self.api.player_update(latitude=lat, longitude=lng) response_dict = self.api.call() logger.log('[#] Arrived at Pokestop') sleep(2) return response_dict return None
def step(self, speed=None): now = time.time() t = 1 - min(now - self.last_update, 1) sleep(t) self.last_update = now + t if speed is None: speed = uniform(self.bot.config.walk_min, self.bot.config.walk_max) elif speed == self.bot.config.walk_max: # Keep it more Human like... speed = uniform(speed - 0.5, speed + 0.5) origin_lat, origin_lng, origin_alt = self.bot.position new_position = self.get_next_position(origin_lat, origin_lng, origin_alt, self.dest_lat, self.dest_lng, self.dest_alt, speed) self.api.set_position(new_position[0], new_position[1], new_position[2]) self.bot.event_manager.emit("position_update", sender=self, level="debug", data={"current_position": (new_position[0], new_position[1], new_position[2]), "last_position": (origin_lat, origin_lng, origin_alt), "distance": "", "distance_unit": ""}) return self.is_arrived()
def step(self, speed=None): now = time.time() sleep(1 - min(now - self.last_update, 1)) self.last_update = now if speed is None: speed = uniform(self.bot.config.walk_min, self.bot.config.walk_max) origin_lat, origin_lng, origin_alt = self.bot.position new_position = self.get_next_position(origin_lat, origin_lng, origin_alt, self.dest_lat, self.dest_lng, self.dest_alt, speed) self.api.set_position(new_position[0], new_position[1], new_position[2]) self.bot.event_manager.emit("position_update", sender=self, level="debug", data={ "current_position": (new_position[0], new_position[1], new_position[2]), "last_position": (origin_lat, origin_lng, origin_alt), "distance": "", "distance_unit": "" }) return self.is_arrived()
def _execute_pokemon_evolve(self, pokemon, candy_list, cache): pokemon_id = pokemon["id"] pokemon_name = pokemon["name"] pokemon_cp = pokemon["cp"] pokemon_iv = pokemon["iv"] if pokemon_name in cache: return False response_dict = self.api.evolve_pokemon(pokemon_id=pokemon_id) if response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('result', 0) == 1: self.emit_event( 'pokemon_evolved', formatted= "Successfully evolved {pokemon} with CP {cp} and IV {iv}!", data={ 'pokemon': pokemon_name, 'iv': pokemon_iv, 'cp': pokemon_cp }) candy_list[pokemon["candies_family"]] -= pokemon["candies_amount"] sleep(self.evolve_speed) return True else: # cache pokemons we can't evolve. Less server calls cache[pokemon_name] = 1 sleep(0.7) return False
def _execute_pokemon_evolve(self, pokemon, cache): if pokemon.name in cache: return False response_dict = self.api.evolve_pokemon(pokemon_id=pokemon.id) if response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("result", 0) == 1: self.emit_event( "pokemon_evolved", formatted="Successfully evolved {pokemon} with CP {cp} and IV {iv}!", data={"pokemon": pokemon.name, "iv": pokemon.iv, "cp": pokemon.cp, "ncp": "?", "dps": "?", "xp": "?"}, ) awarded_candies = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("candy_awarded", 0) inventory.candies().get(pokemon.pokemon_id).consume(pokemon.evolution_cost - awarded_candies) inventory.pokemons().remove(pokemon.id) pokemon = Pokemon( response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("evolved_pokemon_data", {}) ) inventory.pokemons().add(pokemon) sleep(self.evolve_speed) return True else: # cache pokemons we can't evolve. Less server calls cache[pokemon.name] = 1 sleep(0.7) return False
def throw_pokeball(bot, encounter_id, pokeball, spawn_point_id, combat_power, pokemon_potential, pokemon_name): # type: (PokemonGoBot, int, int, str, int, float, str) -> bool def log(text, color="black"): logger.log(text, color=color, prefix="Catch") bot.api_wrapper.catch_pokemon(encounter_id=encounter_id, pokeball=pokeball, normalized_reticle_size=1.950 - random.random() / 200, spawn_point_id=spawn_point_id, hit_pokemon=True, spin_modifier=1, normalized_hit_position=1) response = bot.api_wrapper.call() if response is None: return False, None pokemon_catch_response = response["encounter"] status = pokemon_catch_response.status if status is 2: log('Failed to capture {}. Trying again!'.format(pokemon_name), 'yellow') sleep(2) return True elif status is 3: log('Oh no! {} fled! :('.format(pokemon_name), 'red') return False elif status is 1: log('{} has been caught! (CP {}, IV {})'.format(pokemon_name, combat_power, pokemon_potential), 'green') xp = pokemon_catch_response.xp stardust = pokemon_catch_response.stardust candy = pokemon_catch_response.candy log("Rewards: {} XP, {} Stardust, {} Candy".format(xp, stardust, candy), "green") return False
def _hatch_eggs(self): self.bot.api.get_hatched_eggs() response_dict = self.bot.api.call() log_color = 'green' try: result = reduce(dict.__getitem__, ["responses", "GET_HATCHED_EGGS"], response_dict) except KeyError: return if 'pokemon_id' in result: pokemon_ids = [id for id in result['pokemon_id']] stardust = result.get('stardust_awarded', 0) candy = result.get('candy_awarded', 0) xp = result.get('experience_awarded', 0) sleep(self.hatching_animation_delay) self.bot.latest_inventory = None try: pokemon_data = self._check_inventory(pokemon_ids) except: pass # just proceed with what we have for pokemon in pokemon_data: pokemon['name'] = self.bot.pokemon_list[(pokemon['pokemon_id']-1)]['Name'] # pokemon ids seem to be offset by one logger.log("-"*30,log_color) logger.log("[!] {} eggs hatched! Received:".format(len(pokemon_data)), log_color) for i in range(len(pokemon_data)): logger.log("-"*30,log_color) logger.log("[!] Pokemon: {}".format(pokemon_data[i]['name']),log_color) logger.log("[!] CP: {}".format(pokemon_data[i]['cp']),log_color) logger.log("[!] IV: {}".format("/".join(map(str,pokemon_data[i]['iv']))),log_color) logger.log("[!] XP: {}".format(xp[i]),log_color) logger.log("[!] Stardust: {}".format(stardust[i]),log_color) logger.log("[!] Candy: {}".format(candy[i]),log_color) logger.log("-"*30,log_color)
def work(self): logger.log('[x] Initial Transfer.') ignlist = self.config.ign_init_trans.split(',') if self.config.cp: logger.log('[x] Will NOT transfer anything above CP {} or these {}'.format( self.config.cp, ignlist)) else: logger.log('[x] Preparing to transfer all Pokemon duplicates, keeping the highest CP of each one type.') pokemon_groups = self._initial_transfer_get_groups() for group_id in pokemon_groups: group_cp = list(pokemon_groups[group_id].keys()) if len(group_cp) > 1: group_cp.sort() group_cp.reverse() pokemon = self.pokemon_list[int(group_id - 1)] pokemon_name = pokemon['Name'] pokemon_num = pokemon['Number'].lstrip('0') for i in range(1, len(group_cp)): if (self.config.cp and group_cp[i] > self.config.cp) or (pokemon_name in ignlist or pokemon_num in ignlist): continue logger.log('[x] Transferring #{} ({}) with CP {}'.format(group_id, pokemon_name, group_cp[i])) self.api_wrapper.release_pokemon(pokemon_id=pokemon_groups[group_id][group_cp[i]]).call() sleep(2) logger.log('[x] Transferring Done.')
def work(self): logger.log('[x] Initial Transfer.') logger.log( '[x] Preparing to transfer all duplicate Pokemon, keeping the highest CP of each type.' ) logger.log('[x] Will NOT transfer anything above CP {}'.format( self.config.initial_transfer)) pokemon_groups = self._initial_transfer_get_groups() for id in pokemon_groups: group_cp = pokemon_groups[id].keys() if len(group_cp) > 1: group_cp.sort() group_cp.reverse() for x in range(1, len(group_cp)): if self.config.initial_transfer and group_cp[ x] > self.config.initial_transfer: continue print('[x] Transferring {} with CP {}'.format( self.pokemon_list[id - 1]['Name'], group_cp[x])) self.api.release_pokemon( pokemon_id=pokemon_groups[id][group_cp[x]]) response_dict = self.api.call() sleep(2) logger.log('[x] Transferring Done.')
def work(self): lat = self.fort['latitude'] lng = self.fort['longitude'] fortID = self.fort['id'] unit = self.config.distance_unit # Unit to use when printing formatted distance dist = distance(self.position[0], self.position[1], lat, lng) # print('[#] Found fort {} at distance {}m'.format(fortID, dist)) self.logger.info('[#] Found fort {} at distance {}'.format( fortID, format_dist(dist, unit))) if dist > 10: self.logger.info('[#] Need to move closer to Pokestop') position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper._walk_to(self.config.walk, *position) else: self.api.set_position(*position) self.api.player_update(latitude=lat, longitude=lng) response_dict = self.api.call() self.logger.info('[#] Arrived at Pokestop') sleep(1) return response_dict return None
def _hatch_eggs(self): response_dict = self.bot.api.get_hatched_eggs() log_color = 'green' try: result = reduce(dict.__getitem__, ["responses", "GET_HATCHED_EGGS"], response_dict) except KeyError: return pokemon_ids = [] if 'pokemon_id' in result: pokemon_ids = [id for id in result['pokemon_id']] stardust = result.get('stardust_awarded', "error") candy = result.get('candy_awarded', "error") xp = result.get('experience_awarded', "error") sleep(self.hatching_animation_delay) self.bot.latest_inventory = None try: pokemon_data = self._check_inventory(pokemon_ids) for pokemon in pokemon_data: # pokemon ids seem to be offset by one if pokemon['pokemon_id'] != -1: pokemon['name'] = self.bot.pokemon_list[( pokemon.get('pokemon_id') - 1)]['Name'] else: pokemon['name'] = "error" except: pokemon_data = [{"name": "error", "cp": "error", "iv": "error"}] if not pokemon_ids or pokemon_data[0]['name'] == "error": self.emit_event('egg_hatched', data={ 'pokemon': 'error', 'cp': 'error', 'iv': 'error', 'exp': 'error', 'stardust': 'error', 'candy': 'error', }) return for i in range(len(pokemon_data)): msg = "Egg hatched with a {pokemon} (CP {cp} - IV {iv}), {exp} exp, {stardust} stardust and {candy} candies." self.bot.metrics.hatched_eggs(1) self.emit_event( 'egg_hatched', formatted=msg, data={ 'pokemon': pokemon_data[i]['name'], 'cp': pokemon_data[i]['cp'], 'iv': "{} {}".format( "/".join(map(str, pokemon_data[i]['iv'])), round(sum(pokemon_data[i]['iv']) / self.max_iv, 2)), 'exp': xp[i], 'stardust': stardust[i], 'candy': candy[i], })
def _set_team(self): if self.team == 0: return True if self.bot.player_data.get('team', 0) != 0: self.logger.info(u'Team already picked') return True sleep(10) request = self.bot.api.create_request() request.set_player_team(team=self.team) response_dict = request.call() try: result = response_dict['responses']['SET_PLAYER_TEAM']['status'] if result == 1: team_codes = { 1: 'Mystic (BLUE)', 2: 'Valor (RED)', 3: 'Instinct (YELLOW)' } self.logger.info(u'Picked Team {}.'.format(team_codes[self.team])) return True else: error_codes = { 0: 'UNSET', 1: 'SUCCESS', 2: 'TEAM_ALREADY_SET', 3: 'FAILURE' } self.logger.error(u'Error while picking team : {}'.format(error_codes[result])) return False except KeyError: return False
def work(self): lat = self.fort['latitude'] lng = self.fort['longitude'] fortID = self.fort['id'] unit = self.config.distance_unit # Unit to use when printing formatted distance dist = distance(self.position[0], self.position[1], lat, lng) # print('[#] Found fort {} at distance {}m'.format(fortID, dist)) logger.log('[#] Ditemukan {} jarak {}'.format( fortID, format_dist(dist, unit))) if dist > 10: logger.log('[#] Harus cari Pokestop') position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper._walk_to(self.config.walk, *position) else: self.api.set_position(*position) self.api.player_update(latitude=lat, longitude=lng) response_dict = self.api.call() logger.log('[#] Sampai di Pokestop') sleep(2) return response_dict return None
def work(self): logger.log('[x] Initial Transfer.') logger.log( '[x] Preparing to transfer all duplicate Pokemon, keeping the highest CP of each type.') logger.log('[x] Will NOT transfer anything above CP {}'.format( self.config.initial_transfer)) pokemon_groups = self._initial_transfer_get_groups() for id in pokemon_groups: group_cp = pokemon_groups[id].keys() if len(group_cp) > 1: group_cp.sort() group_cp.reverse() for x in range(1, len(group_cp)): if self.config.initial_transfer and group_cp[x] > self.config.initial_transfer: continue print('[x] Transferring {} with CP {}'.format( self.pokemon_list[id - 1]['Name'], group_cp[x])) self.api.release_pokemon( pokemon_id=pokemon_groups[id][group_cp[x]]) response_dict = self.api.call() sleep(0.1) logger.log('[x] Transferring Done.')
def _execute_pokemon_evolve(self, pokemon, cache): if pokemon.name in cache: return False response_dict = self.api.evolve_pokemon(pokemon_id=pokemon.unique_id) if response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('result', 0) == 1: xp = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("experience_awarded", 0) evolution = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("evolved_pokemon_data", {}) awarded_candies = response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('candy_awarded', 0) candy = inventory.candies().get(pokemon.pokemon_id) candy.consume(pokemon.evolution_cost - awarded_candies) self.emit_event( 'pokemon_evolved', formatted="*Evolved {}* (IV {}) (CP {}) ({} candies) (+{} xp)".format(pokemon.name, pokemon.iv, pokemon.cp, candy.quantity, xp), data={ 'pokemon': pokemon.name, 'iv': pokemon.iv, 'cp': pokemon.cp, 'candy': candy.quantity, 'xp': xp, } ) inventory.pokemons().remove(pokemon.unique_id) new_pokemon = inventory.Pokemon(evolution) inventory.pokemons().add(new_pokemon) inventory.player().exp += xp action_delay(self.min_evolve_speed, self.max_evolve_speed) evolve_result = True else: # cache pokemons we can't evolve. Less server calls cache[pokemon.name] = 1 sleep(0.7) evolve_result = False with self.bot.database as conn: c = conn.cursor() c.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='evolve_log'") result = c.fetchone() while True: if result[0] == 1: conn.execute('''INSERT INTO evolve_log (pokemon, iv, cp) VALUES (?, ?, ?)''', (pokemon.name, pokemon.iv, pokemon.cp)) break else: self.emit_event( 'evolve_log', sender=self, level='info', formatted="evolve_log table not found, skipping log" ) break return evolve_result
def _execute_pokemon_evolve(self, pokemon, cache): if pokemon.name in cache: return False response_dict = self.bot.api.evolve_pokemon(pokemon_id=pokemon.unique_id) if response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('result', 0) == 1: xp = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("experience_awarded", 0) evolution = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("evolved_pokemon_data", {}) awarded_candies = response_dict.get('responses', {}).get('EVOLVE_POKEMON', {}).get('candy_awarded', 0) candy = inventory.candies().get(pokemon.pokemon_id) candy.consume(pokemon.evolution_cost - awarded_candies) self.emit_event( 'pokemon_evolved', formatted="*Evolved {}* (IV {}) (CP {}) ({} candies) (+{} xp)".format(pokemon.name, pokemon.iv, pokemon.cp, candy.quantity, xp), data={ 'pokemon': pokemon.name, 'iv': pokemon.iv, 'cp': pokemon.cp, 'candy': candy.quantity, 'xp': xp, } ) inventory.pokemons().remove(pokemon.unique_id) new_pokemon = inventory.Pokemon(evolution) inventory.pokemons().add(new_pokemon) inventory.player().exp += xp action_delay(self.min_evolve_speed, self.max_evolve_speed) evolve_result = True else: # cache pokemons we can't evolve. Less server calls cache[pokemon.name] = 1 sleep(0.7) evolve_result = False with self.bot.database as conn: c = conn.cursor() c.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='evolve_log'") result = c.fetchone() while True: if result[0] == 1: conn.execute('''INSERT INTO evolve_log (pokemon, iv, cp) VALUES (?, ?, ?)''', (pokemon.name, pokemon.iv, pokemon.cp)) break else: self.emit_event( 'evolve_log', sender=self, level='info', formatted="evolve_log table not found, skipping log" ) break return evolve_result
def work(self, response_dict=None): response_dict = response_dict or self.create_encounter_api_call() # validate response if not response_dict: return WorkerResult.ERROR try: responses = response_dict['responses'] response = responses[self.response_key] if response[self.response_status_key] != ENCOUNTER_STATUS_SUCCESS: if response[self.response_status_key] == ENCOUNTER_STATUS_NOT_IN_RANGE: self.emit_event('pokemon_not_in_range', formatted='Pokemon went out of range!') elif response[self.response_status_key] == ENCOUNTER_STATUS_POKEMON_INVENTORY_FULL: self.emit_event('pokemon_inventory_full', formatted='Your Pokemon inventory is full! Could not catch!') return WorkerResult.ERROR except KeyError: return WorkerResult.ERROR # get pokemon data pokemon_data = response['wild_pokemon']['pokemon_data'] if 'wild_pokemon' in response else response['pokemon_data'] pokemon = Pokemon(pokemon_data) # skip ignored pokemon if not self._should_catch_pokemon(pokemon): return WorkerResult.SUCCESS # log encounter self.emit_event( 'pokemon_appeared', formatted='A wild {pokemon} appeared! [CP {cp}] [Potential {iv}] [A/D/S {iv_display}]', data={ 'pokemon': pokemon.name, 'cp': pokemon.cp, 'iv': pokemon.iv, 'iv_display': pokemon.iv_display, 'encounter_id': self.pokemon['encounter_id'], 'latitude': self.pokemon['latitude'], 'longitude': self.pokemon['longitude'], 'pokemon_id': pokemon.pokemon_id } ) # simulate app sleep(3) # check for VIP pokemon is_vip = self._is_vip_pokemon(pokemon) if is_vip: self.emit_event('vip_pokemon', formatted='This is a VIP pokemon. Catch!!!') # catch that pokemon! encounter_id = self.pokemon['encounter_id'] catch_rate_by_ball = [0] + response['capture_probability']['capture_probability'] # offset so item ids match indces self._do_catch(pokemon, encounter_id, catch_rate_by_ball, is_vip=is_vip) # simulate app time.sleep(5)
def _step_to(self, lat, lng, alt): # type: (float, float, float) -> None self.api_wrapper.set_position(lat, lng, alt) self.current_lat = lat self.current_lng = lng self.current_alt = alt sleep(1) # sleep one second plus a random delta
def step(self): self.polyline_walker.unpause() sleep(1) self.polyline_walker.pause() cLat, cLng = self.polyline_walker.get_pos()[0] self.api.set_position(round(cLat, 5), round(cLng, 5), 0) self.bot.heartbeat() if self.destLat == cLat and self.destLng == cLng: return True
def _nickname_pokemon(self, pokemon): """This requies a pokemon object containing all the standard fields: id, ivs, cp, etc""" new_name = "" instance_id = pokemon.get("id", 0) if not instance_id: self.emit_event("api_error", formatted="Failed to get pokemon name, will not rename.") return id = pokemon.get("pokemon_id", 0) - 1 name = self.bot.pokemon_list[id]["Name"] cp = pokemon.get("cp", 0) iv_attack = pokemon.get("individual_attack", 0) iv_defense = pokemon.get("individual_defense", 0) iv_stamina = pokemon.get("individual_stamina", 0) iv_list = [iv_attack, iv_defense, iv_stamina] iv_ads = "/".join(map(str, iv_list)) iv_sum = sum(iv_list) iv_pct = "{:0.0f}".format(100 * iv_sum / 45.0) log_color = "red" try: new_name = self.template.format( name=name, id=id, cp=cp, iv_attack=iv_attack, iv_defense=iv_defense, iv_stamina=iv_stamina, iv_ads=iv_ads, iv_sum=iv_sum, iv_pct=iv_pct, )[:12] except KeyError as bad_key: self.emit_event( "config_error", formatted="Unable to nickname {} due to bad template ({})".format(name, bad_key) ) if pokemon.get("nickname", "") == new_name: return response = self.bot.api.nickname_pokemon(pokemon_id=instance_id, nickname=new_name) sleep(1.2) try: result = reduce(dict.__getitem__, ["responses", "NICKNAME_POKEMON"], response) except KeyError: self.emit_event("api_error", formatted="Attempt to nickname received bad response from server.") result = result["result"] new_name = new_name or name if result == 0: self.emit_event("unset_pokemon_nickname", formatted="Pokemon nickname unset.") elif result == 1: self.emit_event( "rename_pokemon", formatted="Pokemon {old_name} renamed to {current_name}", data={"old_name": name, "current_name": new_name}, ) pokemon["nickname"] = new_name elif result == 2: self.emit_event( "pokemon_nickname_invalid", formatted="Nickname {nickname} is invalid", data={"nickname": new_name} )
def _nickname_pokemon(self,pokemon): """This requies a pokemon object containing all the standard fields: id, ivs, cp, etc""" new_name = "" instance_id = pokemon.get('id',0) if not instance_id: logger.log("Pokemon instance id returned 0. Can't rename.",'red') return id = pokemon.get('pokemon_id',0)-1 name = self.bot.pokemon_list[id]['Name'] cp = pokemon.get('cp',0) iv_attack = pokemon.get('individual_attack',0) iv_defense = pokemon.get('individual_defense',0) iv_stamina = pokemon.get('individual_stamina',0) iv_list = [iv_attack,iv_defense,iv_stamina] iv_ads = "/".join(map(str,iv_list)) iv_sum = sum(iv_list) iv_pct = "{:0.0f}".format(100*iv_sum/45.0) log_color = 'red' try: new_name = self.template.format(name=name, id=id, cp=cp, iv_attack=iv_attack, iv_defense=iv_defense, iv_stamina=iv_stamina, iv_ads=iv_ads, iv_sum=iv_sum, iv_pct=iv_pct)[:12] except KeyError as bad_key: logger.log("Unable to nickname {} due to bad template ({})".format(name,bad_key),log_color) if pokemon.get('nickname', "") == new_name: return self.bot.api.nickname_pokemon(pokemon_id=instance_id,nickname=new_name) response = self.bot.api.call() sleep(1.2) try: result = reduce(dict.__getitem__, ["responses", "NICKNAME_POKEMON"], response) except KeyError: logger.log("Attempt to nickname received bad response from server.",log_color) if self.bot.config.debug: logger.log(response,log_color) return result = result['result'] if new_name == "": new_name = name output = { 0: 'Nickname unset', 1: 'Nickname set successfully! {} is now {}'.format(name,new_name), 2: 'Invalid nickname! ({})'.format(new_name), 3: 'Pokemon not found.', 4: 'Pokemon is egg' }[result] if result==1: log_color='green' pokemon['nickname'] = new_name logger.log(output,log_color)
def _hatch_eggs(self): response_dict = self.bot.api.get_hatched_eggs() log_color = 'green' try: result = reduce(dict.__getitem__, ["responses", "GET_HATCHED_EGGS"], response_dict) except KeyError: return pokemon_ids = [] if 'pokemon_id' in result: pokemon_ids = [id for id in result['pokemon_id']] stardust = result.get('stardust_awarded', "error") candy = result.get('candy_awarded', "error") xp = result.get('experience_awarded', "error") sleep(self.hatching_animation_delay) self.bot.latest_inventory = None try: pokemon_data = self._check_inventory(pokemon_ids) for pokemon in pokemon_data: # pokemon ids seem to be offset by one if pokemon['pokemon_id']!=-1: pokemon['name'] = self.bot.pokemon_list[(pokemon.get('pokemon_id')-1)]['Name'] else: pokemon['name'] = "error" except: pokemon_data = [{"name":"error","cp":"error","iv":"error"}] if not pokemon_ids or pokemon_data[0]['name'] == "error": self.emit_event( 'egg_hatched', data={ 'pokemon': 'error', 'cp': 'error', 'iv': 'error', 'exp': 'error', 'stardust': 'error', 'candy': 'error', } ) return for i in range(len(pokemon_data)): msg = "Egg hatched with a {pokemon} (CP {cp} - IV {iv}), {exp} exp, {stardust} stardust and {candy} candies." self.bot.metrics.hatched_eggs(1) self.emit_event( 'egg_hatched', formatted=msg, data={ 'pokemon': pokemon_data[i]['name'], 'cp': pokemon_data[i]['cp'], 'iv': "{} {}".format( "/".join(map(str, pokemon_data[i]['iv'])), round(sum(pokemon_data[i]['iv'])/self.max_iv, 2) ), 'exp': xp[i], 'stardust': stardust[i], 'candy': candy[i], } )
def step(self): cLat, cLng = self.api._position_lat, self.api._position_lng while (cLat, cLng) != self.polyline_walker.get_pos()[0]: self.polyline_walker.unpause() sleep(1) self.polyline_walker.pause() cLat, cLng = self.polyline_walker.get_pos()[0] self.api.set_position(round(cLat, 5), round(cLng, 5), 0) self.bot.heartbeat() return True
def take_step(self): if self.first_step: self.first_step = False position = (self.origin_lat, self.origin_lon, 0.0) else: position_lat, position_lng, _ = self.api_wrapper.get_position() position = (position_lat, position_lng, 0.0) self.api_wrapper.set_position(*position) self._work_at_position(position[0], position[1]) sleep(5)
def evolve_pokemon(self, pokemon): while pokemon.unique_id in self.evolution_map: pokemon = self.evolution_map[pokemon.unique_id] if self.config_evolve and (not self.bot.config.test): response_dict = self.bot.api.evolve_pokemon(pokemon_id=pokemon.unique_id) else: response_dict = {"responses": {"EVOLVE_POKEMON": {"result": SUCCESS}}} if not response_dict: return False result = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("result", 0) if result != SUCCESS: return False xp = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("experience_awarded", 0) candy_awarded = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("candy_awarded", 0) candy = inventory.candies().get(pokemon.pokemon_id) evolution = response_dict.get("responses", {}).get("EVOLVE_POKEMON", {}).get("evolved_pokemon_data", {}) if self.config_evolve and (not self.bot.config.test): candy.consume(pokemon.evolution_cost - candy_awarded) inventory.player().exp += xp self.emit_event("pokemon_evolved", formatted="Evolved {pokemon} [IV {iv}] [CP {cp}] [{candy} candies] [+{xp} xp]", data={"pokemon": pokemon.name, "iv": pokemon.iv, "cp": pokemon.cp, "candy": candy.quantity, "xp": xp}) if self.config_evolve and (not self.bot.config.test): new_pokemon = inventory.Pokemon(evolution) self.evolution_map[pokemon.unique_id] = new_pokemon inventory.pokemons().remove(pokemon.unique_id) inventory.pokemons().add(new_pokemon) with self.bot.database as db: cursor = db.cursor() cursor.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='evolve_log'") db_result = cursor.fetchone() if db_result[0] == 1: db.execute("INSERT INTO evolve_log (pokemon, iv, cp) VALUES (?, ?, ?)", (pokemon.name, pokemon.iv, pokemon.cp)) sleep(self.config_evolve_time, 0.1) return True
def work(self): bad_pokemons = [p for p in inventory.pokemons().all() if p.is_bad] if len(bad_pokemons) > 0: if self._should_print(): self.logger.warning("You have %s bad (slashed) Pokemon!" % len(bad_pokemons)) self._compute_next_update() sleep(1) if self.config_transfer: self.transfer_pokemon(bad_pokemons) return WorkerResult.SUCCESS
def take_step(self): position = (0, 0, 0) if self.first_step: self.first_step = False position = (self.origin_lat, self.origin_lon, 0.0) else: position_lat, position_lng, _ = self.api.get_position() position = (i2f(position_lat), i2f(position_lng), 0.0) self.api.set_position(*position) self._work_at_position(position[0], position[1], True) sleep(5)
def _do_evolve(self, bot, name): pokemon_list = bot.player_service.get_pokemon() base_pokemon = self._get_base_pokemon(bot, name) base_name = base_pokemon['name'] pokemon_id = base_pokemon['id'] num_evolve = base_pokemon['requirements'] pokemon_candies = bot.player_service.get_candy(int(pokemon_id)) evolve_list = self.config["evolve_filter"] if base_name in evolve_list and evolve_list[base_name][ "evolve"] is True: if num_evolve is None: self.log('Can\'t evolve {}'.format(base_name), color='yellow') return pokemon_evolve = [ pokemon for pokemon in pokemon_list if pokemon.pokemon_id is pokemon_id ] if pokemon_evolve is None: return pokemon_evolve.sort(key=lambda p: p.combat_power, reverse=True) num_evolved = 0 for pokemon in pokemon_evolve: if num_evolve > pokemon_candies: break bot.api_wrapper.evolve_pokemon(pokemon_id=pokemon.unique_id) response = bot.api_wrapper.call() if response['evolution'].success: pokemon_candies -= (num_evolve - 1) num_evolved += 1 evolved_id = response['evolution'].get_pokemon().pokemon_id self.log('Evolved {} into {}'.format( base_name, bot.pokemon_list[evolved_id - 1]['Name'])) self.event_manager.fire_with_context('pokemon_evolved', bot, pokemon=pokemon, evolution=evolved_id) sleep(2) else: self.log('Evolving {} failed'.format(base_name), color='red') break if num_evolve > pokemon_candies: self.log( 'Not enough candies for {} to evolve'.format(base_name), color='yellow') elif len(pokemon_evolve) > num_evolved: self.log('Stopped evolving due to error', color='red') else: self.log('Evolved {} {}(s)'.format(num_evolved, base_name))
def _step_to(self, lat, lng, alt): # type: (float, float, float) -> None self.api_wrapper.set_position(lat, lng, alt) self.current_lat = lat self.current_lng = lng self.current_alt = alt self.bot.fire("position_updated", coordinates=(lat, lng, alt)) self.bot.heartbeat() sleep(1) # sleep one second plus a random delta
def _step_to(self, lat, lng, alt): # type: (float, float, float) -> None self.api_wrapper.set_position(lat, lng, alt) new_lat, new_lng, new_alt = self.api_wrapper.get_position() self.current_lat = new_lat self.current_lng = new_lng self.current_alt = new_alt self.bot.fire("position_updated", coords=(new_lat, new_lng, new_alt)) self.bot.heartbeat() sleep(1) # sleep one second plus a random delta
def step(self): if (self.dLat == 0 and self.dLng == 0) or self.dist < self.speed: self.api.set_position(self.destLat + random_lat_long_delta(), self.destLng + random_lat_long_delta(), self.alt) self.bot.event_manager.emit('position_update', sender=self, level='debug', data={ 'current_position': (self.destLat, self.destLng), 'last_position': (self.initLat, self.initLng), 'distance': '', 'distance_unit': '' }) self.bot.heartbeat() return True totalDLat = (self.destLat - self.initLat) totalDLng = (self.destLng - self.initLng) magnitude = self._pythagorean(totalDLat, totalDLng) unitLat = totalDLat / magnitude unitLng = totalDLng / magnitude scaledDLat = unitLat * self.magnitude scaledDLng = unitLng * self.magnitude cLat = self.initLat + scaledDLat + random_lat_long_delta() cLng = self.initLng + scaledDLng + random_lat_long_delta() self.api.set_position(cLat, cLng, self.alt) self.bot.event_manager.emit('position_update', sender=self, level='debug', data={ 'current_position': (cLat, cLng), 'last_position': (self.initLat, self.initLng), 'distance': '', 'distance_unit': '' }) self.bot.heartbeat() sleep(1) # sleep one second plus a random delta
def work(self): if self.config.fill_incubators: self.api_wrapper.get_inventory() response_dict = self.api_wrapper.call() eggs = [egg.unique_id for egg in response_dict["eggs"] if egg.egg_incubator_id == ""] incubators = [incu.unique_id for incu in response_dict["egg_incubators"] if incu.pokemon_id == 0 and ( self.config.use_all_incubators or incu.item_id == 901)] for incubator_unique_id in incubators: if len(eggs) > 0: self.api_wrapper.use_item_egg_incubator(item_id=incubator_unique_id, pokemon_id=eggs.pop()) self.api_wrapper.call() logger.log("[+] Put an egg into an incubator", "green") else: logger.log("[+] No more free incubators", "yellow") lat = self.fort.latitude lng = self.fort.longitude unit = self.config.distance_unit # Unit to use when printing formatted distance fort_id = self.fort.fort_id dist = distance(self.position[0], self.position[1], lat, lng) self.api_wrapper.fort_details(fort_id=fort_id, latitude=lat, longitude=lng) response_dict = self.api_wrapper.call() if response_dict is None: return fort_details = response_dict["fort"] fort_name = fort_details.fort_name logger.log(u"[#] Found fort {} at distance {}".format(fort_name, format_dist(dist, unit))) if dist > 0: logger.log(u"[#] Moving closer to {}".format(fort_name)) position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper.walk_to(self.config.walk, *position) else: self.api_wrapper.set_position(*position) self.api_wrapper.player_update(latitude=lat, longitude=lng) sleep(2) logger.log(u"[#] Now at Pokestop: {}".format(fort_name))
def _check_tutorial_state(self): self._player = self.bot.player_data tutorial_state = self._player.get('tutorial_state', []) # LEGAL_SCREEN = 0 if not 0 in tutorial_state: sleep(2) if self._set_tutorial_state(0): self.logger.info('Completed legal screen') tutorial_state = self._player.get('tutorial_state', []) else: return False # AVATAR_SELECTION = 1 if not 1 in tutorial_state: sleep(7) if self._set_avatar(): if self._set_tutorial_state(1): self.logger.info('Completed avatar selection') tutorial_state = self._player.get('tutorial_state', []) else: return False else: self.logger.error('Error during avatar selection') return False # POKEMON_CAPTURE = 3 if not 3 in tutorial_state: sleep(10) if self._encounter_tutorial(): self.logger.info('Completed first capture') else: self.logger.error('Error during first capture') return False # NAME_SELECTION = 4 if not 4 in tutorial_state: if not self.nickname: self.logger.info("No nickname defined in config") return False self.logger.info(u'Trying to set {} as nickname'.format( self.nickname)) sleep(5) if self._set_nickname(self.nickname): self._set_tutorial_state(4) tutorial_state = self._player.get('tutorial_state', []) else: self.logger.error('Error trying to set nickname') return False # FIRST_TIME_EXPERIENCE_COMPLETE = 7 if not 7 in tutorial_state: if self._set_tutorial_state(7): self.logger.info('Completed first time experience') else: return False return True
def _init_plugins(self): # create a plugin manager self.plugin_manager = PluginManager('./plugins') # load all plugin modules for plugin in self.plugin_manager.get_available_plugins(): if plugin not in self.config.exclude_plugins: self.plugin_manager.load_plugin(plugin) else: logger.log("Not loading plugin \"{}\"".format(plugin), color="red", prefix="Plugins") loaded_plugins = sorted(self.plugin_manager.get_loaded_plugins().keys()) sleep(2) logger.log("Plugins loaded: {}".format(loaded_plugins), color="green", prefix="Plugins") logger.log("Events available: {}".format(manager.get_registered_events()), color="green", prefix="Events")
def navigate(self, map_cells): # type: (List[Cell]) -> List[Direction] if not len(self.camping_sites): current_lat, current_lng, _ = self.api_wrapper.get_position() self.camping_sites.append((current_lat, current_lng)) try: lat, lng = self.camping_sites[self.pointer] position = (lat, lng, 0.0) yield Destination(*position, name="Camping position at {},{}".format(lat, lng), exact_location=True) sleep(5) except IndexError: self.logger.log("No campsite location found", color="red", prefix="Camper")
def step(self): cLat, cLng = self.api._position_lat, self.api._position_lng if self.dist < 10: # 10m, add config? set it at constants? return True self.polyline_walker.unpause() sleep(1) self.polyline_walker.pause() cLat, cLng = self.polyline_walker.get_pos() alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max) self.api.set_position(cLat, cLng, alt) self.bot.heartbeat() return False
def start_rest(self): duration = int(uniform(self.rest_duration_min, self.rest_duration_max)) resume = datetime.now() + timedelta(seconds=duration) self.emit_event( 'vanish_limit_reached', formatted= "Vanish limit reached! Taking a rest now for {duration}, will resume at {resume}.", data={ 'duration': str(timedelta(seconds=duration)), 'resume': resume.strftime("%H:%M:%S") }) sleep(duration) self.rest_completed = True self.bot.login()
def endLaps(self): duration = int(uniform(self.timer_restart_min, self.timer_restart_max)) resume = dt.now() + timedelta(seconds=duration) self.emit_event( 'path_lap_end', formatted= "Great job, lot of calories burned! Taking a break now for {duration}, will resume at {resume}.", data={ 'duration': str(timedelta(seconds=duration)), 'resume': resume.strftime("%H:%M:%S") }) self.number_lap = 0 # at the end of the break, start again sleep(duration) self.bot.login()
def step(self): if (self.dLat == 0 and self.dLng == 0) or self.dist < self.speed: self.api.set_position(self.destLat, self.destLng, self.alt) self.bot.event_manager.emit('position_update', sender=self, level='debug', data={ 'current_position': (self.destLat, self.destLng), 'last_position': (self.initLat, self.initLng), 'distance': '', 'distance_unit': '' }) self.bot.heartbeat() # This step is implicitlly teleporting... # and since now we have variable speeds it can be quite often that self.dist < self.speed # especially for the polyline # need to speed one even when teleporting small distances sleep(1) # sleep one second plus a random delta return True self._new_position = self._get_next_pos(self.initLat, self.initLng, self.bearing, self.speed, self.precision) cAlt = self.initAlt + random_alt_delta() self.api.set_position(self._new_position[0], self._new_position[1], cAlt) self.bot.event_manager.emit( 'position_update', sender=self, level='debug', data={ 'current_position': (self._new_position[0], self._new_position[1], cAlt), 'last_position': (self.initLat, self.initLng, self.initAlt), 'distance': '', 'distance_unit': '' }) self.bot.heartbeat() sleep(1) # sleep one second plus a random delta
def _execute_pokemon_evolve(self, pokemon, cache): pokemon_id = pokemon[0] pokemon_name = pokemon[1] pokemon_cp = pokemon[2] if pokemon_name in cache: return self.api.evolve_pokemon(pokemon_id=pokemon_id) response_dict = self.api.call() status = response_dict['responses']['EVOLVE_POKEMON']['result'] if status == 1: print('[#] Successfully evolved {} with {} cp!'.format( pokemon_name, pokemon_cp)) else: # cache pokemons we can't evolve. Less server calls cache[pokemon_name] = 1 sleep(5.7)
def recycle_items(self, bot, recyclable_items=None): if recyclable_items is None: return recycled_items = 0 for item_type in recyclable_items: quantity = recyclable_items[item_type] item_name = bot.item_list[item_type] self.log("Recycling {} {}{}".format(quantity, item_name, "s" if quantity > 1 else ""), color="green") bot.api_wrapper.recycle_inventory_item(item_id=item_type, count=quantity).call() recycled_items += quantity sleep(2) if recycled_items > 0: self.log("Recycled {} items.".format(recycled_items), color="green")
def throw_pokeball(bot, encounter_id, pokeball, spawn_point_id, pokemon): # type: (PokemonGoBot, int, int, str, Pokemon) -> bool def log(text, color="black"): logger.log(text, color=color, prefix="Catch") bot.api_wrapper.catch_pokemon(encounter_id=encounter_id, pokeball=pokeball, normalized_reticle_size=1.950 - random.random() / 200, spawn_point_id=spawn_point_id, hit_pokemon=True, spin_modifier=1, normalized_hit_position=1) response = bot.api_wrapper.call() if response is None: return False, None pokemon_catch_response = response["encounter"] status = pokemon_catch_response.status pokemon_name = bot.pokemon_list[pokemon.pokemon_id]["Name"] if status is 2: log('Failed to capture {}. Trying again!'.format(pokemon_name), 'yellow') bot.fire("pokemon_catch_failed", pokemon=pokemon) sleep(2) return True elif status is 3: log('Oh no! {} fled! :('.format(pokemon_name), 'red') bot.fire("pokemon_fled", pokemon=pokemon) return False elif status is 1: log( '{} has been caught! (CP {}, IV {})'.format( pokemon_name, pokemon.combat_power, pokemon.potential), 'green') xp = pokemon_catch_response.xp stardust = pokemon_catch_response.stardust candy = pokemon_catch_response.candy log( "Rewards: {} XP, {} Stardust, {} Candy".format( xp, stardust, candy), "green") bot.fire("pokemon_caught", pokemon=pokemon) return False
def step(self): self.polyline_walker = PolylineObjectHandler.cached_polyline( self.actual_pos, (self.destLat, self.destLng), self.speed) if self.dist < 10: # 10m, add config? set it at constants? return True self.polyline_walker.unpause() sleep(1) self.polyline_walker.pause() cLat, cLng = self.polyline_walker.get_pos() cAlt = self.polyline_walker.get_alt() self.api.set_position(cLat, cLng, cAlt) self.actual_pos = ( cLat, cLng ) # might be a case this instance is reused in the future... self.bot.heartbeat() return False
def transfer_pokemon(self, bot, transfer_list=None, filter_list=None): # type: (PokemonGoBot, Optional[List[Pokemon]], Optional[List[str]]) -> None filter_list = [] if filter_list is None else filter_list if transfer_list is None or len(transfer_list) == 0: return False output_str = "Transferring {} Pokemon".format(len(transfer_list)) # Print out the list of filters used filter_list = filter_list[::-1] if len(filter_list) > 1: output_str += " " + ", ".join(filter_list[:-1]) + " and " + filter_list[-1] elif len(filter_list) == 1: output_str += " " + filter_list[0] self.log(output_str) for index, pokemon in enumerate(transfer_list): pokemon_num = pokemon.pokemon_id pokemon_name = bot.pokemon_list[pokemon_num - 1]["Name"] pokemon_cp = pokemon.combat_power pokemon_potential = pokemon.potential self.log( "Transferring {0} (#{1}) with CP {2} and IV {3} ({4}/{5})".format( pokemon_name, pokemon_num, pokemon_cp, pokemon_potential, index + 1, len(transfer_list) ) ) bot.api_wrapper.release_pokemon(pokemon_id=pokemon.unique_id).call() sleep(2) bot.player_service.add_candy(pokemon_num, 1) bot.fire('after_transfer_pokemon', pokemon=pokemon) self.log("Transferred {} Pokemon.".format(len(transfer_list)))
def transfer_pokemon(bot, transfer_list=None): # type: (PokemonGoBot, Optional[List[Pokemon]]) -> None def log(text, color="black"): logger.log(text, color=color, prefix="Transfer") if transfer_list is None or len(transfer_list) == 0: log("No Pokemon to transfer.", color="yellow") for index, pokemon in enumerate(transfer_list): pokemon_num = pokemon.pokemon_id pokemon_name = bot.pokemon_list[pokemon_num - 1]["Name"] pokemon_cp = pokemon.combat_power pokemon_potential = pokemon.potential log("Transferring {0} (#{1}) with CP {2} and IV {3} ({4}/{5})".format( pokemon_name, pokemon_num, pokemon_cp, pokemon_potential, index + 1, len(transfer_list))) bot.api_wrapper.release_pokemon(pokemon_id=pokemon.unique_id).call() sleep(2) log("Transferred {} Pokemon.".format(len(transfer_list)))