class PokemonGoBot(object):
def __init__(self, config):
self.config = config
self.pokemon_list=json.load(open('pokemon.json'))
self.item_list=json.load(open('items.json'))
def start(self):
self._setup_logging()
self._setup_api()
self.stepper = Stepper(self)
random.seed()
def take_step(self):
self.stepper.take_step()
def work_on_cell(self, cell, position):
if 'catchable_pokemons' in cell:
print '[#] Something rustles nearby!'
for pokemon in cell['catchable_pokemons']:
worker = PokemonCatchWorker(pokemon, self)
worker.work()
if 'wild_pokemons' in cell:
for pokemon in cell['wild_pokemons']:
worker = PokemonCatchWorker(pokemon, self)
worker.work()
if self.config.spinstop:
if 'forts' in cell:
# Only include those with a lat/long
forts = [fort for fort in cell['forts'] if 'latitude' in fort and 'type' in fort]
# Sort all by distance from current pos- eventually this should build graph & A* it
forts.sort(key=lambda x: SeenFortWorker.geocalc(self.position[0], self.position[1], fort['latitude'], fort['longitude']))
for fort in cell['forts']:
worker = SeenFortWorker(fort, self)
hack_chain = worker.work()
if hack_chain > 10:
print('need a rest')
break
def _setup_logging(self):
self.log = logging.getLogger(__name__)
# log settings
# log format
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
# log level for http request class
logging.getLogger("requests").setLevel(logging.WARNING)
# log level for main pgoapi class
logging.getLogger("pgoapi").setLevel(logging.INFO)
# log level for internal pgoapi class
logging.getLogger("rpc_api").setLevel(logging.INFO)
def _setup_api(self):
# instantiate pgoapi
self.api = PGoApi()
# provide player position on the earth
self._set_starting_position()
if not self.api.login(self.config.auth_service, self.config.username, self.config.password):
return
# chain subrequests (methods) into one RPC call
# get player profile call
# ----------------------
self.api.get_player()
response_dict = self.api.call()
#print('Response dictionary: \n\r{}'.format(json.dumps(response_dict, indent=2)))
currency_1="0"
currency_2="0"
player = response_dict['responses']['GET_PLAYER']['profile']
### @@@ TODO: Convert this to d/m/Y H:M:S
creation_date = datetime.datetime.fromtimestamp(player['creation_time'] / 1e3)
pokecoins = '0'
stardust = '0'
if 'amount' in player['currency'][0]:
pokecoins = player['currency'][0]['amount']
if 'amount' in player['currency'][1]:
stardust = player['currency'][1]['amount']
try:
print('[#]')
print('[#] Username: '******'username']))
print('[#] Acccount Creation: ' + str(creation_date))
print('[#] Bag Storage: ' + str(self.getInventoryCount('item')) + '/' + str(player['item_storage']))
print('[#] Pokemon Storage: ' + str(self.getInventoryCount('pokemon')) + '/' + str(player['poke_storage']))
print('[#] Stardust: ' + str(stardust))
print('[#] Pokecoins: ' + str(pokecoins))
self.getPlayerInfo()
print('[#]')
except:
print('Exception during print player profile')
self.update_inventory();
def update_inventory(self):
self.api.get_inventory()
response = self.api.call()
self.inventory = list()
if 'responses' in response:
if 'GET_INVENTORY' in response['responses']:
if 'inventory_delta' in response['responses']['GET_INVENTORY']:
if 'inventory_items' in response['responses']['GET_INVENTORY']['inventory_delta']:
for item in response['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']:
if not 'inventory_item_data' in item:
continue
if not 'item' in item['inventory_item_data']:
continue
if not 'item' in item['inventory_item_data']['item']:
continue
if not 'count' in item['inventory_item_data']['item']:
continue
self.inventory.append(item['inventory_item_data']['item'])
def _set_starting_position(self):
self.position = self._get_pos_by_name(self.config.location)
self.api.set_position(*self.position)
print('[x] Address found: ' + self.config.location)
print('[x] Position in-game set as: ' + str(self.position))
if self.config.test:
return
def _get_pos_by_name(self, location_name):
geolocator = GoogleV3(api_key=self.config.gmapkey)
loc = geolocator.geocode(location_name)
print
#self.log.info('Your given location: %s', loc.address.encode('utf-8'))
#self.log.info('lat/long/alt: %s %s %s', loc.latitude, loc.longitude, loc.altitude)
return (loc.latitude, loc.longitude, loc.altitude)
###########################################
## @eggins pretty print functions
###########################################
## - Get count of inventory items and return the output for each
def getInventoryCount(self, what):
# Get contents of inventory
self.api.get_inventory()
response_dict = self.api.call()
if 'responses' in response_dict:
if 'GET_INVENTORY' in response_dict['responses']:
if 'inventory_delta' in response_dict['responses']['GET_INVENTORY']:
if 'inventory_items' in response_dict['responses']['GET_INVENTORY']['inventory_delta']:
pokecount = 0
itemcount = 1
for item in response_dict['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']:
#print('item {}'.format(item))
if 'inventory_item_data' in item:
if 'pokemon' in item['inventory_item_data']:
pokecount = pokecount + 1
if 'item' in item['inventory_item_data']:
if 'count' in item['inventory_item_data']['item']:
itemcount = itemcount + item['inventory_item_data']['item']['count']
if 'pokemon' in what:
return pokecount
if 'item' in what:
return itemcount
return '0'
## - Get more player information
def getPlayerInfo(self):
# Get contents of inventory
self.api.get_inventory()
response_dict = self.api.call()
if 'responses' in response_dict:
if 'GET_INVENTORY' in response_dict['responses']:
if 'inventory_delta' in response_dict['responses']['GET_INVENTORY']:
if 'inventory_items' in response_dict['responses']['GET_INVENTORY']['inventory_delta']:
pokecount = 0
itemcount = 1
for item in response_dict['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']:
#print('item {}'.format(item))
if 'inventory_item_data' in item:
if 'player_stats' in item['inventory_item_data']:
playerdata = item['inventory_item_data']['player_stats']
nextlvlxp = (int(playerdata['next_level_xp']) - int(playerdata['experience']))
if 'level' in playerdata:
print('[#] -- Level: ' + str(playerdata['level']))
if 'experience' in playerdata:
print('[#] -- Experience: ' + str(playerdata['experience']))
print('[#] -- Experience until next level: ' + str(nextlvlxp))
if 'pokemons_captured' in playerdata:
print('[#] -- Pokemon Captured: ' + str(playerdata['pokemons_captured']))
if 'poke_stop_visits' in playerdata:
print('[#] -- Pokestops Visited: ' + str(playerdata['poke_stop_visits']))
class PokemonGoBot(object):
def __init__(self, config):
self.config = config
self.pokemon_list = json.load(open('data/pokemon.json'))
self.item_list = json.load(open('data/items.json'))
def start(self):
self._setup_logging()
self._setup_api()
self.stepper = Stepper(self)
random.seed()
def take_step(self):
self.stepper.take_step()
def work_on_cell(self, cell, position, include_fort_on_path):
if self.config.evolve_all:
# Run evolve all once. Flip the bit.
print('[#] Attempting to evolve all pokemons ...')
worker = EvolveAllWorker(self)
worker.work()
self.config.evolve_all = []
self._filter_ignored_pokemons(cell)
if (self.config.mode == "all" or self.config.mode ==
"poke") and 'catchable_pokemons' in cell and len(cell[
'catchable_pokemons']) > 0:
logger.log('[#] Something rustles nearby!')
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['catchable_pokemons'].sort(
key=
lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
user_web_catchable = 'web/catchable-%s.json' % (self.config.username)
for pokemon in cell['catchable_pokemons']:
with open(user_web_catchable, 'w') as outfile:
json.dump(pokemon, outfile)
if self.catch_pokemon(pokemon) == PokemonCatchWorker.NO_POKEBALLS:
break
with open(user_web_catchable, 'w') as outfile:
json.dump({}, outfile)
if (self.config.mode == "all" or self.config.mode == "poke"
) and 'wild_pokemons' in cell and len(cell['wild_pokemons']) > 0:
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['wild_pokemons'].sort(
key=
lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
for pokemon in cell['wild_pokemons']:
if self.catch_pokemon(pokemon) == PokemonCatchWorker.NO_POKEBALLS:
break
if (self.config.mode == "all" or
self.config.mode == "farm") and include_fort_on_path:
if 'forts' in cell:
# Only include those with a lat/long
forts = [fort
for fort in cell['forts']
if 'latitude' in fort and 'type' in fort]
gyms = [gym for gym in cell['forts'] if 'gym_points' in gym]
# Sort all by distance from current pos- eventually this should
# build graph & A* it
forts.sort(key=lambda x: distance(self.position[
0], self.position[1], x['latitude'], x['longitude']))
for fort in forts:
worker = MoveToFortWorker(fort, self)
worker.work()
worker = SeenFortWorker(fort, self)
hack_chain = worker.work()
if hack_chain > 10:
#print('need a rest')
break
def _setup_logging(self):
self.log = logging.getLogger(__name__)
# log settings
# log format
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
if self.config.debug:
logging.getLogger("requests").setLevel(logging.DEBUG)
logging.getLogger("pgoapi").setLevel(logging.DEBUG)
logging.getLogger("rpc_api").setLevel(logging.DEBUG)
else:
logging.getLogger("requests").setLevel(logging.ERROR)
logging.getLogger("pgoapi").setLevel(logging.ERROR)
logging.getLogger("rpc_api").setLevel(logging.ERROR)
def _setup_api(self):
# instantiate pgoapi
self.api = PGoApi()
# check if the release_config file exists
try:
with open('release_config.json') as file:
pass
except:
# the file does not exist, warn the user and exit.
logger.log('[#] IMPORTANT: Rename and configure release_config.json.example for your Pokemon release logic first!', 'red')
exit(0)
# provide player position on the earth
self._set_starting_position()
if not self.api.login(self.config.auth_service,
str(self.config.username),
str(self.config.password)):
logger.log('Login Error, server busy', 'red')
exit(0)
# chain subrequests (methods) into one RPC call
# get player profile call
# ----------------------
self.api.get_player()
response_dict = self.api.call()
#print('Response dictionary: \n\r{}'.format(json.dumps(response_dict, indent=2)))
currency_1 = "0"
currency_2 = "0"
player = response_dict['responses']['GET_PLAYER']['player_data']
# @@@ TODO: Convert this to d/m/Y H:M:S
creation_date = datetime.datetime.fromtimestamp(
player['creation_timestamp_ms'] / 1e3)
pokecoins = '0'
stardust = '0'
balls_stock = self.pokeball_inventory()
if 'amount' in player['currencies'][0]:
pokecoins = player['currencies'][0]['amount']
if 'amount' in player['currencies'][1]:
stardust = player['currencies'][1]['amount']
logger.log('[#] Username: {username}'.format(**player))
logger.log('[#] Acccount Creation: {}'.format(creation_date))
logger.log('[#] Bag Storage: {}/{}'.format(
self.get_inventory_count('item'), player['max_item_storage']))
logger.log('[#] Pokemon Storage: {}/{}'.format(
self.get_inventory_count('pokemon'), player[
'max_pokemon_storage']))
logger.log('[#] Stardust: {}'.format(stardust))
logger.log('[#] Pokecoins: {}'.format(pokecoins))
logger.log('[#] PokeBalls: ' + str(balls_stock[1]))
logger.log('[#] GreatBalls: ' + str(balls_stock[2]))
logger.log('[#] UltraBalls: ' + str(balls_stock[3]))
self.get_player_info()
if self.config.initial_transfer:
worker = InitialTransferWorker(self)
worker.work()
logger.log('[#]')
self.update_inventory()
def catch_pokemon(self, pokemon):
worker = PokemonCatchWorker(pokemon, self)
return_value = worker.work()
if return_value == PokemonCatchWorker.BAG_FULL:
worker = InitialTransferWorker(self)
worker.work()
return return_value
def drop_item(self, item_id, count):
self.api.recycle_inventory_item(item_id=item_id, count=count)
inventory_req = self.api.call()
# Example of good request response
#{'responses': {'RECYCLE_INVENTORY_ITEM': {'result': 1, 'new_count': 46}}, 'status_code': 1, 'auth_ticket': {'expire_timestamp_ms': 1469306228058L, 'start': '/HycFyfrT4t2yB2Ij+yoi+on778aymMgxY6RQgvrGAfQlNzRuIjpcnDd5dAxmfoTqDQrbz1m2dGqAIhJ+eFapg==', 'end': 'f5NOZ95a843tgzprJo4W7Q=='}, 'request_id': 8145806132888207460L}
return inventory_req
def update_inventory(self):
self.api.get_inventory()
response = self.api.call()
self.inventory = list()
if 'responses' in response:
if 'GET_INVENTORY' in response['responses']:
if 'inventory_delta' in response['responses']['GET_INVENTORY']:
if 'inventory_items' in response['responses'][
'GET_INVENTORY']['inventory_delta']:
for item in response['responses']['GET_INVENTORY'][
'inventory_delta']['inventory_items']:
if not 'inventory_item_data' in item:
continue
if not 'item' in item['inventory_item_data']:
continue
if not 'item_id' in item['inventory_item_data'][
'item']:
continue
if not 'count' in item['inventory_item_data'][
'item']:
continue
self.inventory.append(item['inventory_item_data'][
'item'])
def pokeball_inventory(self):
self.api.get_player().get_inventory()
inventory_req = self.api.call()
try:
inventory_dict = inventory_req['responses']['GET_INVENTORY'][
'inventory_delta']['inventory_items']
except KeyError as e:
print(str(e))
balls_stock = {1: 0, 2: 0, 3: 0, 4: 0}
return balls_stock
user_web_inventory = 'web/inventory-%s.json' % (self.config.username)
with open(user_web_inventory, 'w') as outfile:
json.dump(inventory_dict, outfile)
# get player balls stock
# ----------------------
balls_stock = {1: 0, 2: 0, 3: 0, 4: 0}
for item in inventory_dict:
try:
# print(item['inventory_item_data']['item'])
item_id = item['inventory_item_data']['item']['item_id']
item_count = item['inventory_item_data']['item']['count']
if item_id == Item.ITEM_POKE_BALL.value:
# print('Poke Ball count: ' + str(item_count))
balls_stock[1] = item_count
if item_id == Item.ITEM_GREAT_BALL.value:
# print('Great Ball count: ' + str(item_count))
balls_stock[2] = item_count
if item_id == Item.ITEM_ULTRA_BALL.value:
# print('Ultra Ball count: ' + str(item_count))
balls_stock[3] = item_count
except:
continue
return balls_stock
def item_inventory_count(self, id):
self.api.get_player().get_inventory()
inventory_req = self.api.call()
try:
inventory_dict = inventory_req['responses'][
'GET_INVENTORY']['inventory_delta']['inventory_items']
except KeyError as e:
print(str(e))
return 0
item_count = 0
for item in inventory_dict:
try:
if item['inventory_item_data']['item']['item_id'] == int(id):
item_count = item[
'inventory_item_data']['item']['count']
except:
continue
return item_count
def _set_starting_position(self):
if self.config.test:
# TODO: Add unit tests
return
if self.config.location:
try:
location_str = str(self.config.location)
location = (self._get_pos_by_name(location_str.replace(" ", "")))
self.position = location
self.api.set_position(*self.position)
logger.log('')
logger.log(u'[x] Address found: {}'.format(self.config.location.decode(
'utf-8')))
logger.log('[x] Position in-game set as: {}'.format(self.position))
logger.log('')
return
except:
logger.log('[x] The location given using -l could not be parsed. Checking for a cached location.')
pass
if self.config.location_cache and not self.config.location:
try:
#
# save location flag used to pull the last known location from
# the location.json
with open('data/last-location-%s.json' %
(self.config.username)) as f:
location_json = json.load(f)
self.position = (location_json['lat'],
location_json['lng'], 0.0)
self.api.set_position(*self.position)
logger.log('')
logger.log(
'[x] Last location flag used. Overriding passed in location')
logger.log(
'[x] Last in-game location was set as: {}'.format(
self.position))
logger.log('')
return
except:
if not self.config.location:
sys.exit(
"No cached Location. Please specify initial location.")
else:
pass
def _get_pos_by_name(self, location_name):
# Check if the given location is already a coordinate.
if ',' in location_name:
possibleCoordinates = re.findall("[-]?\d{1,3}[.]\d{6,7}", location_name)
if len(possibleCoordinates) == 2:
# 2 matches, this must be a coordinate. We'll bypass the Google geocode so we keep the exact location.
logger.log(
'[x] Coordinates found in passed in location, not geocoding.')
return (float(possibleCoordinates[0]), float(possibleCoordinates[1]), float("0.0"))
geolocator = GoogleV3(api_key=self.config.gmapkey)
loc = geolocator.geocode(location_name, timeout=10)
#self.log.info('Your given location: %s', loc.address.encode('utf-8'))
#self.log.info('lat/long/alt: %s %s %s', loc.latitude, loc.longitude, loc.altitude)
return (loc.latitude, loc.longitude, loc.altitude)
def _filter_ignored_pokemons(self, cell):
process_ignore = False
try:
with open("./data/catch-ignore.yml", 'r') as y:
ignores = yaml.load(y)['ignore']
if len(ignores) > 0:
process_ignore = True
except Exception, e:
pass
if process_ignore:
#
# remove any wild pokemon
try:
for p in cell['wild_pokemons'][:]:
pokemon_id = p['pokemon_data']['pokemon_id']
pokemon_name = filter(
lambda x: int(x.get('Number')) == pokemon_id,
self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['wild_pokemons'].remove(p)
except KeyError:
pass
#
# remove catchable pokemon
try:
for p in cell['catchable_pokemons'][:]:
pokemon_id = p['pokemon_id']
pokemon_name = filter(
lambda x: int(x.get('Number')) == pokemon_id,
self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['catchable_pokemons'].remove(p)
except KeyError:
pass
class PokemonGoBot(object):
def __init__(self, config):
self.config = config
self.pokemon_list=json.load(open('pokemon.json'))
self.item_list=json.load(open('items.json'))
self.noballs = False
def start(self):
self._setup_logging()
self._setup_api()
self.stepper = Stepper(self)
random.seed()
def take_step(self):
self.stepper.take_step()
def work_on_cell(self, cell, position):
if 'catchable_pokemons' in cell:
print '[#] Something rustles nearby!'
for pokemon in cell['catchable_pokemons']:
worker = PokemonCatchWorker(pokemon, self)
worker.work()
if 'wild_pokemons' in cell:
for pokemon in cell['wild_pokemons']:
worker = PokemonCatchWorker(pokemon, self)
worker.work()
# After [self.noballs = True] and first spining, check if 50 pokeballs was gathered, if so stop spining
if self.noballs and self.ballstock[1] >= 50:
print ('[#] Gathered 50/50 pokeballs, continue catching!')
self.noballs = False
elif self.noballs and self.ballstock[1] < 50:
print ('[#] Gathered ' + str(self.ballstock[1]) + '/50 pokeballs, continue farming...')
if self.config.spinstop or self.noballs:
if 'forts' in cell:
# Only include those with a lat/long
forts = [fort for fort in cell['forts'] if 'latitude' in fort and 'type' in fort]
# Sort all by distance from current pos- eventually this should build graph & A* it
forts.sort(key=lambda x: distance(self.position[0], self.position[1], fort['latitude'], fort['longitude']))
for fort in cell['forts']:
worker = SeenFortWorker(fort, self)
hack_chain = worker.work()
if hack_chain > 10:
print('[-] Anti-ban resting....')
break
def _setup_logging(self):
self.log = logging.getLogger(__name__)
# log settings
# log format
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
# log level for http request class
logging.getLogger("requests").setLevel(logging.WARNING)
# log level for main pgoapi class
logging.getLogger("pgoapi").setLevel(logging.INFO)
# log level for internal pgoapi class
logging.getLogger("rpc_api").setLevel(logging.INFO)
def _setup_api(self):
# instantiate pgoapi
self.api = PGoApi()
# provide player position on the earth
self._set_starting_position()
if not self.api.login(self.config.auth_service, self.config.username, self.config.password):
print('Login Error, server busy')
exit(0)
# chain subrequests (methods) into one RPC call
# get player inventory call
# ----------------------
self.api.get_player().get_inventory()
inventory_req = self.api.call()
inventory_dict = inventory_req['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']
# get player balls stock
# ----------------------
balls_stock = {1:0,2:0,3:0,4:0}
for item in inventory_dict:
try:
if item['inventory_item_data']['item']['item'] == 1:
#print('Poke Ball count: ' + str(item['inventory_item_data']['item']['count']))
balls_stock[1] = item['inventory_item_data']['item']['count']
if item['inventory_item_data']['item']['item'] == 2:
#print('Great Ball count: ' + str(item['inventory_item_data']['item']['count']))
balls_stock[2] = item['inventory_item_data']['item']['count']
if item['inventory_item_data']['item']['item'] == 3:
#print('Ultra Ball count: ' + str(item['inventory_item_data']['item']['count']))
balls_stock[3] = item['inventory_item_data']['item']['count']
except:
continue
self.ballstock = balls_stock
# get player pokemon[id] group by pokemon[pokemon_id]
# ----------------------
pokemon_stock = {}
for pokemon in inventory_dict:
try:
id1 = pokemon['inventory_item_data']['pokemon']['pokemon_id']
id2 = pokemon['inventory_item_data']['pokemon']['id']
id3 = pokemon['inventory_item_data']['pokemon']['cp']
#DEBUG - Hide
#print(str(id1))
if id1 not in pokemon_stock:
pokemon_stock[id1] = {}
#DEBUG - Hide
#print(str(id2))
pokemon_stock[id1].update({id3:id2})
except:
continue
#DEBUG - Hide
#print pokemon_stock
for id in pokemon_stock:
#DEBUG - Hide
#print id
sorted_cp = pokemon_stock[id].keys()
if len(sorted_cp) > 1:
sorted_cp.sort()
sorted_cp.reverse()
#DEBUG - Hide
#print sorted_cp
#Hide for now. If Unhide transfer all poke duplicates exept most CP.
#for x in range(1, len(sorted_cp)):
#DEBUG - Hide
#print x
#print pokemon_stock[id][sorted_cp[x]]
#self.api.release_pokemon(pokemon_id=pokemon_stock[id][sorted_cp[x]])
#response_dict = self.api.call()
# get player profile call
# ----------------------
self.api.get_player()
response_dict = self.api.call()
#print('Response dictionary: \n\r{}'.format(json.dumps(response_dict, indent=2)))
currency_1="0"
currency_2="0"
player = response_dict['responses']['GET_PLAYER']['profile']
### @@@ TODO: Convert this to d/m/Y H:M:S
creation_date = datetime.datetime.fromtimestamp(player['creation_time'] / 1e3)
pokecoins = '0'
stardust = '0'
if 'amount' in player['currency'][0]:
pokecoins = player['currency'][0]['amount']
if 'amount' in player['currency'][1]:
stardust = player['currency'][1]['amount']
try:
print('[#]')
print('[#] Username: '******'username']))
print('[#] Acccount Creation: ' + str(creation_date))
print('[#] Bag Storage: ' + str(self.getInventoryCount('item')) + '/' + str(player['item_storage']))
print('[#] Pokemon Storage: ' + str(self.getInventoryCount('pokemon')) + '/' + str(player['poke_storage']))
print('[#] Stardust: ' + str(stardust))
print('[#] Pokecoins: ' + str(pokecoins))
print('[#] PokeBalls: ' + str(self.ballstock[1]))
print('[#] GreatBalls: ' + str(self.ballstock[2]))
print('[#] UltraBalls: ' + str(self.ballstock[3]))
self.getPlayerInfo()
print('[#]')
except:
print('Exception during print player profile')
self.update_inventory();
def update_inventory(self):
self.api.get_inventory()
response = self.api.call()
self.inventory = list()
if 'responses' in response:
if 'GET_INVENTORY' in response['responses']:
if 'inventory_delta' in response['responses']['GET_INVENTORY']:
if 'inventory_items' in response['responses']['GET_INVENTORY']['inventory_delta']:
for item in response['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']:
if not 'inventory_item_data' in item:
continue
if not 'item' in item['inventory_item_data']:
continue
if not 'item' in item['inventory_item_data']['item']:
continue
if not 'count' in item['inventory_item_data']['item']:
continue
self.inventory.append(item['inventory_item_data']['item'])
def _set_starting_position(self):
self.position = self._get_pos_by_name(self.config.location)
self.api.set_position(*self.position)
print('[x] Address found: ' + self.config.location.decode('utf-8'))
print('[x] Position in-game set as: ' + str(self.position))
if self.config.test:
return
def _get_pos_by_name(self, location_name):
geolocator = GoogleV3(api_key=self.config.gmapkey)
loc = geolocator.geocode(location_name)
print
#self.log.info('Your given location: %s', loc.address.encode('utf-8'))
#self.log.info('lat/long/alt: %s %s %s', loc.latitude, loc.longitude, loc.altitude)
return (loc.latitude, loc.longitude, loc.altitude)
###########################################
## @eggins pretty print functions
###########################################
## - Get count of inventory items and return the output for each
def getInventoryCount(self, what):
# Get contents of inventory
self.api.get_inventory()
response_dict = self.api.call()
if 'responses' in response_dict:
if 'GET_INVENTORY' in response_dict['responses']:
if 'inventory_delta' in response_dict['responses']['GET_INVENTORY']:
if 'inventory_items' in response_dict['responses']['GET_INVENTORY']['inventory_delta']:
pokecount = 0
itemcount = 1
for item in response_dict['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']:
#print('item {}'.format(item))
if 'inventory_item_data' in item:
if 'pokemon' in item['inventory_item_data']:
pokecount = pokecount + 1
if 'item' in item['inventory_item_data']:
if 'count' in item['inventory_item_data']['item']:
itemcount = itemcount + item['inventory_item_data']['item']['count']
if 'pokemon' in what:
return pokecount
if 'item' in what:
return itemcount
return '0'
## - Get more player information
def getPlayerInfo(self):
# Get contents of inventory
self.api.get_inventory()
response_dict = self.api.call()
if 'responses' in response_dict:
if 'GET_INVENTORY' in response_dict['responses']:
if 'inventory_delta' in response_dict['responses']['GET_INVENTORY']:
if 'inventory_items' in response_dict['responses']['GET_INVENTORY']['inventory_delta']:
pokecount = 0
itemcount = 1
for item in response_dict['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']:
#print('item {}'.format(item))
if 'inventory_item_data' in item:
if 'player_stats' in item['inventory_item_data']:
playerdata = item['inventory_item_data']['player_stats']
nextlvlxp = (int(playerdata['next_level_xp']) - int(playerdata['experience']))
if 'level' in playerdata:
print('[#] -- Level: ' + str(playerdata['level']))
if 'experience' in playerdata:
print('[#] -- Experience: ' + str(playerdata['experience']))
print('[#] -- Experience until next level: ' + str(nextlvlxp))
if 'pokemons_captured' in playerdata:
print('[#] -- Pokemon Captured: ' + str(playerdata['pokemons_captured']))
if 'poke_stop_visits' in playerdata:
print('[#] -- Pokestops Visited: ' + str(playerdata['poke_stop_visits']))
class PokemonGoBot(object):
def __init__(self, config):
self.config = config
self.pokemon_list = json.load(open('data/pokemon.json'))
self.item_list = json.load(open('data/items.json'))
def start(self):
self._setup_logging()
self._setup_api()
self.stepper = Stepper(self)
random.seed()
def take_step(self):
self.stepper.take_step()
def work_on_cell(self, cell, position, include_fort_on_path):
if self.config.evolve_all:
# Run evolve all once. Flip the bit.
print('[#] Attempting to evolve all pokemons ...')
worker = EvolveAllWorker(self)
worker.work()
self.config.evolve_all = []
self._filter_ignored_pokemons(cell)
if (self.config.mode == "all" or self.config.mode ==
"poke") and 'catchable_pokemons' in cell and len(cell[
'catchable_pokemons']) > 0:
logger.log('[#] Something rustles nearby!')
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['catchable_pokemons'].sort(
key=
lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
user_web_catchable = 'web/catchable-%s.json' % (self.config.username)
for pokemon in cell['catchable_pokemons']:
with open(user_web_catchable, 'w') as outfile:
json.dump(pokemon, outfile)
if self.catch_pokemon(pokemon) == PokemonCatchWorker.NO_POKEBALLS:
break
with open(user_web_catchable, 'w') as outfile:
json.dump({}, outfile)
if (self.config.mode == "all" or self.config.mode == "poke"
) and 'wild_pokemons' in cell and len(cell['wild_pokemons']) > 0:
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['wild_pokemons'].sort(
key=
lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
for pokemon in cell['wild_pokemons']:
if self.catch_pokemon(pokemon) == PokemonCatchWorker.NO_POKEBALLS:
break
if (self.config.mode == "all" or
self.config.mode == "farm") and include_fort_on_path:
if 'forts' in cell:
# Only include those with a lat/long
forts = [fort
for fort in cell['forts']
if 'latitude' in fort and 'type' in fort]
gyms = [gym for gym in cell['forts'] if 'gym_points' in gym]
# Sort all by distance from current pos- eventually this should
# build graph & A* it
forts.sort(key=lambda x: distance(self.position[
0], self.position[1], x['latitude'], x['longitude']))
for fort in forts:
worker = MoveToFortWorker(fort, self)
worker.work()
worker = SeenFortWorker(fort, self)
hack_chain = worker.work()
if hack_chain > 10:
#print('need a rest')
break
def _setup_logging(self):
self.log = logging.getLogger(__name__)
# log settings
# log format
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
if self.config.debug:
logging.getLogger("requests").setLevel(logging.DEBUG)
logging.getLogger("pgoapi").setLevel(logging.DEBUG)
logging.getLogger("rpc_api").setLevel(logging.DEBUG)
else:
logging.getLogger("requests").setLevel(logging.ERROR)
logging.getLogger("pgoapi").setLevel(logging.ERROR)
logging.getLogger("rpc_api").setLevel(logging.ERROR)
def _setup_api(self):
# instantiate pgoapi
self.api = PGoApi()
# check if the release_config file exists
try:
with open('release_config.json') as file:
pass
except:
# the file does not exist, warn the user and exit.
logger.log('[#] IMPORTANT: Rename and configure release_config.json.example for your Pokemon release logic first!', 'red')
exit(0)
# provide player position on the earth
self._set_starting_position()
if not self.api.login(self.config.auth_service,
str(self.config.username),
str(self.config.password)):
logger.log('Login Error, server busy', 'red')
exit(0)
# chain subrequests (methods) into one RPC call
# get player profile call
# ----------------------
self.api.get_player()
response_dict = self.api.call()
#print('Response dictionary: \n\r{}'.format(json.dumps(response_dict, indent=2)))
currency_1 = "0"
currency_2 = "0"
player = response_dict['responses']['GET_PLAYER']['player_data']
# @@@ TODO: Convert this to d/m/Y H:M:S
creation_date = datetime.datetime.fromtimestamp(
player['creation_timestamp_ms'] / 1e3)
pokecoins = '0'
stardust = '0'
balls_stock = self.pokeball_inventory()
if 'amount' in player['currencies'][0]:
pokecoins = player['currencies'][0]['amount']
if 'amount' in player['currencies'][1]:
stardust = player['currencies'][1]['amount']
logger.log('[#] Username: {username}'.format(**player))
logger.log('[#] Acccount Creation: {}'.format(creation_date))
logger.log('[#] Bag Storage: {}/{}'.format(
self.get_inventory_count('item'), player['max_item_storage']))
logger.log('[#] Pokemon Storage: {}/{}'.format(
self.get_inventory_count('pokemon'), player[
'max_pokemon_storage']))
logger.log('[#] Stardust: {}'.format(stardust))
logger.log('[#] Pokecoins: {}'.format(pokecoins))
logger.log('[#] PokeBalls: ' + str(balls_stock[1]))
logger.log('[#] GreatBalls: ' + str(balls_stock[2]))
logger.log('[#] UltraBalls: ' + str(balls_stock[3]))
self.get_player_info()
if self.config.initial_transfer:
worker = InitialTransferWorker(self)
worker.work()
logger.log('[#]')
self.update_inventory()
def catch_pokemon(self, pokemon):
worker = PokemonCatchWorker(pokemon, self)
return_value = worker.work()
if return_value == PokemonCatchWorker.BAG_FULL:
worker = InitialTransferWorker(self)
worker.work()
return return_value
def drop_item(self, item_id, count):
self.api.recycle_inventory_item(item_id=item_id, count=count)
inventory_req = self.api.call()
# Example of good request response
#{'responses': {'RECYCLE_INVENTORY_ITEM': {'result': 1, 'new_count': 46}}, 'status_code': 1, 'auth_ticket': {'expire_timestamp_ms': 1469306228058L, 'start': '/HycFyfrT4t2yB2Ij+yoi+on778aymMgxY6RQgvrGAfQlNzRuIjpcnDd5dAxmfoTqDQrbz1m2dGqAIhJ+eFapg==', 'end': 'f5NOZ95a843tgzprJo4W7Q=='}, 'request_id': 8145806132888207460L}
return inventory_req
def update_inventory(self):
self.api.get_inventory()
response = self.api.call()
self.inventory = list()
if 'responses' in response:
if 'GET_INVENTORY' in response['responses']:
if 'inventory_delta' in response['responses']['GET_INVENTORY']:
if 'inventory_items' in response['responses'][
'GET_INVENTORY']['inventory_delta']:
for item in response['responses']['GET_INVENTORY'][
'inventory_delta']['inventory_items']:
if not 'inventory_item_data' in item:
continue
if not 'item' in item['inventory_item_data']:
continue
if not 'item_id' in item['inventory_item_data'][
'item']:
continue
if not 'count' in item['inventory_item_data'][
'item']:
continue
self.inventory.append(item['inventory_item_data'][
'item'])
def pokeball_inventory(self):
self.api.get_player().get_inventory()
inventory_req = self.api.call()
inventory_dict = inventory_req['responses']['GET_INVENTORY'][
'inventory_delta']['inventory_items']
user_web_inventory = 'web/inventory-%s.json' % (self.config.username)
with open(user_web_inventory, 'w') as outfile:
json.dump(inventory_dict, outfile)
# get player balls stock
# ----------------------
balls_stock = {1: 0, 2: 0, 3: 0, 4: 0}
for item in inventory_dict:
try:
# print(item['inventory_item_data']['item'])
item_id = item['inventory_item_data']['item']['item_id']
item_count = item['inventory_item_data']['item']['count']
if item_id == Item.ITEM_POKE_BALL.value:
# print('Poke Ball count: ' + str(item_count))
balls_stock[1] = item_count
if item_id == Item.ITEM_GREAT_BALL.value:
# print('Great Ball count: ' + str(item_count))
balls_stock[2] = item_count
if item_id == Item.ITEM_ULTRA_BALL.value:
# print('Ultra Ball count: ' + str(item_count))
balls_stock[3] = item_count
except:
continue
return balls_stock
def item_inventory_count(self, id):
self.api.get_player().get_inventory()
inventory_req = self.api.call()
inventory_dict = inventory_req['responses'][
'GET_INVENTORY']['inventory_delta']['inventory_items']
item_count = 0
for item in inventory_dict:
try:
if item['inventory_item_data']['item']['item_id'] == int(id):
item_count = item[
'inventory_item_data']['item']['count']
except:
continue
return item_count
def _set_starting_position(self):
if self.config.test:
# TODO: Add unit tests
return
if self.config.location:
try:
location_str = str(self.config.location)
location = (self._get_pos_by_name(location_str.replace(" ", "")))
self.position = location
self.api.set_position(*self.position)
logger.log('')
logger.log(u'[x] Address found: {}'.format(self.config.location.decode(
'utf-8')))
logger.log('[x] Position in-game set as: {}'.format(self.position))
logger.log('')
return
except:
logger.log('[x] The location given using -l could not be parsed. Checking for a cached location.')
pass
if self.config.location_cache and not self.config.location:
try:
#
# save location flag used to pull the last known location from
# the location.json
with open('data/last-location-%s.json' %
(self.config.username)) as f:
location_json = json.load(f)
self.position = (location_json['lat'],
location_json['lng'], 0.0)
self.api.set_position(*self.position)
logger.log('')
logger.log(
'[x] Last location flag used. Overriding passed in location')
logger.log(
'[x] Last in-game location was set as: {}'.format(
self.position))
logger.log('')
return
except:
if not self.config.location:
sys.exit(
"No cached Location. Please specify initial location.")
else:
pass
def _get_pos_by_name(self, location_name):
# Check if the given location is already a coordinate.
if ',' in location_name:
possibleCoordinates = re.findall("[-]?\d{1,3}[.]\d{6,7}", location_name)
if len(possibleCoordinates) == 2:
# 2 matches, this must be a coordinate. We'll bypass the Google geocode so we keep the exact location.
logger.log(
'[x] Coordinates found in passed in location, not geocoding.')
return (float(possibleCoordinates[0]), float(possibleCoordinates[1]), float("0.0"))
geolocator = GoogleV3(api_key=self.config.gmapkey)
loc = geolocator.geocode(location_name, timeout=10)
#self.log.info('Your given location: %s', loc.address.encode('utf-8'))
#self.log.info('lat/long/alt: %s %s %s', loc.latitude, loc.longitude, loc.altitude)
return (loc.latitude, loc.longitude, loc.altitude)
def _filter_ignored_pokemons(self, cell):
process_ignore = False
try:
with open("./data/catch-ignore.yml", 'r') as y:
ignores = yaml.load(y)['ignore']
if len(ignores) > 0:
process_ignore = True
except Exception, e:
pass
if process_ignore:
#
# remove any wild pokemon
try:
for p in cell['wild_pokemons'][:]:
pokemon_id = p['pokemon_data']['pokemon_id']
pokemon_name = filter(
lambda x: int(x.get('Number')) == pokemon_id,
self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['wild_pokemons'].remove(p)
except KeyError:
pass
#
# remove catchable pokemon
try:
for p in cell['catchable_pokemons'][:]:
pokemon_id = p['pokemon_id']
pokemon_name = filter(
lambda x: int(x.get('Number')) == pokemon_id,
self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['catchable_pokemons'].remove(p)
except KeyError:
pass
class PokemonGoBot(object):
def __init__(self, config):
self.config = config
self.pokemon_list = config.pokemons
self.item_list = config.items
def start(self):
self._setup_api()
self.stepper = Stepper(self)
random.seed()
def setup_logging(self, logger):
self._setup_logging()
self.logger = logger
def take_step(self):
self.stepper.take_step()
def work_on_cell(self, cell, position, include_fort_on_path):
if self.config.evolve_all:
# Run evolve all once. Flip the bit.
print('[#] Attempting to evolve all pokemons ...')
worker = EvolveAllWorker(self)
worker.work()
self.config.evolve_all = []
self._filter_ignored_pokemons(cell)
if (self.config.mode == "all" or self.config.mode ==
"poke") and 'catchable_pokemons' in cell and len(cell[
'catchable_pokemons']) > 0:
self.logger.info('[#] Something rustles nearby!')
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['catchable_pokemons'].sort(
key=
lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
if (self.config.mode == "all" or self.config.mode == "poke"
) and 'wild_pokemons' in cell and len(cell['wild_pokemons']) > 0:
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['wild_pokemons'].sort(
key=
lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
for pokemon in cell['wild_pokemons']:
if self.catch_pokemon(pokemon) == PokemonCatchWorker.NO_POKEBALLS:
break
if (self.config.mode == "all" or
self.config.mode == "farm") and include_fort_on_path:
if 'forts' in cell:
# Only include those with a lat/long
forts = [fort
for fort in cell['forts']
if 'latitude' in fort and 'type' in fort]
gyms = [gym for gym in cell['forts'] if 'gym_points' in gym]
# Sort all by distance from current pos- eventually this should
# build graph & A* it
forts.sort(key=lambda x: distance(self.position[
0], self.position[1], x['latitude'], x['longitude']))
for fort in forts:
worker = MoveToFortWorker(fort, self)
worker.work()
worker = SeenFortWorker(fort, self)
hack_chain = worker.work()
if hack_chain > 10:
#print('need a rest')
break
def _setup_logging(self):
# log settings
# log format
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
if self.config.debug:
logging.getLogger("requests").setLevel(logging.DEBUG)
logging.getLogger("pgoapi").setLevel(logging.DEBUG)
logging.getLogger("rpc_api").setLevel(logging.DEBUG)
else:
logging.getLogger("requests").setLevel(logging.ERROR)
logging.getLogger("pgoapi").setLevel(logging.ERROR)
logging.getLogger("rpc_api").setLevel(logging.ERROR)
def _setup_api(self):
# instantiate pgoapi
self.api = PGoApi()
# provide player position on the earth
self._set_starting_position()
if not self.api.login(self.config.auth_service,
str(self.config.username),
str(self.config.password)):
self.logger.error('Login Error, server busy', 'red')
exit(0)
# chain subrequests (methods) into one RPC call
# get player profile call
# ----------------------
self.api.get_player()
response_dict = self.api.call()
currency_1 = "0"
currency_2 = "0"
player = response_dict['responses']['GET_PLAYER']['player_data']
print response_dict
# @@@ TODO: Convert this to d/m/Y H:M:S
creation_date = datetime.datetime.fromtimestamp(
player['creation_timestamp_ms'] / 1e3)
pokecoins = '0'
stardust = '0'
balls_stock = self.pokeball_inventory()
if 'amount' in player['currencies'][0]:
pokecoins = player['currencies'][0]['amount']
if 'amount' in player['currencies'][1]:
stardust = player['currencies'][1]['amount']
self.logger.info('[#] Username: {username}'.format(**player))
self.logger.info('[#] Acccount Creation: {}'.format(creation_date))
self.logger.info('[#] Bag Storage: {}/{}'.format(
self.get_inventory_count('item'), player['max_item_storage']))
self.logger.info('[#] Pokemon Storage: {}/{}'.format(
self.get_inventory_count('pokemon'), player[
'max_pokemon_storage']))
self.logger.info('[#] Stardust: {}'.format(stardust))
self.logger.info('[#] Pokecoins: {}'.format(pokecoins))
self.logger.info('[#] PokeBalls: ' + str(balls_stock[1]))
self.logger.info('[#] GreatBalls: ' + str(balls_stock[2]))
self.logger.info('[#] UltraBalls: ' + str(balls_stock[3]))
self.get_player_info()
if self.config.initial_transfer:
worker = InitialTransferWorker(self)
worker.work()
self.logger.info('[#]')
self.update_inventory()
def catch_pokemon(self, pokemon):
worker = PokemonCatchWorker(pokemon, self)
return_value = worker.work()
if return_value == PokemonCatchWorker.BAG_FULL:
worker = InitialTransferWorker(self)
worker.work()
return return_value
def drop_item(self, item_id, count):
self.api.recycle_inventory_item(item_id=item_id, count=count)
inventory_req = self.api.call()
# Example of good request response
#{'responses': {'RECYCLE_INVENTORY_ITEM': {'result': 1, 'new_count': 46}}, 'status_code': 1, 'auth_ticket': {'expire_timestamp_ms': 1469306228058L, 'start': '/HycFyfrT4t2yB2Ij+yoi+on778aymMgxY6RQgvrGAfQlNzRuIjpcnDd5dAxmfoTqDQrbz1m2dGqAIhJ+eFapg==', 'end': 'f5NOZ95a843tgzprJo4W7Q=='}, 'request_id': 8145806132888207460L}
return inventory_req
def update_inventory(self):
self.api.get_inventory()
response = self.api.call()
self.inventory = list()
if 'responses' in response:
if 'GET_INVENTORY' in response['responses']:
if 'inventory_delta' in response['responses']['GET_INVENTORY']:
if 'inventory_items' in response['responses'][
'GET_INVENTORY']['inventory_delta']:
for item in response['responses']['GET_INVENTORY'][
'inventory_delta']['inventory_items']:
if not 'inventory_item_data' in item:
continue
if not 'item' in item['inventory_item_data']:
continue
if not 'item_id' in item['inventory_item_data'][
'item']:
continue
if not 'count' in item['inventory_item_data'][
'item']:
continue
self.inventory.append(item['inventory_item_data'][
'item'])
def pokeball_inventory(self):
self.api.get_player().get_inventory()
inventory_req = self.api.call()
inventory_dict = inventory_req['responses']['GET_INVENTORY'][
'inventory_delta']['inventory_items']
# get player balls stock
# ----------------------
balls_stock = {1: 0, 2: 0, 3: 0, 4: 0}
for item in inventory_dict:
try:
# print(item['inventory_item_data']['item'])
item_id = item['inventory_item_data']['item']['item_id']
item_count = item['inventory_item_data']['item']['count']
if item_id == Item.ITEM_POKE_BALL.value:
# print('Poke Ball count: ' + str(item_count))
balls_stock[1] = item_count
if item_id == Item.ITEM_GREAT_BALL.value:
# print('Great Ball count: ' + str(item_count))
balls_stock[2] = item_count
if item_id == Item.ITEM_ULTRA_BALL.value:
# print('Ultra Ball count: ' + str(item_count))
balls_stock[3] = item_count
except:
continue
return balls_stock
def item_inventory_count(self, id):
self.api.get_player().get_inventory()
inventory_req = self.api.call()
inventory_dict = inventory_req['responses'][
'GET_INVENTORY']['inventory_delta']['inventory_items']
item_count = 0
for item in inventory_dict:
try:
if item['inventory_item_data']['item']['item_id'] == int(id):
item_count = item[
'inventory_item_data']['item']['count']
except:
continue
return item_count
def _set_starting_position(self):
if self.config.test:
# TODO: Add unit tests
return
if self.config.location:
try:
location_str = str(self.config.location)
location = (self._get_pos_by_name(location_str.replace(" ", "")))
self.position = location
self.api.set_position(*self.position)
self.logger.info('')
self.logger.info(u'[x] Address found: {}'.format(self.config.location.decode(
'utf-8')))
self.logger.info('[x] Position in-game set as: {}'.format(self.position))
self.logger.info('')
return
except:
self.logger.info('[x] The location given using -l could not be parsed.')
pass
else:
raise ValueError("No usable location")
def _get_pos_by_name(self, location_name):
# Check if the given location is already a coordinate.
if ',' in location_name:
possibleCoordinates = re.findall("[-]?\d{1,3}[.]\d{6,7}", location_name)
if len(possibleCoordinates) == 2:
# 2 matches, this must be a coordinate. We'll bypass the Google geocode so we keep the exact location.
self.logger.info(
'[x] Coordinates found in passed in location, not geocoding.')
return (float(possibleCoordinates[0]), float(possibleCoordinates[1]), float("0.0"))
else:
raise ValueError("Invalid GPS")
else:
raise ValueError("Invalid GPS")
def _filter_ignored_pokemons(self, cell):
process_ignore = False
ignores = self.config.ignores
if len(ignores) > 0:
process_ignore = True
if process_ignore:
# remove any wild pokemon
try:
for p in cell['wild_pokemons'][:]:
pokemon_id = p['pokemon_data']['pokemon_id']
pokemon_name = filter(
lambda x: int(x.get('Number')) == pokemon_id,
self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['wild_pokemons'].remove(p)
except KeyError:
pass
#
# remove catchable pokemon
try:
for p in cell['catchable_pokemons'][:]:
pokemon_id = p['pokemon_id']
pokemon_name = filter(
lambda x: int(x.get('Number')) == pokemon_id,
self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['catchable_pokemons'].remove(p)
except KeyError:
pass
def heartbeat(self):
self.api.get_player()
self.api.get_hatched_eggs()
self.api.get_inventory()
self.api.check_awarded_badges()
self.api.call()
def get_inventory_count(self, what):
self.api.get_inventory()
response_dict = self.api.call()
if 'responses' in response_dict:
if 'GET_INVENTORY' in response_dict['responses']:
if 'inventory_delta' in response_dict['responses'][
'GET_INVENTORY']:
if 'inventory_items' in response_dict['responses'][
'GET_INVENTORY']['inventory_delta']:
pokecount = 0
itemcount = 1
for item in response_dict['responses'][
'GET_INVENTORY']['inventory_delta'][
'inventory_items']:
#print('item {}'.format(item))
if 'inventory_item_data' in item:
if 'pokemon_data' in item[
'inventory_item_data']:
pokecount = pokecount + 1
if 'item' in item['inventory_item_data']:
if 'count' in item['inventory_item_data'][
'item']:
itemcount = itemcount + \
item['inventory_item_data'][
'item']['count']
if 'pokemon' in what:
return pokecount
if 'item' in what:
return itemcount
return '0'
def get_player_info(self):
self.api.get_inventory()
response_dict = self.api.call()
if 'responses' in response_dict:
if 'GET_INVENTORY' in response_dict['responses']:
if 'inventory_delta' in response_dict['responses'][
'GET_INVENTORY']:
if 'inventory_items' in response_dict['responses'][
'GET_INVENTORY']['inventory_delta']:
pokecount = 0
itemcount = 1
for item in response_dict['responses'][
'GET_INVENTORY']['inventory_delta'][
'inventory_items']:
#print('item {}'.format(item))
if 'inventory_item_data' in item:
if 'player_stats' in item[
'inventory_item_data']:
playerdata = item['inventory_item_data'][
'player_stats']
nextlvlxp = (
int(playerdata.get('next_level_xp', 0)) -
int(playerdata.get('experience', 0)))
if 'level' in playerdata:
self.logger.info(
'[#] -- Level: {level}'.format(
**playerdata))
if 'experience' in playerdata:
self.logger.info(
'[#] -- Experience: {experience}'.format(
**playerdata))
self.logger.info(
'[#] -- Experience until next level: {}'.format(
nextlvlxp))
if 'pokemons_captured' in playerdata:
self.logger.info(
'[#] -- Pokemon Captured: {pokemons_captured}'.format(
**playerdata))
if 'poke_stop_visits' in playerdata:
self.logger.info(
'[#] -- Pokestops Visited: {poke_stop_visits}'.format(
**playerdata))
class PokemonGoBot(object):
def __init__(self, config):
self.config = config
self.pokemon_list=json.load(open('pokemon.json'))
self.item_list=json.load(open('items.json'))
def start(self):
self._setup_logging()
self._setup_api()
self.stepper = Stepper(self)
def take_step(self):
self.stepper.take_step()
def work_on_cell(self, cell, position):
if 'catchable_pokemons' in cell:
print 'Something rustles nearby!'
for pokemon in cell['catchable_pokemons']:
worker = PokemonCatchWorker(pokemon, self)
worker.work()
if 'wild_pokemons' in cell:
for pokemon in cell['wild_pokemons']:
worker = PokemonCatchWorker(pokemon, self)
worker.work()
if self.config.spinstop:
if 'forts' in cell:
# Only include those with a lat/long
forts = [fort for fort in cell['forts'] if 'latitude' in fort and 'type' in fort]
# Sort all by distance from current pos- eventually this should build graph & A* it
forts.sort(key=lambda x: SeenFortWorker.geocalc(self.position[0], self.position[1], fort['latitude'], fort['longitude']))
for fort in cell['forts']:
worker = SeenFortWorker(fort, self)
hack_chain = worker.work()
if hack_chain > 10:
print('need a rest')
break
def _setup_logging(self):
self.log = logging.getLogger(__name__)
# log settings
# log format
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
# log level for http request class
logging.getLogger("requests").setLevel(logging.WARNING)
# log level for main pgoapi class
logging.getLogger("pgoapi").setLevel(logging.INFO)
# log level for internal pgoapi class
logging.getLogger("rpc_api").setLevel(logging.INFO)
def _setup_api(self):
# instantiate pgoapi
self.api = PGoApi()
# provide player position on the earth
self._set_starting_position()
if not self.api.login(self.config.auth_service, self.config.username, self.config.password):
return
# chain subrequests (methods) into one RPC call
# get player profile call
# ----------------------
self.api.get_player()
response_dict = self.api.call()
#print('Response dictionary: \n\r{}'.format(json.dumps(response_dict, indent=2)))
currency_1="0"
currency_2="0"
try:
if 'amount' in response_dict['responses']['GET_PLAYER']['profile']['currency'][0]:
currency_1=response_dict['responses']['GET_PLAYER']['profile']['currency'][0]['amount']
if 'amount' in response_dict['responses']['GET_PLAYER']['profile']['currency'][1]:
currency_2=response_dict['responses']['GET_PLAYER']['profile']['currency'][1]['amount']
print 'Profile:'
print ' Username: '******'responses']['GET_PLAYER']['profile']['username'])
print ' Bag size: ' + str(response_dict['responses']['GET_PLAYER']['profile']['item_storage'])
print ' Pokemon Storage Size: ' + str(response_dict['responses']['GET_PLAYER']['profile']['poke_storage'])
print ' Account Creation: ' + str(response_dict['responses']['GET_PLAYER']['profile']['creation_time'])
print ' Currency: '
print ' ' + str(response_dict['responses']['GET_PLAYER']['profile']['currency'][0]['type']) + ': ' + str(currency_1)
print ' ' + str(response_dict['responses']['GET_PLAYER']['profile']['currency'][1]['type']) + ': ' + str(currency_2)
except:
print('Exception during print player profile')
self.update_inventory();
def update_inventory(self):
self.api.get_inventory()
response = self.api.call()
self.inventory = list()
if 'responses' in response:
if 'GET_INVENTORY' in response['responses']:
if 'inventory_delta' in response['responses']['GET_INVENTORY']:
if 'inventory_items' in response['responses']['GET_INVENTORY']['inventory_delta']:
for item in response['responses']['GET_INVENTORY']['inventory_delta']['inventory_items']:
if not 'inventory_item_data' in item:
continue
if not 'item' in item['inventory_item_data']:
continue
if not 'item' in item['inventory_item_data']['item']:
continue
if not 'count' in item['inventory_item_data']['item']:
continue
self.inventory.append(item['inventory_item_data']['item'])
def _set_starting_position(self):
self.position = self._get_pos_by_name(self.config.location)
self.api.set_position(*self.position)
print(self.position)
if self.config.test:
return
def _get_pos_by_name(self, location_name):
geolocator = GoogleV3(api_key=self.config.gmapkey)
loc = geolocator.geocode(location_name)
self.log.info('Your given location: %s', loc.address.encode('utf-8'))
self.log.info('lat/long/alt: %s %s %s', loc.latitude, loc.longitude, loc.altitude)
return (loc.latitude, loc.longitude, loc.altitude)
class PokemonGoBot(object):
process_ignored_pokemon = False
def __init__(self, config):
self.config = config
self.item_list = json.load(open('data/items.json'))
self.pokemon_list = json.load(open('data/pokemon.json'))
def start(self):
self._setup_logging()
self._setup_api()
self._setup_ignored_pokemon()
self.stepper = Stepper(self)
random.seed()
def take_step(self):
self.stepper.take_step()
def work_on_cell(self, map_cells, position, include_fort_on_path):
self._remove_ignored_pokemon(map_cells)
if (self.config.mode == "all" or self.config.mode == "poke"):
self._work_on_catchable_pokemon(map_cells)
if (self.config.mode == "all" or self.config.mode == "poke"):
self._work_on_wild_pokemon(map_cells)
if (self.config.mode == "all" or self.config.mode == "farm") and include_fort_on_path:
self._work_on_forts(position, map_cells)
def _work_on_forts(self, position, map_cells):
forts = filtered_forts(position[0], position[1], sum([cell.get("forts", []) for cell in map_cells], []))
if forts:
worker = SeenFortWorker(forts[0], self)
hack_chain = worker.work()
def _remove_ignored_pokemon(self, map_cells):
if self.process_ignored_pokemon:
try:
for cell in map_cells:
for p in cell['wild_pokemons'][:]:
pokemon_id = p['pokemon_data']['pokemon_id']
pokemon_name = filter(lambda x: int(x.get('Number')) == pokemon_id, self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['wild_pokemons'].remove(p)
except KeyError:
pass
try:
for call in map_cells:
for p in cell['catchable_pokemons'][:]:
pokemon_id = p['pokemon_id']
pokemon_name = filter(lambda x: int(x.get('Number')) == pokemon_id, self.pokemon_list)[0]['Name']
if pokemon_name in ignores:
cell['catchable_pokemons'].remove(p)
except KeyError:
pass
def _work_on_catchable_pokemon(self, map_cells):
for cell in map_cells:
if 'catchable_pokemons' in cell and len(cell['catchable_pokemons']) > 0:
logger.log('[#] Something rustles nearby!')
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['catchable_pokemons'].sort(
key=lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
for pokemon in cell['catchable_pokemons']:
with open('web/catchable-%s.json' % (self.config.username), 'w') as outfile:
json.dump(pokemon, outfile)
worker = PokemonCatchWorker(pokemon, self)
if worker.work() == -1:
break
with open('web/catchable-%s.json' % (self.config.username), 'w') as outfile:
json.dump({}, outfile)
def _work_on_wild_pokemon(self, map_cells):
for cell in map_cells:
if 'wild_pokemons' in cell and len(cell['wild_pokemons']) > 0:
# Sort all by distance from current pos- eventually this should
# build graph & A* it
cell['wild_pokemons'].sort(
key=lambda x: distance(self.position[0], self.position[1], x['latitude'], x['longitude']))
for pokemon in cell['wild_pokemons']:
worker = PokemonCatchWorker(pokemon, self)
if worker.work() == -1:
break
def _setup_logging(self):
self.log = logging.getLogger(__name__)
# log settings
# log format
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
if self.config.debug:
logging.getLogger("requests").setLevel(logging.DEBUG)
logging.getLogger("pgoapi").setLevel(logging.DEBUG)
logging.getLogger("rpc_api").setLevel(logging.DEBUG)
else:
logging.getLogger("requests").setLevel(logging.ERROR)
logging.getLogger("pgoapi").setLevel(logging.ERROR)
logging.getLogger("rpc_api").setLevel(logging.ERROR)
def _setup_api(self):
# instantiate pgoapi
self.api = PGoApi()
# provide player position on the earth
self._set_starting_position()
if not self.api.login(self.config.auth_service,
str(self.config.username),
str(self.config.password)):
logger.log('Login Error, server busy', 'red')
exit(0)
# chain subrequests (methods) into one RPC call
# get player profile call
# ----------------------
self.api.get_player()
response_dict = self.api.call()
# print('Response dictionary: \n\r{}'.format(json.dumps(response_dict, indent=2)))
currency_1 = "0"
currency_2 = "0"
player = response_dict['responses']['GET_PLAYER']['player_data']
# @@@ TODO: Convert this to d/m/Y H:M:S
creation_date = datetime.datetime.fromtimestamp(
player['creation_timestamp_ms'] / 1e3)
pokecoins = '0'
stardust = '0'
balls_stock = self.pokeball_inventory()
if 'amount' in player['currencies'][0]:
pokecoins = player['currencies'][0]['amount']
if 'amount' in player['currencies'][1]:
stardust = player['currencies'][1]['amount']
logger.log('[#]')
logger.log('[#] Username: {username}'.format(**player))
logger.log('[#] Acccount Creation: {}'.format(creation_date))
logger.log('[#] Bag Storage: {}/{}'.format(
self.get_inventory_count('item'), player['max_item_storage']))
logger.log('[#] Pokemon Storage: {}/{}'.format(
self.get_inventory_count('pokemon'), player[
'max_pokemon_storage']))
logger.log('[#] Stardust: {}'.format(stardust))
logger.log('[#] Pokecoins: {}'.format(pokecoins))
logger.log('[#] PokeBalls: {}'.format(balls_stock[1]))
logger.log('[#] GreatBalls: {}'.format(balls_stock[2]))
logger.log('[#] UltraBalls: {}'.format(balls_stock[3]))
# Testing
# self.drop_item(Item.ITEM_POTION.value,1)
# exit(0)
self.get_player_info()
if self.config.initial_transfer:
self.initial_transfer()
logger.log('[#]')
self.update_inventory()
def _setup_ignored_pokemon(self):
try:
with open("./data/catch-ignore.yml", 'r') as y:
ignores = yaml.load(y)['ignore']
if len(ignores) > 0:
self.process_ignored_pokemon = True
except Exception, e:
pass
