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