Hotfix/walk to pokestop and refactor to walker (PokemonGoF#1193)

* some nice refactoring to StepWalker to avoid repetition

* removing sleep in navigator (bot should only sleep after walk and in workers)

* fixing walk to pokestop

* removing personal debug log from step walker

* removing empty line

* added random_lat_long_delta again to StepWalker (my bad)

* completely removed walking progress bar (log trimming is required)

* better log color when exchanging pokemon (red)

* less sleep after spinning pokestop

* spiral navigator shouldn't reuse step walker instance

pokemongo_bot/cell_workers/evolve_all_worker.py

@@ -109,7 +109,7 @@ def _release_evolved(self, release_cand_list_ids):
                     # Transfering Pokemon
                     self.transfer_pokemon(pokemon_id)
                     logger.log(
-                        '[#] {} has been exchanged for candy!'.format(pokemon_name), 'green')
+                        '[#] {} has been exchanged for candy!'.format(pokemon_name), 'red')
 
     def _sort_by_cp_iv(self, inventory_items):
         pokemons1 = []

pokemongo_bot/cell_workers/initial_transfer_worker.py

@@ -29,8 +29,12 @@ def work(self):
                     pokemon_data = pokemon_groups[id][pokemon_cp]
                     pokemon_potential = self.get_pokemon_potential(pokemon_data)
                     if self.should_release_pokemon(pokemon_name, pokemon_cp, pokemon_potential):
-                        logger.log('Exchanging {} [CP {}] [Potential {}]'.format(
-                            pokemon_name, pokemon_cp, pokemon_potential))
+                        message = 'Exchanging {} [CP {}] [Potential {}]'.format(
+                            pokemon_name,
+                            pokemon_cp,
+                            pokemon_potential
+                        )
+                        logger.log(message, 'red')
                         self.api.release_pokemon(
                             pokemon_id=pokemon_data['id'])
                         response_dict = self.api.call()

pokemongo_bot/cell_workers/move_to_fort_worker.py

@@ -5,14 +5,14 @@
 from pokemongo_bot.worker_result import WorkerResult
 
 class MoveToFortWorker(object):
+
     def __init__(self, fort, bot):
         self.bot = bot
         self.fort = fort
         self.api = bot.api
         self.config = bot.config
         self.navigator = bot.navigator
         self.position = bot.position
-        self._step_walker = None
 
     def work(self):
         lat = self.fort['latitude']
@@ -23,26 +23,21 @@ def work(self):
         dist = distance(self.position[0], self.position[1], lat, lng)
 
         # print('Found fort {} at distance {}m'.format(fortID, dist))
-        logger.log('Found fort {} at distance {}'.format(
+        logger.log('[x] Found fort {} at distance {}'.format(
             fortID, format_dist(dist, unit)))
 
         if dist > 10:
-            logger.log('Need to move closer to Pokestop')
-            position = (lat, lng, 0.0)
-
-            if self._step_walker == None:
-                self._step_walker = StepWalker(
-                    self.bot,
-                    self.config.walk,
-                    self.api._position_lat,
-                    self.api._position_lng,
-                    position[0],
-                    position[1]
-                )
+            logger.log('[x] Need to move closer to Pokestop')
 
+            step_walker = StepWalker(
+                self.bot,
+                self.config.walk,
+                lat,
+                lng
+            )
 
-            if not self._step_walker.step():
+            if not step_walker.step():
                 return WorkerResult.RUNNING
 
-        logger.log('Arrived at Pokestop')
+        logger.log('[o] Arrived at Pokestop')
         return WorkerResult.SUCCESS

pokemongo_bot/cell_workers/seen_fort_worker.py

@@ -116,7 +116,7 @@ def work(self):
                 logger.log('Possibly searching too often - taking a short rest :)', 'yellow')
                 self.bot.fort_timeouts[self.fort["id"]] = (time.time() + 300) * 1000  # Don't spin for 5m
                 return 11
-        sleep(8)
+        sleep(2)
         return 0
 
     @staticmethod

pokemongo_bot/step_walker.py

@@ -1,30 +1,22 @@
 from math import sqrt
 
+from pokemongo_bot import logger
 from cell_workers.utils import distance, i2f
 from human_behaviour import random_lat_long_delta, sleep
 import sys
 
 
-def progress_bar(percentage):
-    percentage = min(100, max(0, percentage))
-    if not sys.stdout.isatty():
-        return
-    sys.stdout.write('\r')
-    # http://www.fileformat.info/info/unicode/char/003D/index.htm
-    msg = (u"[%-40s] %d%%" % (u"\u003D"*int(percentage*2//5), percentage))
-    sys.stdout.write(msg)
-    sys.stdout.flush()
-
-
 class StepWalker(object):
 
-    def __init__(self, bot, speed, initLat, initLng, destLat, destLng):
+    def __init__(self, bot, speed, destLat, destLng):
         self.bot = bot
         self.api = bot.api
 
-        dist = distance(
-            i2f(initLat),
-            i2f(initLng),
+        self.initLat, self.initLng = self.bot.position[0:2]
+
+        self.dist = distance(
+            self.initLat,
+            self.initLng,
             destLat,
             destLng
         )
@@ -33,52 +25,44 @@ def __init__(self, bot, speed, initLat, initLng, destLat, destLng):
 
         self.destLat = destLat
         self.destLng = destLng
-        self.totalDist = max(1, dist)
+        self.totalDist = max(1, self.dist)
 
-        self.steps = (dist + 0.0) / (speed + 0.0)
+        self.steps = (self.dist + 0.0) / (speed + 0.0)
 
-        if dist < speed or self.steps < 1:
+        if self.dist < speed or int(self.steps) <= 1:
             self.dLat = 0
             self.dLng = 0
             self.magnitude = 0;
         else:
-            self.dLat = (destLat - i2f(initLat)) / self.steps
-            self.dLng = (destLng - i2f(initLng)) / self.steps
+            self.dLat = (destLat - self.initLat) / int(self.steps)
+            self.dLng = (destLng - self.initLng) / int(self.steps)
             self.magnitude = self._pythagorean(self.dLat, self.dLng)
 
     def step(self):
-        dist = distance(
-            i2f(self.api._position_lat),
-            i2f(self.api._position_lng),
-            self.destLat,
-            self.destLng
-        )
-
-        progress_bar(int(100 * (1 - dist/self.totalDist)))
-
-        if (self.dLat == 0 and self.dLng == 0) or dist < self.speed:
+        if (self.dLat == 0 and self.dLng == 0) or self.dist < self.speed:
             if sys.stdout.isatty():
                 sys.stdout.write('\n')
             self.api.set_position(self.destLat, self.destLng, 0)
             return True
 
-        totalDLat = (self.destLat - i2f(self.api._position_lat))
-        totalDLng = (self.destLng - i2f(self.api._position_lng))
+        totalDLat = (self.destLat - self.initLat)
+        totalDLng = (self.destLng - self.initLng)
         magnitude = self._pythagorean(totalDLat, totalDLng)
         unitLat = totalDLat / magnitude
         unitLng = totalDLng / magnitude
 
         scaledDLat = unitLat * self.magnitude
         scaledDLng = unitLng * self.magnitude
 
-        cLat = i2f(self.api._position_lat) + scaledDLat + random_lat_long_delta()
-        cLng = i2f(self.api._position_lng) + scaledDLng + random_lat_long_delta()
+        cLat = self.initLat + scaledDLat + random_lat_long_delta()
+        cLng = self.initLng + scaledDLng + random_lat_long_delta()
 
         self.api.set_position(cLat, cLng, 0)
         self.bot.heartbeat()
+
         sleep(1)  # sleep one second plus a random delta
         # self._work_at_position(
-        #     i2f(self.api._position_lat), i2f(self.api._position_lng),
+        #     self.initLat, self.initLng,
         #     alt, False)
 
     def _pythagorean(self, lat, lng):