text: import numpy
  import numpy as np
  from grabscreen import grab_screen
  import cv2
  import time
  from keys import PressKey, ReleaseKey, W, A, S, D
  from models import inception_v3 as googlenet
  from getKeys import key_check
  from collections import deque, Counter
  import random
  from statistics import mode, mean
  import numpy as np
  from motion import motion_detection
  import grabscreen
  import tensorflow as tf
  
  gpu_devices = tf.config.experimental.list_physical_devices('GPU')
  for device in gpu_devices: tf.config.experimental.set_memory_growth(device, True)
  
  GAME_WIDTH = 1366
  GAME_HEIGHT = 768
  
  how_far_remove = 800
  rs = (20, 15)
  log_len = 25
  
  motion_req = 800
  motion_log = deque(maxlen=log_len)
  
  WIDTH = 1366
  HEIGHT = 768
  LR = 1e-3
  EPOCHS = 10
  
  choices = deque([], maxlen=5)
  hl_hist = 250
  choice_hist = deque([], maxlen=hl_hist)
  
  w = [1, 0, 0, 0, 0, 0, 0, 0, 0]
  s = [0, 1, 0, 0, 0, 0, 0, 0, 0]
  a = [0, 0, 1, 0, 0, 0, 0, 0, 0]
  d = [0, 0, 0, 1, 0, 0, 0, 0, 0]
  wa = [0, 0, 0, 0, 1, 0, 0, 0, 0]
  wd = [0, 0, 0, 0, 0, 1, 0, 0, 0]
  sa = [0, 0, 0, 0, 0, 0, 1, 0, 0]
  sd = [0, 0, 0, 0, 0, 0, 0, 1, 0]
  nk = [0, 0, 0, 0, 0, 0, 0, 0, 1]
  
  t_time = 0.25
  
  
  def straight():
      PressKey(W)
      ReleaseKey(A)
      ReleaseKey(D)
      ReleaseKey(S)
  
  
  def left():
      if random.randrange(0, 3) == 1:
          PressKey(W)
      else:
          ReleaseKey(W)
      PressKey(A)
      ReleaseKey(S)
      ReleaseKey(D)
      # ReleaseKey(S)
  
  
  def right():
      if random.randrange(0, 3) == 1:
          PressKey(W)
      else:
          ReleaseKey(W)
      PressKey(D)
      ReleaseKey(A)
      ReleaseKey(S)
  
  
  def reverse():
      PressKey(S)
      ReleaseKey(A)
      ReleaseKey(W)
      ReleaseKey(D)
  
  
  def forward_left():
      PressKey(W)
      PressKey(A)
      ReleaseKey(D)
      ReleaseKey(S)
  
  
  def forward_right():
      PressKey(W)
      PressKey(D)
      ReleaseKey(A)
      ReleaseKey(S)
  
  
  def reverse_left():
      PressKey(S)
      PressKey(A)
      ReleaseKey(W)
      ReleaseKey(D)
  
  
  def reverse_right():
      PressKey(S)
      PressKey(D)
      ReleaseKey(W)
      ReleaseKey(A)
  
  
  def no_keys():
      if random.randrange(0, 3) == 1:
          PressKey(W)
      else:
          ReleaseKey(W)
      ReleaseKey(A)
      ReleaseKey(S)
      ReleaseKey(D)
  
  
  model = googlenet(WIDTH, HEIGHT, 3, LR, output=9)
  MODEL_NAME = 'model'
  model.load(MODEL_NAME)
  
  print('We have loaded a previous model!!!!')
  
  
  def main():
      last_time = time.time()
      for i in list(range(4))[::-1]:
          print(i + 1)
          time.sleep(1)
  
      paused = False
      mode_choice = 0
  
      screen = numpy.array(grabscreen.printWindow())
      screen = cv2.cvtColor(screen, cv2.COLOR_BGR2RGB)
      prev = cv2.resize(screen, (WIDTH, HEIGHT))
  
      t_minus = prev
      t_now = prev
      t_plus = prev
  
      while (True):
          if not paused:
              screen = numpy.array(grabscreen.printWindow())
              screen = cv2.cvtColor(screen, cv2.COLOR_BGR2RGB)
  
              last_time = time.time()
              screen = cv2.resize(screen, (WIDTH, HEIGHT))
  
              #delta_count_last = motion_detection(t_minus, t_now, t_plus)
  
              cv2.imshow('window', screen)
              if cv2.waitKey(25) & 0xFF == ord('q'):
                  cv2.destroyAllWindows()
                  break
  
              delta_count_last = motion_detection(screen, t_minus, t_now, t_plus)
  
              t_minus = t_now
              t_now = t_plus
              t_plus = screen
              t_plus = cv2.blur(t_plus, (4, 4))
  
              prediction = model.predict([screen.reshape(WIDTH, HEIGHT, 3)])[0]
              prediction = np.array(prediction) * np.array([4.5, 0.1, 0.1, 0.1,  1.8, 1.8, 0.5, 0.5, 0.2])
  
              mode_choice = np.argmax(prediction)
  
              print(mode_choice)
              print(prediction)
              if mode_choice == 0:
                  straight()
                  choice_picked = 'straight'
  
              elif mode_choice == 1:
                  reverse()
                  choice_picked = 'reverse'
  
              elif mode_choice == 2:
                  left()
                  choice_picked = 'left'
              elif mode_choice == 3:
                  right()
                  choice_picked = 'right'
              elif mode_choice == 4:
                  forward_left()
                  choice_picked = 'forward+left'
              elif mode_choice == 5:
                  forward_right()
                  choice_picked = 'forward+right'
              elif mode_choice == 6:
                  reverse_left()
                  choice_picked = 'reverse+left'
              elif mode_choice == 7:
                  reverse_right()
                  choice_picked = 'reverse+right'
              elif mode_choice == 8:
                  no_keys()
                  choice_picked = 'nokeys'
  
              motion_log.append(delta_count_last)
              motion_avg = round(mean(motion_log), 3)
              print('loop took {} seconds. Motion: {}. Choice: {}'.format(round(time.time() - last_time, 3), motion_avg,
                                                                          choice_picked))
  
              if motion_avg < motion_req and len(motion_log) >= log_len:
                  print('WERE PROBABLY STUCK FFS, initiating some evasive maneuvers.')
  
                  # 0 = reverse straight, turn left out
                  # 1 = reverse straight, turn right out
                  # 2 = reverse left, turn right out
                  # 3 = reverse right, turn left out
  
                  quick_choice = random.randrange(0, 4)
  
                  if quick_choice == 0:
                      reverse()
                      time.sleep(random.uniform(1, 2))
                      forward_left()
                      time.sleep(random.uniform(1, 2))
  
                  elif quick_choice == 1:
                      reverse()
                      time.sleep(random.uniform(1, 2))
                      forward_right()
                      time.sleep(random.uniform(1, 2))
  
                  elif quick_choice == 2:
                      reverse_left()
                      time.sleep(random.uniform(1, 2))
                      forward_right()
                      time.sleep(random.uniform(1, 2))
  
                  elif quick_choice == 3:
                      reverse_right()
                      time.sleep(random.uniform(1, 2))
                      forward_left()
                      time.sleep(random.uniform(1, 2))
  
                  for i in range(log_len - 2):
                      del motion_log[0]
  
          keys = key_check()
  
          # p pauses game and can get annoying.
          if 'T' in keys:
              if paused:
                  paused = False
                  time.sleep(1)
              else:
                  paused = True
                  ReleaseKey(A)
                  ReleaseKey(W)
                  ReleaseKey(D)
                  time.sleep(1)
  
  
  main()
  