Improve humanize walking variance

pokemongo_bot/human_behaviour.py

@@ -24,6 +24,9 @@ def random_lat_long_delta():
     # 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() * 0.00001) - 0.000005) * 5
+
+def random_lat_long_delta2(bearing):
+    return ((random() * 0.00001) - 0.000005) * 5, ((random() * 0.00001) - 0.000005) * 5
 
 def random_alt_delta():
     # Return random value from [-0.2, 0.2]. Altitude is measured in meters. A delta of 0.4 could for example 

pokemongo_bot/walkers/step_walker.py

@@ -1,4 +1,4 @@
-from math import sqrt
+import math
 
 from random import uniform
 from pokemongo_bot.cell_workers.utils import distance
@@ -54,10 +54,14 @@ def __init__(self, bot, dest_lat, dest_lng, dest_alt=None, fixed_speed=None):
             self.dLng = (dest_lng - self.initLng) / int(self.steps)
             self.magnitude = self._pythagorean(self.dLat, self.dLng)
             self.unitAlt = (self.alt - self.initAlt) / int(self.steps)
+
+        self.bearing = calc_bearing(self.initLat, self.initLng, self.dLat, self.dLng)
 
     def step(self):
+        walk_sway = random_lat_long_delta2(self.bearing)
+
         if (self.dLat == 0 and self.dLng == 0) or self.dist < self.speed:
-            self.api.set_position(self.destLat + random_lat_long_delta(), self.destLng + random_lat_long_delta(), self.alt)
+            self.api.set_position(self.destLat + walk_sway[0], self.destLng + walk_sway[1], self.alt)
             self.bot.event_manager.emit(
                 'position_update',
                 sender=self,
@@ -81,8 +85,8 @@ def step(self):
         scaledDLat = unitLat * self.magnitude
         scaledDLng = unitLng * self.magnitude
 
-        cLat = self.initLat + scaledDLat + random_lat_long_delta()
-        cLng = self.initLng + scaledDLng + random_lat_long_delta()
+        cLat = self.initLat + scaledDLat + walk_sway[0]
+        cLng = self.initLng + scaledDLng + walk_sway[1]
         cAlt = self.initAlt + self.unitAlt + random_alt_delta()
 
         self.api.set_position(cLat, cLng, cAlt)
@@ -106,3 +110,43 @@ def step(self):
 
     def _pythagorean(self, lat, lng):
         return sqrt((lat ** 2) + (lng ** 2))
+
+    def calc_bearing(start_lat, start_lng, dest_lat, dest_lng):
+        """
+        Calculates the bearing between two points.
+
+        The formulae used is the following:
+            θ = atan2(sin(Δlong).cos(lat2),
+                      cos(lat1).sin(lat2) − sin(lat1).cos(lat2).cos(Δlong))
+
+        :Parameters:
+          - `start_lat in decimal degrees
+          - `start_lng in decimal degrees
+          - `dest_lat in decimal degrees
+          - `dest_lng in decimal degrees
+
+        :Returns:
+          The bearing in degrees
+
+        :Returns Type:
+          float
+        """
+
+        lat1 = math.radians(start_lat)
+        lat2 = math.radians(dest_lat)
+
+        diffLong = math.radians(dest_lng - start_lng)
+
+        x = math.sin(diffLong) * math.cos(lat2)
+        y = math.cos(lat1) * math.sin(lat2) - (math.sin(lat1)
+                * math.cos(lat2) * math.cos(diffLong))
+
+        initial_bearing = math.atan2(x, y)
+
+        # Now we have the initial bearing but math.atan2 return values
+        # from -180° to + 180° which is not what we want for a compass bearing
+        # The solution is to normalize the initial bearing as shown below
+        initial_bearing = math.degrees(initial_bearing)
+        compass_bearing = (initial_bearing + 360) % 360
+
+        return compass_bearing