class MovementInterface:
def __init__(self, stepper_pins, servo1_pin, servo2_pin):
GPIO.setmode(GPIO.BCM)
self.servo1 = Servo(servo1_pin) # Серво сверху
self.servo2 = Servo(servo2_pin) # Серво снизу
self.stepper = Stepper(stepper_pins)
def shot(self):
self.servo2.set_servo_angle(0)
def prepare(self):
self.servo2.set_servo_angle(0)
self.servo1.set_servo_angle(-20, hold=True)
for angle in range(-20, 160):
duty_cycle = angle / 20 + 3.
self.servo1.servo_pwm.ChangeDutyCycle(duty_cycle)
sleep(0.0125)
sleep(2)
for angle in range(160, 127, -1):
duty_cycle = angle / 20 + 3.
self.servo1.servo_pwm.ChangeDutyCycle(duty_cycle)
sleep(0.0125)
self.servo2.set_servo_angle(0)
self.servo2.set_servo_angle(-30)
self.servo1.set_servo_angle(-20)
def turn(self, degree_value):
self.stepper.turn_degree(degree_value)
def __init__(self, step_pin):
self.stepper = Stepper(step_pin, None)
self.isRunning = False
self.maxSpeedDelay = 100
self.minSpeedDelay = 2000
self.setSpeed(0)
def __init__(self):
GPIO.setup(self.HOME_DOWN_GPIO, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.setup(self.HOME_UP_GPIO, GPIO.IN, pull_up_down = GPIO.PUD_UP)
self.__stepper = Stepper(self.MICROSTEPS * self.GEAR_RATIO, self.DIRECTION_GPIO, self.PULSE_GPIO, self.BACKLASH_STEPS)
steps = 0
while self.is_home_down():
self.__stepper.pulse(self.UP_DIRECTION)
steps += 1
if (steps > self.__stepper.total_steps()):
raise ValueError("Cannot home the elevation stepper. It is likely not moving or the sensor is broken.")
while not self.is_home_down():
self.__stepper.pulse(self.DOWN_DIRECTION)
steps += 1
if (steps > self.__stepper.total_steps()):
raise ValueError("Cannot home the elevation stepper. It is likely not moving or the sensor is broken.")
steps = 0
self.__amplitude = 0
while not self.is_home_up():
self.__stepper.pulse(self.UP_DIRECTION)
steps += 1
self.__amplitude += 1
if (steps > self.__stepper.total_steps()):
raise ValueError("Cannot home the elevation stepper. It is likely not moving or the sensor is broken.")
self.__stepper.reset_position()
class VariablePump:
def __init__(self, step_pin):
self.stepper = Stepper(step_pin, None)
self.isRunning = False
self.maxSpeedDelay = 100
self.minSpeedDelay = 2000
self.setSpeed(0)
# speed is float between 0 - 1
def setSpeed(self, speed):
assert (speed <= 1) and (speed >= 0)
speedRange = self.minSpeedDelay - self.maxSpeedDelay
speedDelay = self.minSpeedDelay - (speedRange * speed)
self.stepper.set_step_time(speedDelay)
# do not use outside of the class
def __loop(self):
while self.isRunning:
self.stepper.steps(1000)
def startMotor(self):
self.isRunning = True
_thread.start_new_thread(self.__loop, ())
def stopMotor(self):
self.isRunning = False
def __init__(self):
self.is_initialized = False
rospy.init_node('manipulator_interface', anonymous=False)
self.sub = rospy.Subscriber('manipulator_command', Manipulator,
self.callback)
rospy.on_shutdown(self.shutdown)
try:
self.claw_stepper = Stepper(STEPPER_NUM_STEPS, STEPPER_CLAW_PINS,
STEPPER_CLAW_PWM_PINS, COMPUTER)
self.claw_direction = 0
self.vertical_stepper = Stepper(STEPPER_NUM_STEPS,
STEPPER_VERTICAL_PINS,
STEPPER_VERTICAL_PWM_PINS,
COMPUTER)
self.vertical_stepper_direction = 0
except NameError:
rospy.logfatal(
'Could not initialize stepper.py. Is /computer parameter set correctly? '
'Shutting down node...')
rospy.signal_shutdown('')
self.claw_stepper.disable()
self.vertical_stepper.disable()
rospy.loginfo('Initialized with {0} RPM steppers.'.format(STEPPER_RPM))
self.is_initialized = True
self.spin()
class AzimuthController:
DIRECTION_GPIO = 38
PULSE_GPIO = 40
HOME_GPIO = 22
MICROSTEPS = 400
GEAR_RATIO = 48
LEFT_DIRECTION = True
RIGHT_DIRECTION = not LEFT_DIRECTION
HOMING_DIRECTION = LEFT_DIRECTION
BACKLASH_STEPS = 12
def __init__(self):
GPIO.setup(self.HOME_GPIO, GPIO.IN, pull_up_down = GPIO.PUD_UP)
self.__stepper = Stepper(self.MICROSTEPS * self.GEAR_RATIO, self.DIRECTION_GPIO, self.PULSE_GPIO, self.BACKLASH_STEPS)
steps = 0
while self.is_home():
self.__stepper.pulse(self.HOMING_DIRECTION)
steps += 1
if (steps > self.total_steps()):
raise ValueError("Cannot home the azimuth stepper. It is likely not moving or the sensor is broken.")
while not self.is_home():
self.__stepper.pulse(self.HOMING_DIRECTION)
steps += 1
if (steps > self.total_steps()):
raise ValueError("Cannot home the azimuth stepper. It is likely not moving or the sensor is broken.")
self.__stepper.reset_position()
def is_home(self):
return not GPIO.input(self.HOME_GPIO)
def position(self):
return self.__stepper.position()
def total_steps(self):
return self.__stepper.total_steps()
def move_left(self, steps):
return self.move(self.LEFT_DIRECTION, steps)
def move_right(self, steps):
return self.move(self.RIGHT_DIRECTION, steps)
def move(self, direction, steps):
self.__stepper.move(direction, steps)
return True
def move_to(self, position, max_steps = sys.maxint):
if position < 0 or position >= self.total_steps():
raise ValueError("Invalid position")
steps_from_left = (position - self.position()) % self.total_steps()
steps_from_right = (self.position() - position) % self.total_steps()
if steps_from_left <= steps_from_right:
self.move(self.LEFT_DIRECTION, min(steps_from_left, max_steps))
return steps_from_left <= max_steps
else:
self.move(self.RIGHT_DIRECTION, min(steps_from_right, max_steps))
return steps_from_right <= max_steps
class Shelly(BaseTurtle):
bipolar1 = Stepper()
bipolar2 = Stepper(2)
def __init__(self):
self.readingarray = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
def start(self):
rcpy.set_state(rcpy.RUNNING)
time.sleep(.5)
mpu9250.initialize(enable_magnetometer=False)
time.sleep(.5)
def reset(self):
self.xyz = [0, 0, 0]
return 0
def move(self, action_vector):
t_0 = time.time()
t_stop = t_0 + 0.50
t_sensing = t_0 + 0.10 # was .25
t1 = t_0
max_accel = [0, 0, 0]
min_accel = [0, 0, 0]
sum_accel = [0, 0, 0]
max_gyro = [0, 0, 0]
min_gyro = [0, 0, 0]
motor.motor1.set(action_vector[0] * 0.35)
motor.motor2.set(action_vector[1] * 0.36)
count = 0
while t1 <= t_stop:
if t1 <= t_sensing:
data = mpu9250.read()
max_accel = np.maximum(max_accel, data['accel'])
min_accel = np.minimum(min_accel, data['accel'])
sum_accel = np.add(data['accel'], sum_accel)
max_gyro = np.maximum(max_gyro, data['gyro'])
min_gyro = np.minimum(min_gyro, data['gyro'])
count += 1
t1 = time.time()
motor.motor1.set(action_vector[0] * 0.00)
motor.motor2.set(action_vector[1] * 0.00)
if max_gyro[Z] > 100.0:
return 'TL'
elif min_gyro[Z] < -100.0: # was -150
return 'TR'
elif sum_accel[1] > 0:
return 'F'
else:
return 'R'
def stop(self):
rcpy.exit()
def test_stepper():
A = 18
B = 23
C = 24
D = 25
stepper = Stepper(A, B, C, D)
stepper.do_full_turn()
time.sleep(1)
def __init__(self):
Thread.__init__(self)
self.window = curses.initscr()
#Klasse für die drei Schrittmotoren
self.stepperMotor = Stepper()
self.wheels = Wheel()
curses.noecho()
self.window.keypad(True)
self.daemon = True
self.start()
def __init__(self, dataFromClient, socketConnection):
Thread.__init__(self)
self.dataFromClient = dataFromClient
self.komm_handy = socketConnection
self.motorCamera = Stepper()
self.wheels = Wheel()
# angabe wie gerade gefahren wird. 0=halt 1=vorwärts 2=rückwärts 3=links 4=rechts
self.richtung = 0
self.verglRichtung1 = 90 # der Motor startet bei 90Grad in der Mitte
self.verglRichtung2 = 90 # der Motor startet bei 90Grad in der Mitte
self.daemon = True
self.start()
def setup(): global Light Light = mraa.Gpio(8) Light.dir(mraa.DIR_OUT) global sensorPin sensorPin = mraa.Aio(5) global BaseStepper BaseStepper = Stepper(10,11,9,'eighth_step') global ReceiverStepper ReceiverStepper = Stepper(7,6,2,'eighth_step') ReceiverStepper.rotateMotor(45)
def __init__(self, spec: SolverSpec, stepper: Stepper):
self._ode = spec.integrator(stepper, spec.time_start, stepper.initial_value(), spec.time_bound, max_step=spec.max_timestep, \
atol=spec.absolute_tol, rtol=spec.relative_tol, vectorized=False)
self._steps = 0
self._avg_steptime = 0.0
self._tot_steptime = 0.0
self._stepper = stepper
def __init__(self, debug=False):
"""
0 : pallete
1 : Cyan
2 : Magenta
3 : Yellow
4 : Black
5 : White
"""
self.palettePosition = 0
self.stepsPerCup = 63.3333
self.maxPalettePosition = 19 * self.stepsPerCup
self.palette_colors = {}
self.debug = debug
self.activeCup = 0
# self.mixerStepper = StepperBasic(12,6,13,19)
if debug:
self.steppers = []
self.steppers.append(Stepper(0))
for i in range(1, 5):
self.steppers.append(StepperTest(i))
# set up position switches for the mixer arm
for pin in [18, 26]:
GPIO.setup(pin, GPIO.IN)
#print("testing pin {}".format(pin))
val = GPIO.input(pin)
#print(pin, val)
for out_pin in self.pin_list:
GPIO.setup(out_pin, GPIO.OUT)
GPIO.output(out_pin, GPIO.LOW)
def setup(): global LED LED = mraa.Gpio(7) LED.dir(mraa.DIR_OUT) global Light Light = mraa.Gpio(8) Light.dir(mraa.DIR_OUT) global sensorPin sensorPin = mraa.Aio(5) global BaseStepper BaseStepper = Stepper(7,6,2) global ReceiverStepper ReceiverStepper = Stepper(10,11,9)
def move_a_bit(a):
stepper = Stepper(a, 2000, 1000)
df = pd.DataFrame(index=np.arange(0, 1500 * 2),
columns=('v', 's', 'd', 't'))
t = 0.0
s = 0
try:
stepper.target_pos = 1500
while True:
d = stepper.step()
m = 1 << stepper.micro
if d == 0 or stepper.pos / m >= 300:
stepper.set_target_speed(6000)
break
t += d
df.loc[s] = [1e6 / d / m, stepper.pos / m, d / 1e6, t / 1e6]
s += 1
while True:
d = stepper.step()
m = 1 << stepper.micro
if d == 0:
break
if 1e6 / d / m < 200:
i = 1
df.loc[s] = [1e6 / d / m, stepper.pos / m, d / 1e6, t / 1e6]
t += d
s += 1
except:
print("FAIL")
return df.dropna()
def stepper_move(steps,dir,speed):
#stepper variables
# [stepPin, directionPin, enablePin]
#print steps
testStepper = Stepper([24, 22, 23])
if dir in VALID_MOVE_DIR:
#test stepper
testStepper.step(steps, dir,speed) #steps, dir, speed, stayOn
data={"Stepper move": "done",
"dir": dir,
"steps": steps,
"speed": speed
}
else:
data={'Move': 'ERROR',
'error': 'Invalid direction.'}
return data
def start(self):
self._setup_logging()
self._setup_api()
if self.config.stats:
## exit early and just show stats
print '[ stats mode, exiting ... ]'
exit()
self.stepper = Stepper(self)
random.seed()
def __init__(self, configFile="hardware.cfg", config=None):
if config == None:
f = open('hardware.cfg')
hardconfobj = ujson.loads(f.read())
self.config = hardconfobj["valve"]
f.close()
else:
self.config = config
#self.config["homeSencePin"]
#self.config["homePosToValve"] in mm
#self.config["valveToValve"] in mm
#self.config["valveAmmount"]
#self.config["maxSteps"]
# mm von ventil zu ventil * schritte pro umdrehung / gewindesteigung
self.stepsValveToValve = int(
self.config["valveToValve"] *
((4075.7728395061727 / 2) / self._m5_steigung))
print(self.stepsValveToValve)
self.stepshomePosToValve = int(
self.config["homePosToValve"] *
((4075.7728395061727 / 2) / self._m5_steigung))
self.homingIsrunning = False
self.valveReachedCB = None
self.homingCB = None
self.homepin = Pin(self.config["homeSencePin"], Pin.IN)
pin = self.config["stepperPins"]
self.valveStepper = Stepper(pin[0], pin[1], pin[2], pin[3],
self.config["steps-s"],
self.config["maxSteps"])
def testStepper():
print '=== Stepper Test ==='
print 'to do: Stepper PINs to output'
stepper = Stepper()
stepper.turn(45,100)
stepper.turnAsync(-45,50)
while(not stepper.isMovementFinished()):
time.sleep(0.02)
def __init__(self):
self.is_initialized = False
rospy.init_node('manipulator_interface', anonymous=False)
self.pub = rospy.Publisher('pwm', Pwm, queue_size=1)
self.sub = rospy.Subscriber('manipulator_command', Manipulator, self.callback)
self.neutral_pulse_width = servo_position_to_microsecs(0)
rospy.sleep(0.1) # Initial set to zero seems to disappear without a short sleep here
self.servo_set_to_zero()
rospy.on_shutdown(self.shutdown)
self.claw_direction = 0.0
self.claw_position = 0.0 # 1 = open, -1 = closed
self.claw_speed = 1.0
try:
self.valve_stepper = Stepper(STEPPER_NUM_STEPS,
STEPPER_VALVE_PINS,
STEPPER_VALVE_ENABLE_PIN,
COMPUTER)
self.valve_direction = 0
self.agar_stepper = Stepper(STEPPER_NUM_STEPS,
STEPPER_AGAR_PINS,
STEPPER_AGAR_ENABLE_PIN,
COMPUTER)
self.agar_direction = 0
except NameError:
rospy.logfatal('Could not initialize stepper.py. Is /computer parameter set correctly? '
'Shutting down node...')
rospy.signal_shutdown('')
self.valve_stepper.disable()
self.agar_stepper.disable()
rospy.loginfo('Initialized with {0} RPM steppers.'.format(STEPPER_RPM))
self.is_initialized = True
self.spin()
def accel_2_integer(steps, a):
stepper = Stepper(a, 10000, 700)
stepper.target_pos = steps
df = pd.DataFrame(index=np.arange(0, steps * 16),
columns=('v', 's', 'd', 't', 'adj_d', 'micro', 'shift'))
t = 0
s = 0
while True:
d = stepper.step()
if d == 0 or s > steps * 16:
break
m = 1 << stepper.micro
v = 1e6 / d / m
p = stepper.pos / m
ad = d * m
t += d
df.loc[s] = [v, p, d, t / 1e6, ad, m, stepper.shift]
s += 1
return df.dropna()
def setup():
global LED
LED = mraa.Gpio(7)
LED.dir(mraa.DIR_OUT)
global sensorPin
sensorPin = mraa.Aio(2)
global myStepper
myStepper = Stepper()
global myServo
myServo = Servo()
myServo.attach(9)
myServo.write(30)
def __init__(self,
name="fibre",
length=1.0,
alpha=None,
beta=None,
gamma=0.0,
sim_type=None,
traces=1,
local_error=1.0e-6,
method="RK4IP",
total_steps=100,
self_steepening=False,
raman_scattering=False,
rs_factor=0.003,
use_all=False,
centre_omega=None,
tau_1=12.2e-3,
tau_2=32.0e-3,
f_R=0.18):
use_cache = not (method.upper().startswith('A'))
self.name = name
self.length = length
self.linearity = Linearity(alpha, beta, sim_type, use_cache,
centre_omega)
self.nonlinearity = Nonlinearity(gamma, sim_type, self_steepening,
raman_scattering, rs_factor, use_all,
tau_1, tau_2, f_R)
class Function():
""" Class to hold linear and nonlinear functions. """
def __init__(self, l, n, linear, nonlinear):
self.l = l
self.n = n
self.linear = linear
self.nonlinear = nonlinear
def __call__(self, A, z):
return self.l(A, z) + self.n(A, z)
self.function = Function(self.l, self.n, self.linear, self.nonlinear)
self.stepper = Stepper(traces, local_error, method, self.function,
self.length, total_steps)
def duster(settings, model_id, zone_id):
assert ONLY_MODEL_2 and model_id == 2, "ONLY HAVE HYDRO DATA FOR MODEL_IDX=2"
print(f"M{model_id} (Z{zone_id}) loading input...(slow for now)")
p = load_particle(settings["particle_inputfile"], \
settings["hydrorun_inputfile"], \
model_id, zone_id)
output_d = f"output_M{model_id:03d}"
os.makedirs(output_d, exist_ok=True)
output_f = os.path.join(output_d, f"dust{zone_id:04}")
net = Network(settings["network_file"])
print(
f"M{model_id} (Z{zone_id}) loaded, beginnging run: output[{output_f}]")
gas = SNGas(p, net)
step = Stepper(gas, net)
spec = SolverSpec(time_start = p.times[p.first_idx], time_bound = p.times[p.last_idx], absolute_tol = settings["abs_tol"], \
relative_tol = settings["rel_tol"], max_timestep = settings["max_dt"])
print(f"time_start = {p.times[p.first_idx]}")
solv = Solver(spec, step)
obs = Observer(output_f, net, gas, step, solv, settings)
msg = f"M{model_id} (Z{zone_id}) ok"
try:
solv(obs)
except Exception as e:
msg = f"M{model_id} (Z{zone_id}) did not finish ok\n{repr(e)}"
print(msg)
traceback.print_exc(file=sys.stdout)
# obs.dump(solv._steps)
finally:
# obs.runout(solv._steps, settings["align_tend_value"], res=settings["align_tend_resolution"])
## TIMING
from stepper import S_DEBUG, S_FASTMATH, S_NOPYTHON, S_PARALLEL
print(
f"DEBUG={S_DEBUG}, NOPYTHON={S_NOPYTHON}, FASTMATH={S_FASTMATH}, PARALLEL={S_PARALLEL}"
)
return msg
def stepper_test():
#stepper variables
# [stepPin, directionPin, enablePin]
testStepper = Stepper([24, 22, 23])
#test stepper
testStepper.step(20000, "CW"); #steps, dir, speed, stayOn
sleep(2)
# test stepper
testStepper.step(64000, "CCW"); # steps, dir, speed, stayOn
return {"Stepper test": "done"}
class PrecisionPump:
def __init__(self, step_pin, dir_pin):
self.stepper = Stepper(step_pin, dir_pin)
self.stepper.set_step_time(750)
self.dir = 1
self.stepsPerML = 5680 #TODO: determine proper amount
def feed(self, ml_amount):
stepsToTake = ml_amount * self.stepsPerML * self.dir
self.stepper.steps(stepsToTake)
# just for testing
def step(self, steps):
self.stepper.steps(steps)
def reverse(self):
self.dir = 1 if self.dir == 1 else -1
def dispense(value):
value = float(value)
try:
print("Setting up OGR")
ogr = ScaleOGR(False, False)
stepper = Stepper(1000000)
f = Filter(0.2)
print("Setting up camera")
camera = PiCamera()
camera.close()
camera = PiCamera()
camera.resolution = (1920, 1088)
camera.framerate = 30
rawCapture = PiRGBArray(camera, size=(1920, 1088))
print("Getting images")
for frame in camera.capture_continuous(rawCapture,
format="bgr",
use_video_port=True):
image = rawCapture.array
num = ogr.process(image)
fv = f.filter(num)
print('Detected number: {:} -- Filtered number: {:}'.format(
num, fv))
rawCapture.truncate(0)
if fv < value:
stepper.run(1000, 1)
else:
stepper.stop()
camera.close()
pass
except Exception as e:
print(e)
print("The scale is probably not on, turn it on and try again")
pass
from machine import Pin, I2C, PWM, Timer
from stepper import Stepper
import utime as time
pin_dir = Pin(14)
pin_step = Pin(13)
pin_en = Pin(0)
steppy = Stepper(pin_en, pin_dir, pin_step)
steppy.on()
steppy.max_speed = 10000
steppy.acc = 5
for i in range(0, 1):
steppy.target = steppy.deg_to_steps(360)
while (steppy.pos != steppy.target):
_ = steppy.run()
#steppy.off()
time.sleep(1.0)
steppy.target = 0
while (steppy.pos != steppy.target):
_ = steppy.run()
#steppy.off()
time.sleep(1.0)
print("Done!")
#pwm = PWM(pin_step)
#
#pwm.freq(1000)
load_config() # Cargamos "config.json"
# Capturamos webcam
print "[START] Preparando cámara...."
camera_recording = False
while camera_recording is not True:
camera = cv2.VideoCapture(0)
time.sleep(1)
# Esperamos a que la cámara esté preparada
camera_recording, _ = camera.read()
print "[DONE] Cámara lista!"
print "[INFO] Inicializamos los motores..."
pan_motor = Stepper("Base", 16, 19, 26)
pan_motor.set_speed(5)
print(pan_motor.print_info())
tilt_motor = Stepper("Top", 16, 6, 13)
tilt_motor.set_speed(5)
print(tilt_motor.print_info())
if test_motors == "True":
motor_test()
# Loop sobre la camara
while True:
# Leemos el primer frame e imprimimos el texto
(video_signal, frame) = camera.read()
def __init__(self):
GPIO.setmode(GPIO.BCM)
self.areas = 16
self.sonicMotor = Stepper()
self.wheels = Wheel()
self.motorPosition = 0 #gibt an ob der SonicMotor links oder rechts steht 0=links
def start(self):
self._setup_logging()
self._setup_api()
self._setup_ignored_pokemon()
self.stepper = Stepper(self)
random.seed()
from stepper import Stepper
from time import sleep
stepper = Stepper()
try:
print "start"
stepper.start()
for i in range(1, 5):
stepper.setSpeed(i * 200)
print i * 200
sleep(1)
print "stop"
stepper.stop()
sleep(.2)
print "flip"
stepper.flipDirection()
stepper.start()
sleep(5)
print "stop"
stepper.stop()
except KeyboardInterrupt:
print("\nCtrl-C pressed. Stopping PIGPIO and exiting...")
finally:
stepper.stop()
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 = 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):
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
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):
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
def start(self):
self._setup_logging()
self._setup_api()
self.stepper = Stepper(self)
random.seed()
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']))
from numpy.random import randint, exponential
from numpy import arange, concatenate
import numpy as np
from pyglet.window import key
try:
from toolbox.toolbox.IO.nidaq import DigitalInput, DigitalOutput, AnalogInput, AnalogOutput
have_nidaq = True
except: # Exception, e:
print("could not import iodaq.")
have_nidaq = False
sys.path.append('C:\github\syringe_pump')
from stepper import Stepper
import time
s = Stepper(mode='arduino', port='COM3', syringe='3mL')
MOUSE_ID = 'm1'
REWARD_VOLUME = 10 #in µL
REWARD_WINDOW = 1.0 #in seconds
try:
opts, args = getopt.getopt(sys.argv, "hi:o:",
["mouse_id=", "reward_volume="])
print(args)
MOUSE_ID = args[1]
REWARD_VOLUME = int(args[2])
REWARD_WINDOW = float(args[3])
print(MOUSE_ID)
print(REWARD_VOLUME)
print(REWARD_WINDOW)
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.set_position()
self.stepper.get_cells()
self.catch_pokemon()
if self.config.spinstop:
self.goto_pokestop()
else:
self.stepper.step()
def catch_pokemon(self):
self.stepper.get_cells()
surrounding_pokemon = ['catchable_pokemons', 'wild_pokemons']
print "seaching for pokemon"
for pokemon_type in surrounding_pokemon:
for cell in self.stepper.cells:
if pokemon_type in cell:
for pokemon in cell[pokemon_type]:
worker = PokemonCatchWorker(pokemon, self)
worker.work()
def goto_pokestop(self):
for cell in self.stepper.cells:
if 'forts' in cell:
for fort in cell['forts']:
if 'type' in fort:
worker = SeenFortWorker(cell, fort, self)
hack_chain = worker.work()
if hack_chain > 10:
print('need a rest')
break
def _setup_logging(self):
self.log = logging.getLogger(__name__)
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(module)10s] [%(levelname)5s] %(message)s')
logging.getLogger("requests").setLevel(logging.WARNING)
logging.getLogger("pgoapi").setLevel(logging.INFO)
logging.getLogger("rpc_api").setLevel(logging.INFO)
def _setup_api(self):
self.api = PGoApi()
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')
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)
