def _do_walk_to(self, speed, from_lat, from_lng, to_lat, to_lng, alt, delta_factor):
# type: (float, float, float, float, float, float, float) -> None
dist = distance(from_lat, from_lng, to_lat, to_lng)
steps = (dist / (self.AVERAGE_STRIDE_LENGTH_IN_METRES * speed))
logger.log("[#] Walking from " + str((from_lat, from_lng)) + " to " + str(
str((to_lat, to_lng))) + " for approx. " + str(format_time(ceil(steps))))
if steps != 0:
d_lat = (to_lat - from_lat) / steps
d_long = (to_lng - from_lng) / steps
for _ in range(int(steps)):
position_lat, position_lng, _ = self.api_wrapper.get_position()
c_lat = position_lat + d_lat + random_lat_long_delta(delta_factor)
c_long = position_lng + d_long + random_lat_long_delta(delta_factor)
self.api_wrapper.set_position(c_lat, c_long, alt)
self.bot.heartbeat()
sleep(1) # sleep one second plus a random delta
position_lat, position_lng, _ = self.api_wrapper.get_position()
self._work_at_position(position_lat, position_lng)
self.bot.heartbeat()
def work(self):
if not self.enabled:
return WorkerResult.SUCCESS
now = time.time()
if now < self.move_until:
return WorkerResult.SUCCESS
if 0 < self.stay_until < now:
self.destination = None
self.stay_until = 0
self.move_until = now + self.config_moving_time
if self.config_moving_time > 0:
return WorkerResult.SUCCESS
if self.destination is None:
forts = self.get_forts()
forts_clusters = self.get_forts_clusters(forts)
if len(forts_clusters) > 0:
self.destination = forts_clusters[0]
self.logger.info("New destination at %s meters: %s forts, %s lured.", int(self.destination[4]), self.destination[3], self.destination[2])
else:
# forts = [f for f in forts if f.get("cooldown_complete_timestamp_ms", 0) < now * 1000]
# fort = min(forts, key=lambda f: self.dist(self.bot.position, f))
# self.destination = (fort["latitude"], fort["longitude"])
return WorkerResult.SUCCESS
if (now - self.last_position_update) < 1:
return WorkerResult.RUNNING
else:
self.last_position_update = now
if self.stay_until >= now:
lat = self.destination[0] + random_lat_long_delta() / 5
lon = self.destination[1] + random_lat_long_delta() / 5
alt = self.walker.pol_alt + random_alt_delta() / 2
self.bot.api.set_position(lat, lon, alt)
else:
self.walker = PolylineWalker(self.bot, self.destination[0], self.destination[1])
self.walker.step()
dst = distance(self.bot.position[0], self.bot.position[1], self.destination[0], self.destination[1])
if dst < 1:
forts = self.get_forts()
circle = (self.destination[0], self.destination[1], Constants.MAX_DISTANCE_FORT_IS_REACHABLE)
cluster = self.get_cluster(forts, circle)
self.logger.info("Arrived at destination: %s forts, %s lured.", cluster[3], cluster[2])
self.stay_until = now + self.config_camping_time
return WorkerResult.RUNNING
def step(self):
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.bot.event_manager.emit('position_update',
sender=self,
level='debug',
data={
'current_position':
(self.destLat, self.destLng),
'last_position':
(self.initLat, self.initLng),
'distance':
'',
'distance_unit':
''
})
self.bot.heartbeat()
return True
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 = self.initLat + scaledDLat + random_lat_long_delta()
cLng = self.initLng + scaledDLng + random_lat_long_delta()
self.api.set_position(cLat, cLng, self.alt)
self.bot.event_manager.emit('position_update',
sender=self,
level='debug',
data={
'current_position': (cLat, cLng),
'last_position':
(self.initLat, self.initLng),
'distance':
'',
'distance_unit':
''
})
self.bot.heartbeat()
sleep(1) # sleep one second plus a random delta
def step(self):
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.bot.event_manager.emit(
'position_update',
sender=self,
level='debug',
data={
'current_position': (self.destLat, self.destLng),
'last_position': (self.initLat, self.initLng),
'distance': '',
'distance_unit': ''
}
)
self.bot.heartbeat()
return True
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 = self.initLat + scaledDLat + random_lat_long_delta()
cLng = self.initLng + scaledDLng + random_lat_long_delta()
cAlt = self.initAlt + self.unitAlt + random_alt_delta()
self.api.set_position(cLat, cLng, cAlt)
self.bot.event_manager.emit(
'position_update',
sender=self,
level='debug',
data={
'current_position': (cLat, cLng, cAlt),
'last_position': (self.initLat, self.initLng, self.initAlt),
'distance': '',
'distance_unit': ''
}
)
self.bot.heartbeat()
sleep(1) # sleep one second plus a random delta
def _walk_to(self, to_lat, to_lng, to_alt):
# type: (float, float, float) -> None
dist = distance(self.current_lat, self.current_lng, to_lat, to_lng)
steps = (dist / (self.AVERAGE_STRIDE_LENGTH_IN_METRES * self.speed))
if self.config.debug:
logger.log("[#] Walking from " + str((self.current_lat, self.current_lng)) + " to " + str(
str((to_lat, to_lng))) + " for approx. " + str(format_time(ceil(steps))))
if steps != 0:
d_lat = (to_lat - self.current_lat) / steps
d_long = (to_lng - self.current_lng) / steps
for _ in range(int(ceil(steps))):
c_lat = self.current_lat + d_lat + random_lat_long_delta(10)
c_long = self.current_lng + d_long + random_lat_long_delta(10)
self._jump_to(c_lat, c_long, to_alt)
self.bot.heartbeat()
def _get_steps_between(self, from_lat, from_lng, to_lat, to_lng, alt):
# type: (float, float, float) -> List[(float,float,float)]
dist = distance(from_lat, from_lng, to_lat, to_lng)
steps = (dist / (self.AVERAGE_STRIDE_LENGTH_IN_METRES * self.speed))
step_locations = list()
if steps != 0:
d_lat = (to_lat - from_lat) / steps
d_long = (to_lng - from_lng) / steps
total_steps = int(ceil(steps))
for _ in range(total_steps):
from_lat += d_lat
from_lng += d_long
c_lat = from_lat + random_lat_long_delta(10)
c_long = from_lng + random_lat_long_delta(10)
step_locations.append((c_lat, c_long, alt))
return step_locations
def _get_steps_between(self, from_lat, from_lng, to_lat, to_lng, alt):
# type: (float, float, float) -> List[(float,float,float)]
dist = distance(from_lat, from_lng, to_lat, to_lng)
steps = (dist / (self.AVERAGE_STRIDE_LENGTH_IN_METRES * self.speed))
step_locations = list()
if steps != 0:
d_lat = (to_lat - from_lat) / steps
d_long = (to_lng - from_lng) / steps
total_steps = int(ceil(steps))
for _ in range(total_steps):
from_lat += d_lat
from_lng += d_long
c_lat = from_lat + random_lat_long_delta(10)
c_long = from_lng + random_lat_long_delta(10)
step_locations.append((c_lat, c_long, alt))
return step_locations
def walk_to(self, speed, lat, lng, alt):
position_lat, position_lng, _ = self.api.get_position()
dist = distance(i2f(position_lat), i2f(position_lng), lat, lng)
steps = (dist / (self.AVERAGE_STRIDE_LENGTH_IN_METRES * speed))
logger.log("[#] Walking from " + str((i2f(position_lat), i2f(position_lng))) + " to " + str(str((lat, lng))) + " for approx. " + str(format_time(ceil(steps))))
if steps != 0:
d_lat = (lat - i2f(position_lat)) / steps
d_long = (lng - i2f(position_lng)) / steps
for _ in range(int(steps)):
position_lat, position_lng, _ = self.api.get_position()
c_lat = i2f(position_lat) + d_lat + random_lat_long_delta()
c_long = i2f(position_lng) + d_long + random_lat_long_delta()
self.api.set_position(c_lat, c_long, alt)
self.bot.heartbeat()
sleep(1) # sleep one second plus a random delta
position_lat, position_lng, _ = self.api.get_position()
self._work_at_position(i2f(position_lat), i2f(position_lng), False)
self.bot.heartbeat()
logger.log("[#] Finished walking")
