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 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 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 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 _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)))
