def _collect_level_reward(self):
request = self.bot.api.create_request()
request.level_up_rewards(level=self.current_level)
response_dict = request.call()
if 'status_code' in response_dict and response_dict['status_code'] == 1:
data = (response_dict
.get('responses', {})
.get('LEVEL_UP_REWARDS', {})
.get('items_awarded', []))
for item in data:
if 'item_id' in item and str(item['item_id']) in self.bot.item_list:
got_item = self.bot.item_list[str(item['item_id'])]
item['name'] = got_item
count = 'item_count' in item and item['item_count'] or 0
inventory.items().get(item['item_id']).add(count)
self.emit_event(
'level_up_reward',
formatted='Received level up reward: {items}',
data={
# [{'item_id': 3, 'name': u'Ultraball', 'item_count': 10}, {'item_id': 103, 'name': u'Hyper Potion', 'item_count': 10}]
'items': ', '.join(["{}x {}".format(x['item_count'], x['name']) for x in data])
}
)
def _collect_level_reward(self):
request = self.bot.api.create_request()
request.level_up_rewards(level=self.current_level)
response_dict = request.call()
if 'status_code' in response_dict and response_dict['status_code'] == 1:
data = (response_dict.get('responses',
{}).get('LEVEL_UP_REWARDS',
{}).get('items_awarded', []))
for item in data:
if 'item_id' in item and str(
item['item_id']) in self.bot.item_list:
got_item = self.bot.item_list[str(item['item_id'])]
item['name'] = got_item
count = 'item_count' in item and item['item_count'] or 0
inventory.items().get(item['item_id']).add(count)
self.emit_event(
'level_up_reward',
formatted='Received level up reward: {items}',
data={
# [{'item_id': 3, 'name': u'Ultraball', 'item_count': 10}, {'item_id': 103, 'name': u'Hyper Potion', 'item_count': 10}]
'items':
', '.join([
"{}x {}".format(x['item_count'], x['name'])
for x in data
])
})
def _revive_pokemon(self, pokemon):
item = Item.ITEM_REVIVE.value
amount = inventory.items().get(item).count
if amount == 0:
self.logger.info("No normal revives left, using MAX revive!")
item = Item.ITEM_MAX_REVIVE.value
amount = inventory.items().get(item).count
if amount > 0:
response_dict_revive = self.bot.api.use_item_revive(
item_id=item, pokemon_id=pokemon.unique_id)
action_delay(2, 3)
if response_dict_revive:
result = response_dict_revive.get('responses', {}).get(
'USE_ITEM_REVIVE', {}).get('result', 0)
revive_item = inventory.items().get(item)
# Remove the revive from the iventory
revive_item.remove(1)
if result is 1: # Request success
self.emit_event('revived_pokemon',
formatted='Revived {name}.',
data={'name': pokemon.name})
if item == Item.ITEM_REVIVE.value:
pokemon.hp = int(pokemon.hp_max / 2)
self.to_heal.append(pokemon)
else:
# Set pokemon as revived
pokemon.hp = pokemon.hp_max
return True
else:
self.emit_event('revived_pokemon',
level='error',
formatted='Failed to revive {name}!',
data={'name': pokemon.name})
return False
def work(self):
if self._should_run():
self.start_time = time.time()
request = self.bot.api.create_request()
request.use_incense(incense_type=self._get_type())
response_dict = request.call()
result = response_dict.get('responses', {}).get('USE_INCENSE', {}).get('result', 0)
if result is 1:
self.emit_event(
'use_incense',
formatted="Using {type} incense. {incense_count} incense remaining",
data={
'type': self.types.get(type, 'Unknown'),
'incense_count': inventory.items().get(type).count
}
)
else:
self.emit_event(
'use_incense',
formatted="Unable to use incense {type}. {incense_count} incense remaining",
data={
'type': self.types.get(type, 'Unknown'),
'incense_count': inventory.items().get(type).count
}
)
return WorkerResult.SUCCESS
def _update_inventory(self, item_awarded):
if 'item_id' in item_awarded:
inventory.items().get(item_awarded['item_id']).add(
item_awarded['item_count'])
elif 'item' in item_awarded:
inventory.items().get(item_awarded['item']).add(
item_awarded['count'])
def work(self):
if self._should_run():
self.start_time = time.time()
response_dict = self.bot.api.use_incense(
incense_type=self._get_type())
result = response_dict.get('responses',
{}).get('USE_INCENSE',
{}).get('result', 0)
if result is 1:
self.emit_event(
'use_incense',
formatted=
"Using {type} incense. {incense_count} incense remaining",
data={
'type': self.types.get(type, 'Unknown'),
'incense_count': inventory.items().get(type).count
})
else:
self.emit_event(
'use_incense',
formatted=
"Unable to use incense {type}. {incense_count} incense remaining",
data={
'type': self.types.get(type, 'Unknown'),
'incense_count': inventory.items().get(type).count
})
return WorkerResult.SUCCESS
def _update_inventory(self):
"""
Updates the inventory. Prevent an unnecessary call to the api
:return: Nothing.
:rtype: None
"""
inventory.items().get(self.item_to_recycle.id).remove(self.amount_to_recycle)
def _determin_feed_berry_id(self, motivated_pokemon):
# # Store the amount of berries we have
razzb = inventory.items().get(ITEM_RAZZBERRY).count
pinap = inventory.items().get(ITEM_PINAPBERRY).count
nanab = inventory.items().get(ITEM_NANABBERRY).count
missing_motivation = 1.0 - motivated_pokemon.get('motivation_now')
# Always allow feeding with RAZZ and NANAB
allowed_berries = []
if razzb > 0:
allowed_berries.append(ITEM_RAZZBERRY)
if nanab > 0:
allowed_berries.append(ITEM_NANABBERRY)
if pinap > 10:
allowed_berries.append(ITEM_PINAPBERRY)
food_values = motivated_pokemon['food_value']
# Only check the berries we wish to feed
food_values = [
f for f in food_values if f['food_item'] in allowed_berries
]
# Sort by the least restore first
sorted(food_values, key=lambda x: x['motivation_increase'])
for food_value in food_values:
if food_value['motivation_increase'] >= missing_motivation:
# We fully restore CP with this berry!
return food_value['food_item']
# Okay, we can't completely fill the CP for the pokemon, get the best berry then NO GOLDEN
return food_values[-1]['food_item']
def _update_inventory(self):
"""
Updates the inventory. Prevent an unnecessary call to the api
:return: Nothing.
:rtype: None
"""
inventory.items().get(self.item_to_recycle.id).remove(
self.amount_to_recycle)
def _update_inventory(self):
self.incense_ordinary_count = inventory.items().get(
Item.ITEM_INCENSE_ORDINARY.value).count
self.incense_spicy_count = inventory.items().get(
Item.ITEM_INCENSE_SPICY.value).count
self.incense_cool_count = inventory.items().get(
Item.ITEM_INCENSE_COOL.value).count
self.incense_floral_count = inventory.items().get(
Item.ITEM_INCENSE_FLORAL.value).count
def work(self):
# check for pokeballs (excluding masterball)
pokeballs_quantity = inventory.items().get(POKEBALL_ID).count
superballs_quantity = inventory.items().get(GREATBALL_ID).count
ultraballs_quantity = inventory.items().get(ULTRABALL_ID).count
if (pokeballs_quantity + superballs_quantity + ultraballs_quantity) < 1:
return WorkerResult.SUCCESS
self.update_map_location()
self.dump_caught_pokemon()
pokemon_list = self.get_pokemon_from_map()
pokemon_list.sort(key=lambda x: x['dist'])
if self.config['mode'] == 'priority':
pokemon_list.sort(key=lambda x: x['priority'], reverse=True)
if self.config['prioritize_vips']:
pokemon_list.sort(key=lambda x: x['is_vip'], reverse=True)
if len(pokemon_list) < 1:
return WorkerResult.SUCCESS
pokemon = pokemon_list[0]
if pokeballs_quantity < 1:
if superballs_quantity < 1:
if ultraballs_quantity < 1:
return WorkerResult.SUCCESS
if self.config['snipe']:
if self.snipe_high_prio_only:
if self.snipe_high_prio_threshold < pokemon['priority']:
self.snipe(pokemon)
else:
return self.snipe(pokemon)
if pokeballs_quantity + superballs_quantity + ultraballs_quantity < self.min_ball:
return WorkerResult.SUCCESS
nearest_fort = self.get_nearest_fort_on_the_way(pokemon)
if nearest_fort is None :
step_walker = self._move_to(pokemon)
if not step_walker.step():
if pokemon['dist'] < Constants.MAX_DISTANCE_POKEMON_IS_REACHABLE:
self._encountered(pokemon)
self.add_caught(pokemon)
return WorkerResult.SUCCESS
else :
return WorkerResult.RUNNING
else :
step_walker = self._move_to_pokemon_througt_fort(nearest_fort, pokemon)
if not step_walker or not step_walker.step():
return WorkerResult.RUNNING
def feed_pokemons_in_gym(self, gym):
#Check if berry feeding is enabled from config
if self.feed_berries == False:
return True
#check if gym is in range. If not, gym=false
if gym == False:
return True
berries = inventory.items().get(ITEM_RAZZBERRY).count + (
inventory.items().get(ITEM_PINAPBERRY).count -
10) + inventory.items().get(ITEM_NANABBERRY).count
if berries < 1:
self.logger.info("No berries left to feed Pokemon.")
return True
max_gym_time = timedelta(hours=8, minutes=20)
try:
gym_info = self.get_gym_details(gym).get(
'gym_status_and_defenders', None)
except (TypeError, KeyError, AttributeError):
#This gym does not give status results. Probably it is not in range
return True
# self.logger.info("Defenders in gym:")okemon_info..items()get('pokemon_id')
if gym_info:
defenders = gym_info.get('gym_defender', [])
for defender in defenders:
#self.logger.info("LOG: Defender data: defender %s" % defender)
motivated_pokemon = defender.get('motivated_pokemon')
pokemon_info = motivated_pokemon.get('pokemon')
pokemon_id = pokemon_info.get('id')
# timestamp when deployed
deployed_on = datetime.fromtimestamp(
int(motivated_pokemon.get('deploy_ms')) / 1e3)
time_deployed = datetime.now() - deployed_on
# % of motivation
current_motivation = motivated_pokemon.get('motivation_now')
# Let's see if we should feed this Pokemon
if time_deployed < max_gym_time and current_motivation < 1.0:
# Let's feed this Pokemon a candy
# self.logger.info("This pokemon deserves a candy")
berry_id = self._determin_feed_berry_id(motivated_pokemon)
poke_id = pokemon_id
#Testing to see what quantity field does. Probably just the amount of berries you want to feed
#quantity = pokemon_info.get('num_upgrades') <- Failed
quantity = 2
self._feed_pokemon(gym, poke_id, berry_id, quantity)
def use_lucky_egg(self):
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
return False
response_dict = self.bot.use_lucky_egg()
if not response_dict:
self.emit_event("lucky_egg_error",
level='error',
formatted="Failed to use lucky egg!")
return False
result = response_dict.get("responses", {}).get("USE_ITEM_XP_BOOST", {}).get("result", 0)
if result == SUCCESS:
lucky_egg.remove(1)
self.emit_event("used_lucky_egg",
formatted="Used lucky egg ({amount_left} left).",
data={"amount_left": lucky_egg.count})
return True
elif result == ERROR_XP_BOOST_ALREADY_ACTIVE:
self.emit_event("used_lucky_egg",
formatted="Lucky egg already active ({amount_left} left).",
data={"amount_left": lucky_egg.count})
return True
else:
self.emit_event("lucky_egg_error",
level='error',
formatted="Failed to use lucky egg!")
return False
def request_ordincense_count(self, update):
ord_incense = inventory.items().get(
Item.ITEM_INCENSE_ORDINARY.value) # @UndefinedVariable
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Ordinary Incense Count: " +
str(ord_incense.count))
def request_luckyegg(self,update):
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
return False
response_dict = self.bot.use_lucky_egg()
if not response_dict:
self.bot.logger.info("Telegram Request: Failed to use lucky egg!")
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Failed to use lucky egg!\n")
return False
result = response_dict.get("responses", {}).get("USE_ITEM_XP_BOOST", {}).get("result", 0)
if result == SUCCESS:
lucky_egg.remove(1)
self.bot.logger.info("Telegram Request: Used lucky egg, {} left.".format(lucky_egg.count))
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Used lucky egg, " + str(lucky_egg.count) + " left.")
return True
elif result == ERROR_XP_BOOST_ALREADY_ACTIVE:
self.bot.logger.info("Telegram Request: Lucky egg already active, {} left.".format(lucky_egg.count))
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Lucky egg already active, " + str(lucky_egg.count) + " left.")
return True
else:
self.bot.logger.info("Telegram Request: Failed to use lucky egg!")
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Failed to use lucky egg!\n")
return False
def use_lucky_egg(self):
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
return False
response_dict = self.bot.use_lucky_egg()
if not response_dict:
self.emit_event("lucky_egg_error",
level='error',
formatted="Failed to use lucky egg!")
return False
result = response_dict.get("responses", {}).get("USE_ITEM_XP_BOOST", {}).get("result", 0)
if result == SUCCESS:
lucky_egg.remove(1)
self.emit_event("used_lucky_egg",
formatted="Used lucky egg ({amount_left} left).",
data={"amount_left": lucky_egg.count})
return True
elif result == ERROR_XP_BOOST_ALREADY_ACTIVE:
self.emit_event("used_lucky_egg",
formatted="Lucky egg already active ({amount_left} left).",
data={"amount_left": lucky_egg.count})
return True
else:
self.emit_event("lucky_egg_error",
level='error',
formatted="Failed to use lucky egg!")
return False
def save_web_inventory(self):
web_inventory = os.path.join(_base_dir, "web", "inventory-%s.json" % self.bot.config.username)
with open(web_inventory, "r") as infile:
ii = json.load(infile)
ii = [x for x in ii if not x.get("inventory_item_data", {}).get("pokedex_entry", None)]
ii = [x for x in ii if not x.get("inventory_item_data", {}).get("candy", None)]
ii = [x for x in ii if not x.get("inventory_item_data", {}).get("item", None)]
ii = [x for x in ii if not x.get("inventory_item_data", {}).get("pokemon_data", None)]
for pokedex in inventory.pokedex().all():
ii.append({"inventory_item_data": {"pokedex_entry": pokedex}})
for family_id, candy in inventory.candies()._data.items():
ii.append({"inventory_item_data": {"candy": {"family_id": family_id, "candy": candy.quantity}}})
for item_id, item in inventory.items()._data.items():
ii.append({"inventory_item_data": {"item": {"item_id": item_id, "count": item.count}}})
for pokemon in inventory.pokemons().all():
ii.append({"inventory_item_data": {"pokemon_data": pokemon._data}})
with open(web_inventory, "w") as outfile:
json.dump(ii, outfile)
def _use_lucky_egg(self):
using_lucky_egg = time.time() - self.start_time < 1800
if using_lucky_egg:
return False
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value)
# Make sure the user has a lucky egg and skip if not
if lucky_egg.count > 0:
response_dict_lucky_egg = self.bot.use_lucky_egg()
if response_dict_lucky_egg:
result = response_dict_lucky_egg.get('responses', {}).get(
'USE_ITEM_XP_BOOST', {}).get('result', 0)
if result is 1: # Request success
self.start_time = time.time()
lucky_egg.remove(1)
self.emit_event(
'used_lucky_egg',
formatted='Used lucky egg ({amount_left} left).',
data={'amount_left': lucky_egg.count})
return True
else:
self.emit_event('lucky_egg_error',
level='error',
formatted='Failed to use lucky egg!')
return False
else:
# Skipping evolve so they aren't wasted
self.emit_event(
'skip_evolve',
formatted='Skipping evolve because has no lucky egg.')
return False
def work(self):
"""
Start the process of recycling items if necessary.
:return: Returns whether or not the task went well
:rtype: WorkerResult
"""
# TODO: Use new inventory everywhere and then remove this inventory update
inventory.refresh_inventory()
worker_result = WorkerResult.SUCCESS
if self.should_run():
if not (self.max_balls_keep is None):
worker_result = self.recycle_excess_category_max(self.max_balls_keep, [1,2,3,4])
if not (self.max_potions_keep is None):
worker_result = self.recycle_excess_category_max(self.max_potions_keep, [101,102,103,104])
if not (self.max_berries_keep is None):
worker_result = self.recycle_excess_category_max(self.max_berries_keep, [701,702,703,704,705])
if not (self.max_revives_keep is None):
worker_result = self.recycle_excess_category_max(self.max_revives_keep, [201,202])
inventory.refresh_inventory()
for item_in_inventory in inventory.items().all():
if self.item_should_be_recycled(item_in_inventory):
# Make the bot appears more human
action_delay(self.recycle_wait_min, self.recycle_wait_max)
# If at any recycling process call we got an error, we consider that the result of this task is error too.
if ItemRecycler(self.bot, item_in_inventory, self.get_amount_to_recycle(item_in_inventory)).work() == WorkerResult.ERROR:
worker_result = WorkerResult.ERROR
return worker_result
def apply_optimization(self, transfer, evolve, upgrade, xp):
transfer_count = len(transfer)
evolve_count = len(evolve)
upgrade_count = len(upgrade)
xp_count = len(xp)
if self.config_transfer or self.bot.config.test:
if transfer_count > 0:
self.logger.info("Transferring %s Pokemon", transfer_count)
for pokemon in transfer:
self.transfer_pokemon(pokemon)
if self.config_evolve or self.bot.config.test:
evolve_xp_count = evolve_count + xp_count
if evolve_xp_count > 0:
skip_evolve = False
if self.config_evolve and self.config_may_use_lucky_egg and (not self.bot.config.test):
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
if self.config_evolve_only_with_lucky_egg:
skip_evolve = True
self.emit_event("skip_evolve",
formatted="Skipping evolution step. No lucky egg available")
elif evolve_xp_count < self.config_evolve_count_for_lucky_egg:
if self.config_evolve_only_with_lucky_egg:
skip_evolve = True
self.emit_event("skip_evolve",
formatted="Skipping evolution step. Not enough Pokemon to evolve with lucky egg: %s/%s" % (evolve_xp_count, self.config_evolve_count_for_lucky_egg))
elif self.get_pokemon_slot_left() > self.config_min_slots_left:
skip_evolve = True
self.emit_event("skip_evolve",
formatted="Waiting for more Pokemon to evolve with lucky egg: %s/%s" % (evolve_xp_count, self.config_evolve_count_for_lucky_egg))
else:
self.use_lucky_egg()
if not skip_evolve:
self.evolution_map = {}
if evolve_count > 0:
self.logger.info("Evolving %s Pokemon (the best)", evolve_count)
for pokemon in evolve:
self.evolve_pokemon(pokemon)
if xp_count > 0:
self.logger.info("Evolving %s Pokemon (for xp)", xp_count)
for pokemon in xp:
self.evolve_pokemon(pokemon)
if self.config_upgrade or self.bot.config.test:
if upgrade_count > 0:
self.logger.info("Upgrading %s Pokemon [%s stardust]", upgrade_count, self.bot.stardust)
for pokemon in upgrade:
self.upgrade_pokemon(pokemon)
def _should_run(self):
if not self.evolve_all or self.evolve_all[0] == 'none':
return False
# Evolve all is used - Use Lucky egg only at the first tick
if self.bot.tick_count is not 1 or not self.use_lucky_egg:
return True
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value)
# Make sure the user has a lucky egg and skip if not
if lucky_egg.count > 0:
response_dict_lucky_egg = self.bot.use_lucky_egg()
if response_dict_lucky_egg:
result = response_dict_lucky_egg.get('responses', {}).get(
'USE_ITEM_XP_BOOST', {}).get('result', 0)
if result is 1: # Request success
lucky_egg.remove(1)
self.emit_event(
'used_lucky_egg',
formatted='Used lucky egg ({amount_left} left).',
data={'amount_left': lucky_egg.count})
return True
else:
self.emit_event('lucky_egg_error',
level='error',
formatted='Failed to use lucky egg!')
return False
else:
# Skipping evolve so they aren't wasted
self.emit_event(
'skip_evolve',
formatted='Skipping evolve because has no lucky egg.')
return False
def apply_optimization(self, transfer, evo):
self.logger.info("Transferring %s Pokemon", len(transfer))
for pokemon in transfer:
self.transfer_pokemon(pokemon)
if len(evo) == 0:
return
if self.config_evolve and self.config_may_use_lucky_egg and (not self.bot.config.test):
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
if self.config_evolve_only_with_lucky_egg:
self.emit_event("skip_evolve",
formatted="Skipping evolution step. No lucky egg available")
return
elif len(evo) < self.config_evolve_count_for_lucky_egg:
if self.config_evolve_only_with_lucky_egg:
self.emit_event("skip_evolve",
formatted="Skipping evolution step. Not enough Pokemon to evolve with lucky egg: %s/%s" % (len(evo), self.config_evolve_count_for_lucky_egg))
return
elif self.get_pokemon_slot_left() > 5:
self.emit_event("skip_evolve",
formatted="Waiting for more Pokemon to evolve with lucky egg: %s/%s" % (len(evo), self.config_evolve_count_for_lucky_egg))
return
else:
self.use_lucky_egg()
self.logger.info("Evolving %s Pokemon", len(evo))
for pokemon in evo:
self.evolve_pokemon(pokemon)
def work(self):
"""
Start the process of recycling items if necessary.
:return: Returns whether or not the task went well
:rtype: WorkerResult
"""
worker_result = WorkerResult.SUCCESS
if self.should_run():
if not (self.max_balls_keep is None):
worker_result = self.recycle_excess_category_max(self.max_balls_keep, [1,2,3,4])
if not (self.max_potions_keep is None):
worker_result = self.recycle_excess_category_max(self.max_potions_keep, [101,102,103,104])
if not (self.max_berries_keep is None):
worker_result = self.recycle_excess_category_max(self.max_berries_keep, [701,702,703,704,705])
if not (self.max_revives_keep is None):
worker_result = self.recycle_excess_category_max(self.max_revives_keep, [201,202])
inventory.refresh_inventory()
for item_in_inventory in inventory.items().all():
if self.item_should_be_recycled(item_in_inventory):
# Make the bot appears more human
action_delay(self.recycle_wait_min, self.recycle_wait_max)
# If at any recycling process call we got an error, we consider that the result of this task is error too.
if ItemRecycler(self.bot, item_in_inventory, self.get_amount_to_recycle(item_in_inventory)).work() == WorkerResult.ERROR:
worker_result = WorkerResult.ERROR
return worker_result
def initialize(self):
self.api = self.bot.api
self.position = self.bot.position
self.pokemon_list = self.bot.pokemon_list
self.inventory = inventory.items()
self.spawn_point_guid = ''
self.response_key = ''
self.response_status_key = ''
#Config
self.min_ultraball_to_keep = self.config.get('min_ultraball_to_keep', 10)
self.berry_threshold = self.config.get('berry_threshold', 0.35)
self.vip_berry_threshold = self.config.get('vip_berry_threshold', 0.9)
self.catch_throw_parameters = self.config.get('catch_throw_parameters', {})
self.catch_throw_parameters_spin_success_rate = self.catch_throw_parameters.get('spin_success_rate', 0.6)
self.catch_throw_parameters_excellent_rate = self.catch_throw_parameters.get('excellent_rate', 0.1)
self.catch_throw_parameters_great_rate = self.catch_throw_parameters.get('great_rate', 0.5)
self.catch_throw_parameters_nice_rate = self.catch_throw_parameters.get('nice_rate', 0.3)
self.catch_throw_parameters_normal_rate = self.catch_throw_parameters.get('normal_rate', 0.1)
self.catch_throw_parameters_hit_rate = self.catch_throw_parameters.get('hit_rate', 0.8)
self.catchsim_config = self.config.get('catch_simulation', {})
self.catchsim_catch_wait_min = self.catchsim_config.get('catch_wait_min', 2)
self.catchsim_catch_wait_max = self.catchsim_config.get('catch_wait_max', 6)
self.catchsim_flee_count = int(self.catchsim_config.get('flee_count', 3))
self.catchsim_flee_duration = self.catchsim_config.get('flee_duration', 2)
self.catchsim_berry_wait_min = self.catchsim_config.get('berry_wait_min', 2)
self.catchsim_berry_wait_max = self.catchsim_config.get('berry_wait_max', 3)
self.catchsim_changeball_wait_min = self.catchsim_config.get('changeball_wait_min', 2)
self.catchsim_changeball_wait_max = self.catchsim_config.get('changeball_wait_max', 3)
def work(self):
# make sure we have SOME balls
if sum([inventory.items().get(ball.value).count for ball in
[Item.ITEM_POKE_BALL, Item.ITEM_GREAT_BALL, Item.ITEM_ULTRA_BALL]]) <= 0:
return WorkerResult.ERROR
# check if we have already loaded a list
if len(self.pokemon) <= 0:
# load available pokemon by config settings
if self.config.get('catch_visible_pokemon', True):
self.get_visible_pokemon()
if self.config.get('catch_lured_pokemon', True):
self.get_lured_pokemon()
if self._have_applied_incense() and self.config.get('catch_incensed_pokemon', True):
self.get_incensed_pokemon()
random.shuffle(self.pokemon)
num_pokemon = len(self.pokemon)
if num_pokemon > 0:
# try catching
try:
if self.catch_pokemon(self.pokemon.pop()) == WorkerResult.ERROR:
# give up incase something went wrong in our catch worker (ran out of balls, etc)
return WorkerResult.ERROR
elif num_pokemon > 1:
# we have more pokemon to catch
return WorkerResult.RUNNING
except ValueError:
return WorkerResult.ERROR
# all pokemon have been processed
return WorkerResult.SUCCESS
def apply_optimization(self, transfer, evo):
self.logger.info("Transferring %s Pokemons", len(transfer))
for pokemon in transfer:
self.transfer_pokemon(pokemon)
if len(evo) == 0:
return
if self.config_evolve and self.config_may_use_lucky_egg and (not self.bot.config.test):
if len(evo) >= self.config_evolve_count_for_lucky_egg:
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count > 0:
self.use_lucky_egg()
elif self.config_evolve_only_with_lucky_egg:
self.logger.info("Skipping evolution step. No lucky egg available")
return
elif self.config_evolve_only_with_lucky_egg:
self.logger.info("Skipping evolution step. Not enough Pokemons (%s) to evolve with lucky egg", len(evo))
return
self.logger.info("Evolving %s Pokemons", len(evo))
for pokemon in evo:
self.evolve_pokemon(pokemon)
def apply_optimization(self, transfer, evolve, upgrade, xp):
transfer_count = len(transfer)
evolve_count = len(evolve)
upgrade_count = len(upgrade)
xp_count = len(xp)
if self.config_transfer or self.bot.config.test:
if transfer_count > 0:
self.logger.info("Transferring %s Pokemon", transfer_count)
for pokemon in transfer:
self.transfer_pokemon(pokemon)
if self.config_evolve or self.bot.config.test:
evolve_xp_count = evolve_count + xp_count
if evolve_xp_count > 0:
skip_evolve = False
if self.config_evolve and self.config_may_use_lucky_egg and (not self.bot.config.test):
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
if self.config_evolve_only_with_lucky_egg:
skip_evolve = True
self.emit_event("skip_evolve",
formatted="Skipping evolution step. No lucky egg available")
elif evolve_xp_count < self.config_evolve_count_for_lucky_egg:
if self.config_evolve_only_with_lucky_egg:
skip_evolve = True
self.emit_event("skip_evolve",
formatted="Skipping evolution step. Not enough Pokemon to evolve with lucky egg: %s/%s" % (evolve_xp_count, self.config_evolve_count_for_lucky_egg))
elif self.get_pokemon_slot_left() > self.config_min_slots_left:
skip_evolve = True
self.emit_event("skip_evolve",
formatted="Waiting for more Pokemon to evolve with lucky egg: %s/%s" % (evolve_xp_count, self.config_evolve_count_for_lucky_egg))
else:
self.use_lucky_egg()
if not skip_evolve:
self.evolution_map = {}
if evolve_count > 0:
self.logger.info("Evolving %s Pokemon (the best)", evolve_count)
for pokemon in evolve:
self.evolve_pokemon(pokemon)
if xp_count > 0:
self.logger.info("Evolving %s Pokemon (for xp)", xp_count)
for pokemon in xp:
self.evolve_pokemon(pokemon)
if self.config_upgrade or self.bot.config.test:
if upgrade_count > 0:
self.logger.info("Upgrading %s Pokemon [%s stardust]", upgrade_count, self.bot.stardust)
for pokemon in upgrade:
self.upgrade_pokemon(pokemon)
def initialize(self):
self.disabled = False
self.last_cell_check_time = time.time()
self.last_data_request_time = time.time()
self.inventory = inventory.items()
self.pokedex = inventory.pokedex()
self.debug = self.config.get('debug', False)
self.special_iv = self.config.get('special_iv', 100)
self.bullets = self.config.get('bullets', 1)
self.homing_shots = self.config.get('homing_shots', True)
self.mode = self.config.get('mode', SniperMode.DEFAULT)
self.order = self.config.get('order', SniperOrderMode.DEFAULT)
self.catch_list = self.config.get('catch', {})
self.altitude = uniform(self.bot.config.alt_min,
self.bot.config.alt_max)
self.sources = [
SniperSource(data) for data in self.config.get('sources', [])
]
if not hasattr(self.bot, "sniper_cache"):
self.bot.sniper_cache = []
# Dont bother validating config if task is not even enabled
if self.enabled:
# Validate ordering
for ordering in self.order:
if ordering not in vars(SniperOrderMode).values():
raise ValueError(
"Unrecognized ordering: '{}'".format(ordering))
# Validate mode and sources
if self.mode not in vars(SniperMode).values():
raise ValueError("Unrecognized mode: '{}'".format(self.mode))
else:
# Selected mode is valid. Validate sources if mode is URL
if self.mode == SniperMode.URL:
self._log("Validating sources: {}...".format(", ".join(
[source.url for source in self.sources])))
# Create a copy of the list so we can iterate and remove elements at the same time
for source in list(self.sources):
try:
source.validate()
self._log("Source '{}' is good!".format(
source.url))
# TODO: On ValueError, remember source and validate later (pending validation)
except (LookupError, ValueError) as exception:
self._error(
"Source '{}' contains errors. Details: {}. Removing from sources list..."
.format(source.url, exception))
self.sources.remove(source)
# Notify user if all sources are invalid and cant proceed
if not self.sources:
self._error(
"There is no source available. Disabling Sniper..."
)
self.disabled = True
def _collect_level_reward(self):
response_dict = self.bot.api.level_up_rewards(level=self.current_level)
if 'status_code' in response_dict and response_dict['status_code'] == 1:
data = (response_dict.get('responses',
{}).get('LEVEL_UP_REWARDS',
{}).get('items_awarded', []))
for item in data:
if 'item_id' in item and str(
item['item_id']) in self.bot.item_list:
got_item = self.bot.item_list[str(item['item_id'])]
item['name'] = got_item
count = 'item_count' in item and item['item_count'] or 0
inventory.items().get(item['item_id']).add(count)
self.emit_event('level_up_reward',
formatted='Received level up reward: {items}',
data={'items': data})
def initialize(self):
self.disabled = False
self.last_cell_check_time = time.time()
self.last_data_request_time = time.time()
self.inventory = inventory.items()
self.pokedex = inventory.pokedex()
self.debug = self.config.get('debug', False)
self.special_iv = self.config.get('special_iv', 0)
self.bullets = self.config.get('bullets', 1)
self.homing_shots = self.config.get('homing_shots', True)
self.mode = self.config.get('mode', SniperMode.DEFAULT)
self.order = self.config.get('order', SniperOrderMode.DEFAULT)
self.cooldown_enabled = self.config.get('cooldown_enabled', False)
self.loiter_after_snipe = self.config.get('loiter_after_snipe', False)
self.catch_list = self.config.get('catch', {})
self.altitude = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
self.sources = [SniperSource(data) for data in self.config.get('sources', [])]
self.no_snipe_until = None
if not hasattr(self.bot,"sniper_cache"):
self.bot.sniper_cache = []
# Dont bother validating config if task is not even enabled
if self.enabled:
# Validate ordering
for ordering in self.order:
if ordering not in vars(SniperOrderMode).values():
raise ValueError("Unrecognized ordering: '{}'".format(ordering))
# Validate mode and sources
if self.mode not in vars(SniperMode).values():
raise ValueError("Unrecognized mode: '{}'".format(self.mode))
else:
# Selected mode is valid. Validate sources if mode is URL
if self.mode == SniperMode.URL:
self._log("Validating sources: {}...".format(", ".join([source.url for source in self.sources])))
# Create a copy of the list so we can iterate and remove elements at the same time
for source in list(self.sources):
try:
source.validate()
self._log("Source '{}' is good!".format(source.url))
# TODO: On ValueError, remember source and validate later (pending validation)
except (LookupError, ValueError) as exception:
self._error("Source '{}' contains errors. Details: {}. Removing from sources list...".format(source.url, exception))
self.sources.remove(source)
# Notify user if all sources are invalid and cant proceed
if not self.sources :
self._error("There is no source available. Disabling Sniper...")
self.disabled = True
# Re-enable snipping if source is from telegram
if self.mode == SniperMode.TELEGRAM:
self.disabled = False
def initialize(self):
self.api = self.bot.api
self.position = self.bot.position
self.pokemon_list = self.bot.pokemon_list
self.inventory = inventory.items()
self.pokedex = inventory.pokedex()
self.spawn_point_guid = ''
self.response_key = ''
self.response_status_key = ''
#Config
self.min_ultraball_to_keep = self.config.get('min_ultraball_to_keep',
10)
self.berry_threshold = self.config.get('berry_threshold', 0.35)
self.vip_berry_threshold = self.config.get('vip_berry_threshold', 0.9)
self.treat_unseen_as_vip = self.config.get('treat_unseen_as_vip',
DEFAULT_UNSEEN_AS_VIP)
self.daily_catch_limit = self.config.get('daily_catch_limit', 800)
self.catch_throw_parameters = self.config.get('catch_throw_parameters',
{})
self.catch_throw_parameters_spin_success_rate = self.catch_throw_parameters.get(
'spin_success_rate', 0.6)
self.catch_throw_parameters_excellent_rate = self.catch_throw_parameters.get(
'excellent_rate', 0.1)
self.catch_throw_parameters_great_rate = self.catch_throw_parameters.get(
'great_rate', 0.5)
self.catch_throw_parameters_nice_rate = self.catch_throw_parameters.get(
'nice_rate', 0.3)
self.catch_throw_parameters_normal_rate = self.catch_throw_parameters.get(
'normal_rate', 0.1)
self.catch_throw_parameters_hit_rate = self.catch_throw_parameters.get(
'hit_rate', 0.8)
self.catchsim_config = self.config.get('catch_simulation', {})
self.catchsim_catch_wait_min = self.catchsim_config.get(
'catch_wait_min', 2)
self.catchsim_catch_wait_max = self.catchsim_config.get(
'catch_wait_max', 6)
self.catchsim_flee_count = int(
self.catchsim_config.get('flee_count', 3))
self.catchsim_flee_duration = self.catchsim_config.get(
'flee_duration', 2)
self.catchsim_berry_wait_min = self.catchsim_config.get(
'berry_wait_min', 2)
self.catchsim_berry_wait_max = self.catchsim_config.get(
'berry_wait_max', 3)
self.catchsim_changeball_wait_min = self.catchsim_config.get(
'changeball_wait_min', 2)
self.catchsim_changeball_wait_max = self.catchsim_config.get(
'changeball_wait_max', 3)
self.catchsim_newtodex_wait_min = self.catchsim_config.get(
'newtodex_wait_min', 20)
self.catchsim_newtodex_wait_max = self.catchsim_config.get(
'newtodex_wait_max', 30)
def __init__(self, pokemon, bot):
self.pokemon = pokemon
self.api = bot.api
self.bot = bot
self.position = bot.position
self.config = bot.config
self.pokemon_list = bot.pokemon_list
self.inventory = inventory.items()
self.spawn_point_guid = ''
self.response_key = ''
self.response_status_key = ''
def _revive_pokemon(self, pokemon):
item = Item.ITEM_REVIVE.value
amount = inventory.items().get(item).count
if amount == 0:
self.logger.info("No normal revives left, using MAX revive!")
item = Item.ITEM_MAX_REVIVE.value
amount = inventory.items().get(item).count
if amount > 0:
response_dict_revive = self.bot.api.use_item_revive(item_id=item, pokemon_id=pokemon.unique_id)
action_delay(2, 3)
if response_dict_revive:
result = response_dict_revive.get('responses', {}).get('USE_ITEM_REVIVE', {}).get('result', 0)
revive_item = inventory.items().get(item)
# Remove the revive from the iventory
revive_item.remove(1)
if result is 1: # Request success
self.emit_event(
'revived_pokemon',
formatted='Revived {name}.',
data={
'name': pokemon.name
}
)
if item == Item.ITEM_REVIVE.value:
pokemon.hp = int(pokemon.hp_max / 2)
self.to_heal.append(pokemon)
else:
# Set pokemon as revived
pokemon.hp = pokemon.hp_max
return True
else:
self.emit_event(
'revived_pokemon',
level='error',
formatted='Failed to revive {name}!',
data={
'name': pokemon.name
}
)
return False
def initialize(self):
self.position = self.bot.position
self.pokemon_list = self.bot.pokemon_list
self.inventory = inventory.items()
self.pokedex = inventory.pokedex()
self.spawn_point_guid = ''
self.response_key = ''
self.response_status_key = ''
self.rest_completed = False
self.caught_last_24 = 0
#Config
self.min_ultraball_to_keep = self.config.get('min_ultraball_to_keep', 10)
self.berry_threshold = self.config.get('berry_threshold', 0.35)
self.golden_razz_threshold = self.config.get('golden_razz_threshold', 0.1)
self.golden_razz_to_keep = self.config.get('golden_razz_to_keep', 30)
self.use_golden_razz_on_vip_only = self.config.get('use_golden_razz_on_vip_only', True)
self.vip_berry_threshold = self.config.get('vip_berry_threshold', 0.9)
self.treat_unseen_as_vip = self.config.get('treat_unseen_as_vip', DEFAULT_UNSEEN_AS_VIP)
self.daily_catch_limit = self.config.get('daily_catch_limit', 500)
self.use_pinap_on_vip = self.config.get('use_pinap_on_vip', False)
self.pinap_on_level_below = self.config.get('pinap_on_level_below', 0)
self.pinap_operator = self.config.get('pinap_operator', "or")
self.pinap_ignore_threshold = self.config.get('pinap_ignore_threshold', False)
self.vanish_settings = self.config.get('vanish_settings', {})
self.consecutive_vanish_limit = self.vanish_settings.get('consecutive_vanish_limit', 10)
self.rest_duration_min = getSeconds(self.vanish_settings.get('rest_duration_min', "02:00:00"))
self.rest_duration_max = getSeconds(self.vanish_settings.get('rest_duration_max', "04:00:00"))
self.catch_throw_parameters = self.config.get('catch_throw_parameters', {})
self.catch_throw_parameters_spin_success_rate = self.catch_throw_parameters.get('spin_success_rate', 0.6)
self.catch_throw_parameters_excellent_rate = self.catch_throw_parameters.get('excellent_rate', 0.1)
self.catch_throw_parameters_great_rate = self.catch_throw_parameters.get('great_rate', 0.5)
self.catch_throw_parameters_nice_rate = self.catch_throw_parameters.get('nice_rate', 0.3)
self.catch_throw_parameters_normal_rate = self.catch_throw_parameters.get('normal_rate', 0.1)
self.catch_throw_parameters_hit_rate = self.catch_throw_parameters.get('hit_rate', 0.8)
self.catchsim_config = self.config.get('catch_simulation', {})
self.catchsim_catch_wait_min = self.catchsim_config.get('catch_wait_min', 2)
self.catchsim_catch_wait_max = self.catchsim_config.get('catch_wait_max', 6)
self.catchsim_flee_count = int(self.catchsim_config.get('flee_count', 3))
self.catchsim_flee_duration = self.catchsim_config.get('flee_duration', 2)
self.catchsim_berry_wait_min = self.catchsim_config.get('berry_wait_min', 2)
self.catchsim_berry_wait_max = self.catchsim_config.get('berry_wait_max', 3)
self.catchsim_changeball_wait_min = self.catchsim_config.get('changeball_wait_min', 2)
self.catchsim_changeball_wait_max = self.catchsim_config.get('changeball_wait_max', 3)
self.catchsim_newtodex_wait_min = self.catchsim_config.get('newtodex_wait_min', 20)
self.catchsim_newtodex_wait_max = self.catchsim_config.get('newtodex_wait_max', 30)
self.smart_pinap_enabled = self.config.get('smart_pinap_enabled', False)
self.smart_pinap_threshold = self.config.get('smart_pinap_threshold', 0.85)
self.smart_pinap_to_keep = self.config.get('smart_pinap_to_keep', 3)
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
# Check for pokemon to heal or revive
to_revive = []
self.to_heal = []
pokemons = inventory.pokemons().all()
pokemons.sort(key=lambda p: p.hp)
for pokemon in pokemons:
if pokemon.hp < 1.0:
self.logger.info("Dead: %s (%s CP| %s/%s )" % (pokemon.name, pokemon.cp, pokemon.hp, pokemon.hp_max))
to_revive += [pokemon]
elif pokemon.hp < pokemon.hp_max:
self.logger.info("Heal: %s (%s CP| %s/%s )" % (pokemon.name, pokemon.cp, pokemon.hp, pokemon.hp_max))
self.to_heal += [pokemon]
if len(self.to_heal) == 0 and len(to_revive) == 0:
if self._should_print:
self.next_update = datetime.now() + timedelta(seconds=120)
#self.logger.info("No pokemon to heal or revive")
return WorkerResult.SUCCESS
# Okay, start reviving pokemons
# Check revives and potions
revives = inventory.items().get(Item.ITEM_REVIVE.value).count
max_revives = inventory.items().get(Item.ITEM_MAX_REVIVE.value).count
normal = inventory.items().get(Item.ITEM_POTION.value).count
super_p = inventory.items().get(Item.ITEM_SUPER_POTION.value).count
hyper = inventory.items().get(Item.ITEM_HYPER_POTION.value).count
max_p = inventory.items().get(Item.ITEM_MAX_POTION.value).count
self.logger.info("Healing %s pokemon" % len(self.to_heal))
self.logger.info("Reviving %s pokemon" % len(to_revive))
if self.revive_pokemon:
if len(to_revive) > 0 and revives == 0 and max_revives == 0:
if not self.warned_about_no_revives:
self.logger.info("No revives left! Can't revive %s pokemons." % len(to_revive))
self.warned_about_no_revives = True
elif len(to_revive) > 0:
self.logger.info("Reviving %s pokemon..." % len(to_revive))
self.warned_about_no_revives = False
for pokemon in to_revive:
self._revive_pokemon(pokemon)
if self.heal_pokemon:
if len(self.to_heal) > 0 and (normal + super_p + hyper + max_p) == 0:
if not self.warned_about_no_potions:
self.logger.info("No potions left! Can't heal %s pokemon" % len(self.to_heal))
self.warned_about_no_potions = True
elif len(self.to_heal) > 0:
self.logger.info("Healing %s pokemon" % len(self.to_heal))
self.warned_about_no_potions = False
for pokemon in self.to_heal:
self._heal_pokemon(pokemon)
if self._should_print:
self.next_update = datetime.now() + timedelta(seconds=120)
self.logger.info("Done healing/reviving pokemon")
def save_web_inventory(self):
web_inventory = os.path.join(
_base_dir, "web", "inventory-%s.json" % self.bot.config.username)
with open(web_inventory, "r") as infile:
ii = json.load(infile)
ii = [
x for x in ii
if not x.get("inventory_item_data", {}).get("pokedex_entry", None)
]
ii = [
x for x in ii
if not x.get("inventory_item_data", {}).get("candy", None)
]
ii = [
x for x in ii
if not x.get("inventory_item_data", {}).get("item", None)
]
ii = [
x for x in ii
if not x.get("inventory_item_data", {}).get("pokemon_data", None)
]
for pokedex in inventory.pokedex().all():
ii.append({"inventory_item_data": {"pokedex_entry": pokedex}})
for family_id, candy in inventory.candies()._data.items():
ii.append({
"inventory_item_data": {
"candy": {
"family_id": family_id,
"candy": candy.quantity
}
}
})
for item_id, item in inventory.items()._data.items():
ii.append({
"inventory_item_data": {
"item": {
"item_id": item_id,
"count": item.count
}
}
})
for pokemon in inventory.pokemons().all():
ii.append({"inventory_item_data": {"pokemon_data": pokemon._data}})
with open(web_inventory, "w") as outfile:
json.dump(ii, outfile)
def request_ordincense(self, update):
ord_incense = inventory.items().get(
Item.ITEM_INCENSE_ORDINARY.value) # @UndefinedVariable
if ord_incense.count == 0:
return False
request = self.bot.api.create_request()
request.use_incense(incense_type=401)
response_dict = request.call()
if not response_dict:
self.bot.logger.info(
"Telegram Request: Failed to use ordinary incense!")
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Failed to use ordinary incense!\n")
return False
result = response_dict.get('responses', {}).get('USE_INCENSE',
{}).get('result', 0)
self.bot.logger.info("Result = " + str(result))
if result == SUCCESS:
ord_incense.remove(1)
self.bot.logger.info(
"Telegram Request: Used ordinary incense, {} left.".format(
ord_incense.count))
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Used ordinary incense, " +
str(ord_incense.count) + " left.")
return True
elif result == ERROR_INCENSE_ALREADY_ACTIVE:
self.bot.logger.info(
"Telegram Request: Ordinary incense already active, {} left.".
format(ord_incense.count))
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Ordinary incense already active, " +
str(ord_incense.count) + " left and has " +
str(currentincense.expire_ms) + " remaining")
return True
else:
self.bot.logger.info(
"Telegram Request: Failed to use ordinary incense! Result=" +
str(result))
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Failed to use ordinary incense!\n")
return False
def _collect_level_reward(self):
response_dict = self.bot.api.level_up_rewards(level=self.current_level)
if 'status_code' in response_dict and response_dict['status_code'] == 1:
data = (response_dict
.get('responses', {})
.get('LEVEL_UP_REWARDS', {})
.get('items_awarded', []))
for item in data:
if 'item_id' in item and str(item['item_id']) in self.bot.item_list:
got_item = self.bot.item_list[str(item['item_id'])]
item['name'] = got_item
count = 'item_count' in item and item['item_count'] or 0
inventory.items().get(item['item_id']).add(count)
self.emit_event(
'level_up_reward',
formatted='Received level up reward: {items}',
data={
'items': data
}
)
def work(self):
# check for pokeballs (excluding masterball)
pokeballs_quantity = inventory.items().get(POKEBALL_ID).count
superballs_quantity = inventory.items().get(GREATBALL_ID).count
ultraballs_quantity = inventory.items().get(ULTRABALL_ID).count
if (pokeballs_quantity + superballs_quantity + ultraballs_quantity) < self.min_ball:
return WorkerResult.SUCCESS
self.update_map_location()
self.dump_caught_pokemon()
pokemon_list = self.get_pokemon_from_social()
#Temp works as it, need add more configuration
#pokemon_list = self.get_pokemon_from_map()
pokemon_list.sort(key=lambda x: x['dist'])
if self.config['mode'] == 'priority':
pokemon_list.sort(key=lambda x: x['priority'], reverse=True)
if self.config['prioritize_vips']:
pokemon_list.sort(key=lambda x: x['is_vip'], reverse=True)
if len(pokemon_list) < 1:
return WorkerResult.SUCCESS
pokemon = pokemon_list[0]
if self.config['snipe']:
if self.snipe_high_prio_only:
if self.snipe_high_prio_threshold < pokemon['priority']:
self.snipe(pokemon)
else:
return self.snipe(pokemon)
# check for pokeballs (excluding masterball)
# checking again as we may have lost some if we sniped
pokeballs_quantity = inventory.items().get(POKEBALL_ID).count
superballs_quantity = inventory.items().get(GREATBALL_ID).count
ultraballs_quantity = inventory.items().get(ULTRABALL_ID).count
if pokeballs_quantity + superballs_quantity + ultraballs_quantity < self.min_ball:
return WorkerResult.SUCCESS
nearest_fort = self.get_nearest_fort_on_the_way(pokemon)
if nearest_fort is None :
step_walker = self._move_to(pokemon)
if not step_walker.step():
if pokemon['dist'] < Constants.MAX_DISTANCE_POKEMON_IS_REACHABLE:
self._encountered(pokemon)
self.add_caught(pokemon)
return WorkerResult.SUCCESS
else :
return WorkerResult.RUNNING
else :
step_walker = self._move_to_pokemon_througt_fort(nearest_fort, pokemon)
if not step_walker or not step_walker.step():
return WorkerResult.RUNNING
def work(self):
# make sure we have SOME balls
if sum([
inventory.items().get(ball.value).count for ball in
[Item.ITEM_POKE_BALL, Item.ITEM_GREAT_BALL, Item.ITEM_ULTRA_BALL]
]) <= 0:
return WorkerResult.ERROR
# Don't try to catch a Pokemon when catching is disabled.
if self.bot.catch_disabled:
if not hasattr(self.bot,"all_disabled_global_warning") or \
(hasattr(self.bot,"all_disabled_global_warning") and not self.bot.all_disabled_global_warning):
self.logger.info(
"All catching tasks are currently disabled until {}. Ignoring all Pokemon till then."
.format(self.bot.catch_resume_at.strftime("%H:%M:%S")))
self.bot.all_disabled_global_warning = True
return WorkerResult.SUCCESS
else:
self.bot.all_disabled_global_warning = False
# check if we have already loaded a list
if len(self.pokemon) <= 0:
# load available pokemon by config settings
if self.config.get('catch_visible_pokemon', True):
self.get_visible_pokemon()
if self.config.get('catch_lured_pokemon', True):
self.get_lured_pokemon()
if self._have_applied_incense() and self.config.get(
'catch_incensed_pokemon', True):
self.get_incensed_pokemon()
random.shuffle(self.pokemon)
num_pokemon = len(self.pokemon)
if num_pokemon > 0:
# try catching
try:
if self.catch_pokemon(
self.pokemon.pop()) == WorkerResult.ERROR:
# give up incase something went wrong in our catch worker (ran out of balls, etc)
return WorkerResult.ERROR
elif num_pokemon > 1:
# we have more pokemon to catch
return WorkerResult.RUNNING
except ValueError:
return WorkerResult.ERROR
# all pokemon have been processed
return WorkerResult.SUCCESS
def get_category_inventory_list(self, category_inventory):
"""
Returns an array of items with the item id and item count.
:param category_inventory:
:return: array of items within a category:
:rtype: array
"""
x = 0
category_inventory_list = []
for c in category_inventory:
category_inventory_list.append([])
category_inventory_list[x].append(c)
category_inventory_list[x].append(inventory.items().get(c).count)
x = x + 1
return category_inventory_list
def get_category_inventory_list(self, category_inventory):
"""
Returns an array of items with the item id and item count.
:param category_inventory:
:return: array of items within a category:
:rtype: array
"""
x = 0
category_inventory_list = []
for c in category_inventory:
category_inventory_list.append([])
category_inventory_list[x].append(c)
category_inventory_list[x].append(inventory.items().get(c).count)
x = x + 1
return category_inventory_list
def initialize(self):
self.position = self.bot.position
self.pokemon_list = self.bot.pokemon_list
self.inventory = inventory.items()
self.pokedex = inventory.pokedex()
self.spawn_point_guid = ''
self.response_key = ''
self.response_status_key = ''
self.rest_completed = False
self.caught_last_24 = 0
#Config
self.min_ultraball_to_keep = self.config.get('min_ultraball_to_keep', 10)
self.berry_threshold = self.config.get('berry_threshold', 0.35)
self.vip_berry_threshold = self.config.get('vip_berry_threshold', 0.9)
self.treat_unseen_as_vip = self.config.get('treat_unseen_as_vip', DEFAULT_UNSEEN_AS_VIP)
self.daily_catch_limit = self.config.get('daily_catch_limit', 800)
self.use_pinap_on_vip = self.config.get('use_pinap_on_vip', False)
self.pinap_on_level_below = self.config.get('pinap_on_level_below', 0)
self.pinap_operator = self.config.get('pinap_operator', "or")
self.pinap_ignore_threshold = self.config.get('pinap_ignore_threshold', False)
self.vanish_settings = self.config.get('vanish_settings', {})
self.consecutive_vanish_limit = self.vanish_settings.get('consecutive_vanish_limit', 10)
self.rest_duration_min = getSeconds(self.vanish_settings.get('rest_duration_min', "02:00:00"))
self.rest_duration_max = getSeconds(self.vanish_settings.get('rest_duration_max', "04:00:00"))
self.catch_throw_parameters = self.config.get('catch_throw_parameters', {})
self.catch_throw_parameters_spin_success_rate = self.catch_throw_parameters.get('spin_success_rate', 0.6)
self.catch_throw_parameters_excellent_rate = self.catch_throw_parameters.get('excellent_rate', 0.1)
self.catch_throw_parameters_great_rate = self.catch_throw_parameters.get('great_rate', 0.5)
self.catch_throw_parameters_nice_rate = self.catch_throw_parameters.get('nice_rate', 0.3)
self.catch_throw_parameters_normal_rate = self.catch_throw_parameters.get('normal_rate', 0.1)
self.catch_throw_parameters_hit_rate = self.catch_throw_parameters.get('hit_rate', 0.8)
self.catchsim_config = self.config.get('catch_simulation', {})
self.catchsim_catch_wait_min = self.catchsim_config.get('catch_wait_min', 2)
self.catchsim_catch_wait_max = self.catchsim_config.get('catch_wait_max', 6)
self.catchsim_flee_count = int(self.catchsim_config.get('flee_count', 3))
self.catchsim_flee_duration = self.catchsim_config.get('flee_duration', 2)
self.catchsim_berry_wait_min = self.catchsim_config.get('berry_wait_min', 2)
self.catchsim_berry_wait_max = self.catchsim_config.get('berry_wait_max', 3)
self.catchsim_changeball_wait_min = self.catchsim_config.get('changeball_wait_min', 2)
self.catchsim_changeball_wait_max = self.catchsim_config.get('changeball_wait_max', 3)
self.catchsim_newtodex_wait_min = self.catchsim_config.get('newtodex_wait_min', 20)
self.catchsim_newtodex_wait_max = self.catchsim_config.get('newtodex_wait_max', 30)
def request_luckyegg(self, update):
lucky_egg = inventory.items().get(
Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
return False
response_dict = self.bot.use_lucky_egg()
if not response_dict:
self.bot.logger.info("Telegram Request: Failed to use lucky egg!")
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Failed to use lucky egg!\n")
return False
result = response_dict.get("responses",
{}).get("USE_ITEM_XP_BOOST",
{}).get("result", 0)
if result == SUCCESS:
lucky_egg.remove(1)
self.bot.logger.info(
"Telegram Request: Used lucky egg, {} left.".format(
lucky_egg.count))
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Used lucky egg, " + str(lucky_egg.count) +
" left.")
return True
elif result == ERROR_XP_BOOST_ALREADY_ACTIVE:
self.bot.logger.info(
"Telegram Request: Lucky egg already active, {} left.".format(
lucky_egg.count))
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Lucky egg already active, " +
str(lucky_egg.count) + " left.")
return True
else:
self.bot.logger.info("Telegram Request: Failed to use lucky egg!")
self.sendMessage(chat_id=update.message.chat_id,
parse_mode='Markdown',
text="Failed to use lucky egg!\n")
return False
def __init__(self, pokemon, bot, config):
self.pokemon = pokemon
self.api = bot.api
self.bot = bot
self.position = bot.position
self.pokemon_list = bot.pokemon_list
self.inventory = inventory.items()
self.spawn_point_guid = ''
self.response_key = ''
self.response_status_key = ''
#Config
self.config = config
self.min_ultraball_to_keep = config.get('min_ultraball_to_keep', 10)
self.catch_throw_parameters = config.get('catch_throw_parameters', {})
self.catch_throw_parameters_spin_success_rate = self.catch_throw_parameters.get(
'spin_success_rate', 0.6)
self.catch_throw_parameters_excellent_rate = self.catch_throw_parameters.get(
'excellent_rate', 0.1)
self.catch_throw_parameters_great_rate = self.catch_throw_parameters.get(
'great_rate', 0.5)
self.catch_throw_parameters_nice_rate = self.catch_throw_parameters.get(
'nice_rate', 0.3)
self.catch_throw_parameters_normal_rate = self.catch_throw_parameters.get(
'normal_rate', 0.1)
self.catchsim_config = config.get('catch_simulation', {})
self.catchsim_catch_wait_min = self.catchsim_config.get(
'catch_wait_min', 2)
self.catchsim_catch_wait_max = self.catchsim_config.get(
'catch_wait_max', 6)
self.catchsim_flee_count = int(
self.catchsim_config.get('flee_count', 3))
self.catchsim_flee_duration = self.catchsim_config.get(
'flee_duration', 2)
self.catchsim_berry_wait_min = self.catchsim_config.get(
'berry_wait_min', 2)
self.catchsim_berry_wait_max = self.catchsim_config.get(
'berry_wait_max', 3)
self.catchsim_changeball_wait_min = self.catchsim_config.get(
'changeball_wait_min', 2)
self.catchsim_changeball_wait_max = self.catchsim_config.get(
'changeball_wait_max', 3)
def work(self):
if sum([inventory.items().get(ball.value).count for ball in
[Item.ITEM_POKE_BALL, Item.ITEM_GREAT_BALL, Item.ITEM_ULTRA_BALL]]) <= 0:
return WorkerResult.ERROR
pokemon = []
if self.config.get('catch_visible_pokemon', True):
pokemon = self.get_visible_pokemon()
if self.config.get('catch_lured_pokemon', True):
pokemon += self.get_lured_pokemon()
num_pokemon = len(pokemon)
if num_pokemon > 0:
pokemon = self.sort_pokemon(pokemon)
self.catch_pokemon(pokemon[0])
if num_pokemon > 1:
return WorkerResult.RUNNING
return WorkerResult.SUCCESS
def recycle_excess_category_max(self, category_max, category_items_list):
"""
Recycle the item which excess the category max
:param category_max:
:param category_items_list:
:return: none:
:rtype: None
"""
worker_result = WorkerResult.SUCCESS
category_inventory = self.get_category_inventory_list(category_items_list)
category_count = 0
for i in category_inventory:
category_count = category_count + i[1]
items_to_recycle = self.get_category_items_to_recycle(category_inventory, category_count, category_max)
for item in items_to_recycle:
action_delay(self.recycle_wait_min, self.recycle_wait_max)
if ItemRecycler(self.bot, inventory.items().get(item[0]), item[1]).work() == WorkerResult.ERROR:
worker_result = WorkerResult.ERROR
return worker_result
def apply_optimization(self, transfer, evo):
self.logger.info("Transferring %s Pokemon", len(transfer))
for pokemon in transfer:
self.transfer_pokemon(pokemon)
if len(evo) == 0:
return
if self.config_evolve and self.config_may_use_lucky_egg and (
not self.bot.config.test):
lucky_egg = inventory.items().get(
Item.ITEM_LUCKY_EGG.value) # @UndefinedVariable
if lucky_egg.count == 0:
if self.config_evolve_only_with_lucky_egg:
self.emit_event(
"skip_evolve",
formatted=
"Skipping evolution step. No lucky egg available")
return
elif len(evo) < self.config_evolve_count_for_lucky_egg:
if self.config_evolve_only_with_lucky_egg:
self.emit_event(
"skip_evolve",
formatted=
"Skipping evolution step. Not enough Pokemon to evolve with lucky egg: %s/%s"
% (len(evo), self.config_evolve_count_for_lucky_egg))
return
elif self.get_pokemon_slot_left() > 5:
self.emit_event(
"skip_evolve",
formatted=
"Waiting for more Pokemon to evolve with lucky egg: %s/%s"
% (len(evo), self.config_evolve_count_for_lucky_egg))
return
else:
self.use_lucky_egg()
self.logger.info("Evolving %s Pokemon", len(evo))
for pokemon in evo:
self.evolve_pokemon(pokemon)
def recycle_excess_category_max(self, category_max, category_items_list):
"""
Recycle the item which excess the category max
:param category_max:
:param category_items_list:
:return: none:
:rtype: None
"""
worker_result = WorkerResult.SUCCESS
category_inventory = self.get_category_inventory_list(category_items_list)
category_count = 0
for i in category_inventory:
category_count = category_count + i[1]
items_to_recycle = self.get_category_items_to_recycle(category_inventory, category_count, category_max)
for item in items_to_recycle:
action_delay(self.recycle_wait_min, self.recycle_wait_max)
if inventory.items().get(item[0]).recycle(item[1]) == WorkerResult.ERROR:
worker_result = WorkerResult.ERROR
return worker_result
def work(self):
"""
Displays the items if necessary.
:return: Always returns WorkerResult.SUCCESS.
:rtype: WorkerResult
"""
if not self.should_print():
return WorkerResult.SUCCESS
self.inventory = inventory.items()
if self.show_all_multiple_lines:
self.print_all()
self.print_inv(self.get_inventory_line(True), True)
return WorkerResult.SUCCESS
line = self.get_inventory_line()
if not line:
return WorkerResult.SUCCESS
self.print_inv(line)
return WorkerResult.SUCCESS
def work(self):
"""
Discard items if necessary.
:return: Returns wether or not the task went well
:rtype: WorkerResult
"""
# TODO: Use new inventory everywhere and then remove the inventory update
# Updating inventory
inventory.refresh_inventory()
worker_result = WorkerResult.SUCCESS
if self.should_run():
# For each user's item in inventory recycle it if needed
for item_in_inventory in inventory.items().all():
amount_to_recycle = self.get_amount_to_recycle(item_in_inventory)
if self.item_should_be_recycled(item_in_inventory, amount_to_recycle):
action_delay(self.bot.config.action_wait_min, self.bot.config.action_wait_max)
if ItemRecycler(self.bot, item_in_inventory, amount_to_recycle).work() == WorkerResult.ERROR:
worker_result = WorkerResult.ERROR
return worker_result
def _should_run(self):
if not self.evolve_all or self.evolve_all[0] == 'none':
return False
# Evolve all is used - Use Lucky egg only at the first tick
if self.bot.tick_count is not 1 or not self.use_lucky_egg:
return True
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value)
# Make sure the user has a lucky egg and skip if not
if lucky_egg.count > 0:
response_dict_lucky_egg = self.bot.use_lucky_egg()
if response_dict_lucky_egg:
result = response_dict_lucky_egg.get('responses', {}).get('USE_ITEM_XP_BOOST', {}).get('result', 0)
if result is 1: # Request success
lucky_egg.remove(1)
self.emit_event(
'used_lucky_egg',
formatted='Used lucky egg ({amount_left} left).',
data={
'amount_left': lucky_egg.count
}
)
return True
else:
self.emit_event(
'lucky_egg_error',
level='error',
formatted='Failed to use lucky egg!'
)
return False
else:
# Skipping evolve so they aren't wasted
self.emit_event(
'skip_evolve',
formatted='Skipping evolve because has no lucky egg.'
)
return False
def _use_lucky_egg(self):
using_lucky_egg = time.time() - self.start_time < 1800
if using_lucky_egg:
return False
lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value)
# Make sure the user has a lucky egg and skip if not
if lucky_egg.count > 0:
response_dict_lucky_egg = self.bot.use_lucky_egg()
if response_dict_lucky_egg:
result = response_dict_lucky_egg.get('responses', {}).get('USE_ITEM_XP_BOOST', {}).get('result', 0)
if result is 1: # Request success
self.start_time = time.time()
lucky_egg.remove(1)
self.emit_event(
'used_lucky_egg',
formatted='Used lucky egg ({amount_left} left).',
data={
'amount_left': lucky_egg.count
}
)
return True
else:
self.emit_event(
'lucky_egg_error',
level='error',
formatted='Failed to use lucky egg!'
)
return False
else:
# Skipping evolve so they aren't wasted
self.emit_event(
'skip_evolve',
formatted='Skipping evolve because has no lucky egg.'
)
return False
def request_ordincense(self,update):
ord_incense = inventory.items().get(Item.ITEM_INCENSE_ORDINARY.value) # @UndefinedVariable
if ord_incense.count == 0:
return False
request = self.bot.api.create_request()
request.use_incense(incense_type=401)
response_dict = request.call()
if not response_dict:
self.bot.logger.info("Telegram Request: Failed to use ordinary incense!")
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Failed to use ordinary incense!\n")
return False
result = response_dict.get('responses', {}).get('USE_INCENSE', {}).get('result', 0)
self.bot.logger.info("Result = " + str(result))
if result == SUCCESS:
ord_incense.remove(1)
self.bot.logger.info("Telegram Request: Used ordinary incense, {} left.".format(ord_incense.count))
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Used ordinary incense, " + str(ord_incense.count) + " left.")
return True
elif result == ERROR_INCENSE_ALREADY_ACTIVE:
self.bot.logger.info("Telegram Request: Ordinary incense already active, {} left.".format(ord_incense.count))
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Ordinary incense already active, " + str(ord_incense.count) + " left and has " + str(currentincense.expire_ms) + " remaining")
return True
else:
self.bot.logger.info("Telegram Request: Failed to use ordinary incense! Result=" + str(result))
self.sendMessage(chat_id=update.message.chat_id, parse_mode='Markdown',
text="Failed to use ordinary incense!\n")
return False
def _update_inventory(self, item_awarded):
inventory.items().get(item_awarded['item_id']).add(item_awarded['item_count'])
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
is_vip = self._is_vip_pokemon(pokemon)
if inventory.items().get(ITEM_POKEBALL).count < 1:
if inventory.items().get(ITEM_GREATBALL).count < 1:
if inventory.items().get(ITEM_ULTRABALL).count < 1:
return WorkerResult.SUCCESS
elif (not is_vip) and inventory.items().get(ITEM_ULTRABALL).count <= self.min_ultraball_to_keep:
return WorkerResult.SUCCESS
# log encounter
self.emit_event(
'pokemon_appeared',
formatted='A wild {pokemon} appeared! [CP {cp}] [NCP {ncp}] [Potential {iv}] [A/D/S {iv_display}]',
data={
'pokemon': pokemon.name,
'ncp': round(pokemon.cp_percent, 2),
'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
time.sleep(3)
# check for VIP pokemon
if is_vip:
self.emit_event('vip_pokemon', formatted='This is a VIP pokemon. Catch!!!')
# check catch limits before catch
with self.bot.database as conn:
c = conn.cursor()
c.execute("SELECT DISTINCT COUNT(encounter_id) FROM catch_log WHERE dated >= datetime('now','-1 day')")
result = c.fetchone()
while True:
max_catch = self.bot.config.daily_catch_limit
if result[0] < max_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)
break
else:
self.emit_event('catch_limit', formatted='WARNING! You have reached your daily catch limit')
break
# simulate app
time.sleep(5)
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
responses = response_dict['responses']
response = responses[self.response_key]
if response[self.response_status_key] != ENCOUNTER_STATUS_SUCCESS and response[self.response_status_key] != INCENSE_ENCOUNTER_AVAILABLE:
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] == INCENSE_ENCOUNTER_NOT_AVAILABLE:
self.emit_event('pokemon_not_in_range', formatted='Incensed 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
# get pokemon data
pokemon_data = response['wild_pokemon']['pokemon_data'] if 'wild_pokemon' in response else response['pokemon_data']
pokemon = Pokemon(pokemon_data)
# check if vip pokemon
is_vip = self._is_vip_pokemon(pokemon)
# skip ignored pokemon
if not self._should_catch_pokemon(pokemon) and not is_vip:
if not hasattr(self.bot,'skipped_pokemon'):
self.bot.skipped_pokemon = []
# Check if pokemon already skipped and suppress alert if so
for skipped_pokemon in self.bot.skipped_pokemon:
if pokemon.pokemon_id == skipped_pokemon.pokemon_id and \
pokemon.cp_exact == skipped_pokemon.cp_exact and \
pokemon.ivcp == skipped_pokemon.ivcp:
return WorkerResult.SUCCESS
self.bot.skipped_pokemon.append(pokemon)
self.emit_event(
'pokemon_appeared',
formatted='Skip ignored {}! (CP {}) (Potential {}) (A/D/S {})'.format(pokemon.name, pokemon.cp, pokemon.iv, pokemon.iv_display),
data={
'pokemon': pokemon.name,
'cp': pokemon.cp,
'iv': pokemon.iv,
'iv_display': pokemon.iv_display,
}
)
return WorkerResult.SUCCESS
if inventory.items().get(ITEM_POKEBALL).count < 1:
if inventory.items().get(ITEM_GREATBALL).count < 1:
if inventory.items().get(ITEM_ULTRABALL).count < 1:
return WorkerResult.ERROR
elif (not is_vip) and inventory.items().get(ITEM_ULTRABALL).count <= self.min_ultraball_to_keep:
return WorkerResult.ERROR
# log encounter
self.emit_event(
'pokemon_appeared',
formatted='*A wild {} appeared!* (CP: {}) (NCP: {}) (Potential {}) (A/D/S {})'.format(pokemon.name, pokemon.cp, round(pokemon.cp_percent, 2), pokemon.iv, pokemon.iv_display),
data={
'pokemon': pokemon.name,
'ncp': round(pokemon.cp_percent, 2),
'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
time.sleep(3)
# check for VIP pokemon
if is_vip:
self.emit_event('vip_pokemon', formatted='This is a VIP pokemon. Catch!!!')
# check catch limits before catch
with self.bot.database as conn:
c = conn.cursor()
c.execute("SELECT DISTINCT COUNT(encounter_id) FROM catch_log WHERE dated >= datetime('now','-1 day')")
result = c.fetchone()
self.caught_last_24_hour = result[0]
while True:
if self.caught_last_24_hour < self.daily_catch_limit:
# 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)
break
else:
self.emit_event('catch_limit', formatted='WARNING! You have reached your daily catch limit')
sys.exit(2)
break
# simulate app
time.sleep(5)
def _update_inventory(self):
self.incense_ordinary_count = inventory.items().get(Item.ITEM_INCENSE_ORDINARY.value).count
self.incense_spicy_count = inventory.items().get(Item.ITEM_INCENSE_SPICY.value).count
self.incense_cool_count = inventory.items().get(Item.ITEM_INCENSE_COOL.value).count
self.incense_floral_count = inventory.items().get(Item.ITEM_INCENSE_FLORAL.value).count
