def login(self, provider, username, password, position_lat, position_lng, position_alt): self._position_lat = f2i(position_lat) self._position_lng = f2i(position_lng) self._position_alt = f2i(position_alt) if not isinstance(username, basestring) or not isinstance(password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException("Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') # making a standard call, like it is also done by the client request = self.create_request() request.get_player() request.get_hatched_eggs() request.get_inventory() request.check_awarded_badges() request.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") response = request.call() if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) elif 'auth_ticket' in response: auth_ticket = response['auth_ticket'] self._auth_provider.set_ticket( [auth_ticket['expire_timestamp_ms'], auth_ticket['start'], auth_ticket['end']]) else: self.log.error('Login failed - unexpected server response!') return False self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True
def login(self, provider, username, password): if not isinstance(username, basestring) or not isinstance( password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException( "Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') # making a standard call, like it is also done by the client self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") response = self.call() if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) elif 'auth_ticket' in response: auth_ticket = response['auth_ticket'] self._auth_provider.set_ticket([ auth_ticket['expire_timestamp_ms'], auth_ticket['start'], auth_ticket['end'] ]) else: self.log.error('Login failed - unexpected server response!') return False self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True
def login(self, provider, username, password): if not isinstance(username, basestring) or not isinstance(password, basestring): raise AuthException("Username/password not correctly specified") if provider == "ptc": self._auth_provider = AuthPtc() elif provider == "google": self._auth_provider = AuthGoogle() else: raise AuthException("Invalid authentication provider - only ptc/google available.") self.log.debug("Auth provider: %s", provider) if not self._auth_provider.login(username, password): self.log.info("Login process failed") return False self.log.info("Starting RPC login sequence (app simulation)") # making a standard call, like it is also done by the client self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") response = self.call() if not response: self.log.info("Login failed!") return False if "api_url" in response: self._api_endpoint = "https://{}/rpc".format(response["api_url"]) self.log.debug("Setting API endpoint to: %s", self._api_endpoint) elif "auth_ticket" in response: auth_ticket = response["auth_ticket"] self._auth_provider.set_ticket( [auth_ticket["expire_timestamp_ms"], auth_ticket["start"], auth_ticket["end"]] ) else: self.log.error("Login failed - unexpected server response!") return False self.log.info("Finished RPC login sequence (app simulation)") self.log.info("Login process completed") return True
def login(self, provider, username, password,cached=False): if not isinstance(username, basestring) or not isinstance(password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException("Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') fname = "auth_cache_%s" % username if os.path.isfile(fname) and cached: response = pickle.load(open(fname)) else: response = self.heartbeat() f = open(fname,"w") pickle.dump(response, f) if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) else: self.log.error('Login failed - unexpected server response!') return False if 'auth_ticket' in response: self._auth_provider.set_ticket(response['auth_ticket'].values()) self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True
class PGoApi: API_ENTRY = 'https://pokemongorelease.nianticlabs.com/plfe/rpc' def __init__(self): self.log = logging.getLogger(__name__) self._auth_provider = None self._api_endpoint = None self._position_lat = 0 self._position_lng = 0 self._position_alt = 0 self._req_method_list = [] def copy(self): other = PGoApi() other.log = self.log other._auth_provider = self._auth_provider other._api_endpoint = self._api_endpoint other._position_lat = self._position_lat other._position_lng = self._position_lng other._position_alt = self._position_alt other._req_method_list = list(self._req_method_list) return other def call(self): if not self._req_method_list: return False if self._auth_provider is None or not self._auth_provider.is_login(): self.log.info('Not logged in') return False player_position = self.get_position() request = RpcApi(self._auth_provider) if self._api_endpoint: api_endpoint = self._api_endpoint else: api_endpoint = self.API_ENTRY self.log.info('Execution of RPC') response = None try: response = request.request(api_endpoint, self._req_method_list, player_position) except ServerBusyOrOfflineException as e: self.log.info('Server seems to be busy or offline - try again!') # cleanup after call execution self.log.info('Cleanup of request!') self._req_method_list = [] return response #def get_player(self): def list_curr_methods(self): for i in self._req_method_list: print("{} ({})".format(RpcEnum.RequestMethod.Name(i),i)) def set_logger(self, logger): self._ = logger or logging.getLogger(__name__) def get_position(self): return (self._position_lat, self._position_lng, self._position_alt) def set_position(self, lat, lng, alt): self.log.debug('Set Position - Lat: %s Long: %s Alt: %s', lat, lng, alt) self._position_lat = f2i(lat) self._position_lng = f2i(lng) self._position_alt = f2i(alt) def __getattr__(self, func): def function(**kwargs): if not self._req_method_list: self.log.info('Create new request...') name = func.upper() if kwargs: self._req_method_list.append( { RpcEnum.RequestMethod.Value(name): kwargs } ) self.log.info("Adding '%s' to RPC request including arguments", name) self.log.debug("Arguments of '%s': \n\r%s", name, kwargs) else: self._req_method_list.append( RpcEnum.RequestMethod.Value(name) ) self.log.info("Adding '%s' to RPC request", name) return self if func.upper() in RpcEnum.RequestMethod.keys(): return function else: raise AttributeError def login(self, provider, username, password): if not isinstance(username, basestring) or not isinstance(password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException("Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') # making a standard call, like it is also done by the client self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") response = self.call() if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) elif 'auth_ticket' in response: auth_ticket = response['auth_ticket'] self._auth_provider.set_ticket([auth_ticket['expire_timestamp_ms'], auth_ticket['start'], auth_ticket['end']]) else: self.log.error('Login failed - unexpected server response!') return False self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True
class PGoApi: API_ENTRY = 'https://pgorelease.nianticlabs.com/plfe/rpc' def __init__(self): self.log = logging.getLogger(__name__) self._auth_provider = None self._api_endpoint = None self._position_lat = 0 self._position_lng = 0 self._position_alt = 0 self._req_method_list = [] def call(self): if not self._req_method_list: return False if self._auth_provider is None or not self._auth_provider.is_login(): self.log.info('Not logged in') return False player_position = self.get_position() request = RpcApi(self._auth_provider) if self._api_endpoint: api_endpoint = self._api_endpoint else: api_endpoint = self.API_ENTRY #self.log.info('Execution of RPC') response = None try: response = request.request(api_endpoint, self._req_method_list, player_position) except ServerBusyOrOfflineException as e: self.log.info('Server seems to be busy or offline - try again!') # cleanup after call execution #self.log.info('Cleanup of request!') self._req_method_list = [] return response #def get_player(self): def list_curr_methods(self): for i in self._req_method_list: print '' #print("{} ({})".format(RpcEnum.RequestMethod.Name(i),i)) def set_logger(self, logger): self._ = logger or logging.getLogger(__name__) def get_position(self): return (self._position_lat, self._position_lng, self._position_alt) # do some keep-alive stuff def heartbeat(self): self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.call() def walk(self, speed, lat, lng, alt,walking_hook): dist = distance(i2f(self._position_lat), i2f(self._position_lng), lat, lng) steps = (dist+0.0)/(speed+0.0) # may be rational number intSteps = int(steps) residuum = steps - intSteps print '[#] Walking from ' + str((i2f(self._position_lat), i2f(self._position_lng))) + " to " + str(str((lat, lng))) + " for approx. " + str(ceil(steps)) + " seconds" if steps != 0: dLat = (lat - i2f(self._position_lat)) / steps dLng = (lng - i2f(self._position_lng)) / steps for i in range(intSteps): self.set_position(i2f(self._position_lat) + dLat + self.random_lat_long(), i2f(self._position_lng) + dLng + self.random_lat_long(), alt) self.heartbeat() if walking_hook: walking_hook(i) time.sleep(1 + self.random_sleep()) # sleep one second plus a random delta self.set_position(lat, lng, alt) self.heartbeat() print "[#] Finished walking to " + str(str((lat, lng))) def set_position(self, lat, lng, alt): #self.log.debug('Set Position - Lat: %s Long: %s Alt: %s', lat, lng, alt) self._position_lat = f2i(lat) self._position_lng = f2i(lng) self._position_alt = f2i(alt) def __getattr__(self, func): def function(**kwargs): #if not self._req_method_list: #self.log.info('Create new request...') name = func.upper() if kwargs: self._req_method_list.append( { RpcEnum.RequestMethod.Value(name): kwargs } ) #self.log.info("Adding '%s' to RPC request including arguments", name) self.log.debug("Arguments of '%s': \n\r%s", name, kwargs) else: self._req_method_list.append( RpcEnum.RequestMethod.Value(name) ) #self.log.info("Adding '%s' to RPC request", name) return self if func.upper() in RpcEnum.RequestMethod.keys(): return function else: raise AttributeError def login(self, provider, username, password): if not isinstance(username, basestring) or not isinstance(password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException("Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') # making a standard call, like it is also done by the client self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") response = self.call() if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) else: self.log.error('Login failed - unexpected server response!') return False if 'auth_ticket' in response: self._auth_provider.set_ticket(response['auth_ticket'].values()) self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True def random_lat_long(self): # Return random value from [-.000025, .000025]. Since 364,000 feet is equivalent to one degree of latitude, this # should be 364,000 * .000025 = 9.1. So it returns between [-9.1, 9.1] return ((random.random() * 0.00001) - 0.000005) * 5 def random_sleep(self): # Returns a random value from [-.2, .2]. Used to randomize sleep time. return (random.random() * 0.4) * -.2
class PGoApi: API_ENTRY = 'https://pgorelease.nianticlabs.com/plfe/rpc' def __init__(self): self.log = logging.getLogger(__name__) self._auth_provider = None self._api_endpoint = None self._position_lat = 0 self._position_lng = 0 self._position_alt = 0 self._req_method_list = [] def call(self): if not self._req_method_list: return False if self._auth_provider is None or not self._auth_provider.is_login(): self.log.info('Not logged in') return False player_position = self.get_position() request = RpcApi(self._auth_provider) if self._api_endpoint: api_endpoint = self._api_endpoint else: api_endpoint = self.API_ENTRY #self.log.info('Execution of RPC') response = None try: response = request.request(api_endpoint, self._req_method_list, player_position) except ServerBusyOrOfflineException as e: self.log.info('Server seems to be busy or offline - try again!') # cleanup after call execution #self.log.info('Cleanup of request!') self._req_method_list = [] return response #def get_player(self): def list_curr_methods(self): for i in self._req_method_list: print("{} ({})".format(RpcEnum.RequestMethod.Name(i),i)) def set_logger(self, logger): self._ = logger or logging.getLogger(__name__) def get_position(self): return (self._position_lat, self._position_lng, self._position_alt) # do some keep-alive stuff def heartbeat(self): self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.call() # Source: http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula def distance(self, lat1, lon1, lat2, lon2): p = 0.017453292519943295 a = 0.5 - cos((lat2 - lat1) * p)/2 + cos(lat1 * p) * cos(lat2 * p) * (1 - cos((lon2 - lon1) * p)) / 2 return 12742 * asin(sqrt(a)) * 1000 def walk(self, speed, lat, lng, alt): dist = self.distance(i2f(self._position_lat), i2f(self._position_lng), lat, lng) steps = (dist+0.0)/(speed+0.0) # may be rational number intSteps = int(steps) residuum = steps-intSteps print "Walking from " + str((i2f(self._position_lat), i2f(self._position_lng))) + " to " + str(str((lat, lng))) + " for approx. " + str(ceil(steps)) + " seconds" if steps != 0: dLat = (lat - i2f(self._position_lat)) / steps dLng = (lng - i2f(self._position_lng)) / steps for i in range(intSteps): self.set_position(i2f(self._position_lat) + dLat, i2f(self._position_lng) + dLng, alt) self.heartbeat() time.sleep(1) # sleep one second self.set_position(lat, lng, alt) self.heartbeat() print "Finished walking" def set_position(self, lat, lng, alt): self.log.debug('Set Position - Lat: %s Long: %s Alt: %s', lat, lng, alt) self._position_lat = f2i(lat) self._position_lng = f2i(lng) self._position_alt = f2i(alt) def __getattr__(self, func): def function(**kwargs): #if not self._req_method_list: #self.log.info('Create new request...') name = func.upper() if kwargs: self._req_method_list.append( { RpcEnum.RequestMethod.Value(name): kwargs } ) #self.log.info("Adding '%s' to RPC request including arguments", name) self.log.debug("Arguments of '%s': \n\r%s", name, kwargs) else: self._req_method_list.append( RpcEnum.RequestMethod.Value(name) ) #self.log.info("Adding '%s' to RPC request", name) return self if func.upper() in RpcEnum.RequestMethod.keys(): return function else: raise AttributeError def login(self, provider, username, password): if not isinstance(username, basestring) or not isinstance(password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException("Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') # making a standard call, like it is also done by the client self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") response = self.call() if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) else: self.log.error('Login failed - unexpected server response!') return False if 'auth_ticket' in response: self._auth_provider.set_ticket(response['auth_ticket'].values()) self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True
class PGoApi: API_ENTRY = 'https://pgorelease.nianticlabs.com/plfe/rpc' def __init__(self): self.log = logging.getLogger(__name__) self._auth_provider = None self._api_endpoint = None self._position_lat = 0 self._position_lng = 0 self._position_alt = 0 self._req_method_list = [] def call(self): if not self._req_method_list: return False if self._auth_provider is None or not self._auth_provider.is_login(): self.log.info('Not logged in') return False player_position = self.get_position() request = RpcApi(self._auth_provider) if self._api_endpoint: api_endpoint = self._api_endpoint else: api_endpoint = self.API_ENTRY self.log.info('Execution of RPC') response = None try: response = request.request(api_endpoint, self._req_method_list, player_position) except ServerBusyOrOfflineException as e: self.log.info('Server seems to be busy or offline - try again!') # cleanup after call execution self.log.info('Cleanup of request!') self._req_method_list = [] return response #def get_player(self): def list_curr_methods(self): for i in self._req_method_list: print("{} ({})".format(RpcEnum.RequestMethod.Name(i), i)) def set_logger(self, logger): self._ = logger or logging.getLogger(__name__) def get_position(self): return (self._position_lat, self._position_lng, self._position_alt) def set_position(self, lat, lng, alt): self.log.debug('Set Position - Lat: %s Long: %s Alt: %s', lat, lng, alt) self._position_lat = f2i(lat) self._position_lng = f2i(lng) self._position_alt = f2i(alt) def __getattr__(self, func): def function(**kwargs): if not self._req_method_list: self.log.info('Create new request...') name = func.upper() if kwargs: self._req_method_list.append( {RpcEnum.RequestMethod.Value(name): kwargs}) self.log.info("Adding '%s' to RPC request including arguments", name) self.log.debug("Arguments of '%s': \n\r%s", name, kwargs) else: self._req_method_list.append(RpcEnum.RequestMethod.Value(name)) self.log.info("Adding '%s' to RPC request", name) return self if func.upper() in RpcEnum.RequestMethod.keys(): return function else: raise AttributeError def login(self, provider, username, password): if not isinstance(username, basestring) or not isinstance( password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException( "Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') # making a standard call, like it is also done by the client self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() self.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") response = self.call() if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) else: self.log.error('Login failed - unexpected server response!') return False if 'auth_ticket' in response: self._auth_provider.set_ticket(response['auth_ticket'].values()) self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True
class PGoApi: API_ENTRY = 'https://pgorelease.nianticlabs.com/plfe/rpc' def __init__(self,CP_CUTOFF=0): self.log = logging.getLogger(__name__) self._auth_provider = None self._api_endpoint = None self._position_lat = 0 #int cooords self._position_lng = 0 self._position_alt = 0 self._posf = (0,0,0) # this is floats self.CP_CUTOFF = CP_CUTOFF # release anything under this if we don't have it already self._req_method_list = [] def call(self): if not self._req_method_list: return False if self._auth_provider is None or not self._auth_provider.is_login(): self.log.info('Not logged in') return False player_position = self.get_position() request = RpcApi(self._auth_provider) if self._api_endpoint: api_endpoint = self._api_endpoint else: api_endpoint = self.API_ENTRY self.log.info('Execution of RPC') response = None try: response = request.request(api_endpoint, self._req_method_list, player_position) except ServerBusyOrOfflineException as e: self.log.info('Server seems to be busy or offline - try again!') # cleanup after call execution self.log.info('Cleanup of request!') self._req_method_list = [] return response #def get_player(self): def list_curr_methods(self): for i in self._req_method_list: print("{} ({})".format(RpcEnum.RequestMethod.Name(i),i)) def set_logger(self, logger): self._ = logger or logging.getLogger(__name__) def get_position(self): return (self._position_lat, self._position_lng, self._position_alt) def set_position(self, lat, lng, alt): self.log.debug('Set Position - Lat: %s Long: %s Alt: %s', lat, lng, alt) self._posf = (lat,lng,alt) self._position_lat = f2i(lat) self._position_lng = f2i(lng) self._position_alt = f2i(alt) def __getattr__(self, func): def function(**kwargs): if not self._req_method_list: self.log.info('Create new request...') name = func.upper() if kwargs: self._req_method_list.append( { RpcEnum.RequestMethod.Value(name): kwargs } ) self.log.info("Adding '%s' to RPC request including arguments", name) self.log.debug("Arguments of '%s': \n\r%s", name, kwargs) else: self._req_method_list.append( RpcEnum.RequestMethod.Value(name) ) self.log.info("Adding '%s' to RPC request", name) return self if func.upper() in RpcEnum.RequestMethod.keys(): return function else: raise AttributeError def heartbeat(self): # making a standard call, like it is also done by the client self.get_player() self.get_hatched_eggs() self.get_inventory() self.check_awarded_badges() # self.download_settings(hash="4a2e9bc330dae60e7b74fc85b98868ab4700802e") res = self.call() print('Response dictionary: \n\r{}'.format(json.dumps(res, indent=2))) if 'GET_INVENTORY' in res['responses']: print(self.cleanup_inventory(res['responses']['GET_INVENTORY']['inventory_delta']['inventory_items'])) return res def walk_to(self,loc): #location in floats of course... steps = get_route(self._posf, loc) for step in steps: for i,next_point in enumerate(get_increments(self._posf,step)): self.set_position(*next_point) self.heartbeat() self.log.info("sleeping before next heartbeat") sleep(1) while self.catch_near_pokemon(): sleep(0.25) def spin_near_fort(self): map_cells = self.nearby_map_objects()['responses']['GET_MAP_OBJECTS']['map_cells'] forts = sum([cell.get('forts',[]) for cell in map_cells],[]) #supper ghetto lol destinations = filtered_forts(self._posf,forts) if destinations: fort = destinations[0] self.log.info("Walking to fort: %s", fort) self.walk_to((fort['latitude'], fort['longitude'])) position = self._posf # FIXME ? res = self.fort_search(fort_id = fort['id'], fort_latitude=fort['latitude'],fort_longitude=fort['longitude'],player_latitude=position[0],player_longitude=position[1]).call()['responses']['FORT_SEARCH'] self.log.info("Fort spinned: %s", res) return True else: self.log.error("No fort to walk to!") return False def catch_near_pokemon(self): map_cells = self.nearby_map_objects()['responses']['GET_MAP_OBJECTS']['map_cells'] pokemons = sum([cell.get('catchable_pokemons',[]) for cell in map_cells],[]) #supper ghetto lol # catch first pokemon: origin = (self._posf[0],self._posf[1]) pokemon_distances = [(pokemon, distance_in_meters(origin,(pokemon['latitude'], pokemon['longitude']))) for pokemon in pokemons] self.log.info("Nearby pokemon: : %s", pokemon_distances) if pokemons: target = pokemon_distances[0] self.log.info("Catching pokemon: : %s, distance: %f meters", target[0], target[1]) return self.encounter_pokemon(target[0]) return False def nearby_map_objects(self): position = self.get_position() neighbors = getNeighbors(self._posf) return self.get_map_objects(latitude=position[0], longitude=position[1], since_timestamp_ms=[0]*len(neighbors), cell_id=neighbors).call() def attempt_catch(self,encounter_id,spawnpoint_id): return self.catch_pokemon( normalized_reticle_size= 1.950, pokeball = 1, spin_modifier= 0.850, hit_pokemon=True, NormalizedHitPosition=1, encounter_id=encounter_id, spawnpoint_id=spawnpoint_id, ).call()['responses']['CATCH_POKEMON'] def cleanup_inventory(self, inventroy_items=None): if not inventroy_items: inventroy_items = self.get_inventory().call()['GET_INVENTORY']['inventory_delta']['inventory_items'] caught_pokemon = defaultdict(list) for inventory_item in inventroy_items: if "pokemon" in inventory_item['inventory_item_data']: # is a pokemon: pokemon = inventory_item['inventory_item_data']['pokemon'] if 'cp' in pokemon: caught_pokemon[pokemon["pokemon_id"]].append(pokemon) for pokemons in caught_pokemon.values(): #Only if we have more than 1 if len(pokemons) > 1: pokemons = sorted(pokemons, lambda x,y: cmp(x['cp'],y['cp']),reverse=True) # keep the first pokemon.... for pokemon in pokemons[1:]: if 'cp' in pokemon and pokemon['cp'] < self.CP_CUTOFF: self.log.info("Releasing pokemon: %s", pokemon) self.release_pokemon(pokemon_id = pokemon["id"]) return self.call() def encounter_pokemon(self,pokemon): #take in a MapPokemon from MapCell.catchable_pokemons encounter_id = pokemon['encounter_id'] spawnpoint_id = pokemon['spawnpoint_id'] # begin encounter_id position = self._posf # FIXME ? resp = self.encounter(encounter_id=encounter_id,spawnpoint_id=spawnpoint_id,player_latitude=position[0],player_longitude=position[1]).call()['responses']['ENCOUNTER'] self.log.info("Started Encounter: %s", resp) if resp['status'] == 1: capture_status = -1 # while capture_status != RpcEnum.CATCH_ERROR and capture_status != RpcEnum.CATCH_FLEE: while capture_status != 0 and capture_status != 3: catch_attempt = self.attempt_catch(encounter_id,spawnpoint_id) status = catch_attempt['status'] # if status == RpcEnum.CATCH_SUCCESS: if status == 1: self.log.info("Caught Pokemon: : %s", catch_attempt) sleep(2) return catch_attempt elif status != 2: self.log.info("Failed Catch: : %s", catch_attempt) return False sleep(2) return False def login(self, provider, username, password,cached=False): if not isinstance(username, basestring) or not isinstance(password, basestring): raise AuthException("Username/password not correctly specified") if provider == 'ptc': self._auth_provider = AuthPtc() elif provider == 'google': self._auth_provider = AuthGoogle() else: raise AuthException("Invalid authentication provider - only ptc/google available.") self.log.debug('Auth provider: %s', provider) if not self._auth_provider.login(username, password): self.log.info('Login process failed') return False self.log.info('Starting RPC login sequence (app simulation)') fname = "auth_cache_%s" % username if os.path.isfile(fname) and cached: response = pickle.load(open(fname)) else: response = self.heartbeat() f = open(fname,"w") pickle.dump(response, f) if not response: self.log.info('Login failed!') return False if 'api_url' in response: self._api_endpoint = ('https://{}/rpc'.format(response['api_url'])) self.log.debug('Setting API endpoint to: %s', self._api_endpoint) else: self.log.error('Login failed - unexpected server response!') return False if 'auth_ticket' in response: self._auth_provider.set_ticket(response['auth_ticket'].values()) self.log.info('Finished RPC login sequence (app simulation)') self.log.info('Login process completed') return True def main_loop(self): while True: try: self.heartbeat() sleep(1) self.spin_near_fort() while self.catch_near_pokemon(): sleep(4) pass except Exception as e: self.log.error("Error in main loop: %s", e) sleep(60) pass