#!/usr/bin/env python3.7

# This is for macOS to play Piano Tiles 2 on BlueStacks.
#   To be specific, I ran this on my Macmini6,1

# You will likely have to change y and tileWidth in this code.

# This code will stop on its own after you lose.
# To prematurely stop Piano Tiles 2, you can press "esc" during run.

# I mostly want to use this on the Master hall,
#   which means that I don't have to worry about programming long clicks for long tiles
#   because time (not score) is important, and I don't have to worry about things
#   like slider tiles!

# For Pianist Challenge...
#   Orange slidey tiles, starburst tiles, and huge multi-click tiles cause problems.
#   Songs that produce sparkly graphics for every tap can cause problems.



# I needed to first do `sudo port install py37-pyobjc` (requires MacPorts)
#   or `sudo pip-3.7 install pyobjc`
import Quartz.CoreGraphics as CG

import struct
import time


# tap mindlessly (True) or intelligently (False)
# Mindless tapping should allow the rare combo (tap-many-times) tiles to be completed
mindlessTaps = False




# start with Piano Tiles 2 (in BlueStacks) on upper-left of screen
# x increases left to right from 0 to width-1 (measured in pixels)
# y increases top to bottom from 0 to height-1 (measured in pixels)

#y = 400
#tileWidth = 101

y = 670
#y = 800
tileWidth = 135

x1 = 15   # don't start at center of tile else long tiles can give problems
x2 = x1 + tileWidth
x3 = x1 + 2*tileWidth
x4 = x1 + 3*tileWidth
region = CG.CGRectMake(x1, y, 3*tileWidth+1, 1)  # 1 screenshot is faster than 4 tiny ones






# since rgb aren't exactly 0 on tiles (partly due to BlueStacks and also due to long tiles),
# set a tolerance that is an integer less than 256
cap = 20



# After how many cycles to stop?
# Set this high if game in BlueStacks often pauses for a few moments.
# I usually don't have to wait for this since the code can stop in other ways.
# Having this is VERY important else you can stuck not being able to use your computer!
stopCounter = 1000


# How long to pause between mouse down and mouse up?
# Increase this value if clicks are not registering. There is some randomness to whether or not they register. For me, it is the game's or Bluestack's or macOS's ability to refresh the screen fast enough ultimately limits me to not going much over 30 tiles/s, so don't worry about making this number a bit too large.
# Decrease this value if counter that is printed at each click is regularly 1.
iPause = 15000


# A pause with more precision but less accuracy than time.sleep()
# On my crappy computer, each iteration takes about 3e-7 seconds.
def pause(n):
  i = 0
  ii = 0.0
  while i<n:
    i += 1
    ii += i%100-50+0.5



# my tap/click function
def clickk(xx,yy):
  CG.CGPostMouseEvent((xx, yy), False, 1, True)   # button down
  pause(iPause)
  CG.CGPostMouseEvent((xx, yy), False, 1, False)   # button up



print("It may be wise to fully restart the Piano Tiles 2 app or BlueStacks!")
print("Put Piano Tiles 2 in BlueStacks on upper-left of screen!")
response = int(input("Where is the start tile (1, 2, 3, or 4)?: "))
if response == 1:
  xs = x1;
elif response == 2:
  xs = x2;
elif response == 3:
  xs = x3;
elif response == 4:
  xs = x4;
else:
  print("script terminating")
  quit()

# select the window then tap the start tile!
clickk(xs,y)
#pause(2000000)
time.sleep(0.5) # seconds
clickk(xs,y)



state = [0,0,0,0]
counter = 0
while counter < stopCounter:

  counter += 1

  # capture screen
  image = CG.CGWindowListCreateImage(region, CG.kCGWindowListOptionOnScreenOnly, CG.kCGNullWindowID, CG.kCGWindowImageDefault)

  # create a string of bytes
  data = CG.CGDataProviderCopyData(CG.CGImageGetDataProvider(image))

  # grab pixel info at (xi,y) coordinates!
  #offset = 4 * ((width*int(round(y))) + int(round(x)))
  b1, g1, r1, a = struct.unpack_from("BBBB", data, offset=0)
  b2, g2, r2, a = struct.unpack_from("BBBB", data, offset=4*tileWidth)
  b3, g3, r3, a = struct.unpack_from("BBBB", data, offset=8*tileWidth)
  b4, g4, r4, a = struct.unpack_from("BBBB", data, offset=12*tileWidth)
  #print((r1, g1, b1), (r2, g2, b2), (r3, g3, b3), (r3, g3, b3))


  stateNow = [0,0,0,0]
  if (r1+g1+b1)/3 < cap:
    stateNow[0]=1;
    if mindlessTaps:
      clickk(x1,y)
  if (r2+g2+b2)/3 < cap:
    stateNow[1]=1;
    if mindlessTaps:
      clickk(x2,y)
  if (r3+g3+b3)/3 < cap:
    stateNow[2]=1;
    if mindlessTaps:
      clickk(x3,y)
  if (r4+g4+b4)/3 < cap:
    stateNow[3]=1;
    if mindlessTaps:
      clickk(x4,y)



  # quit right away if things look weird (because waiting for counter is annoying)
  if sum(stateNow)>2:
    print("More than 2 tiles were found, so quitting!")
    print("This is likely due to the screen going black for a moment at end of game.")
    quit()


  # A minor fix to deal with slow screen update when tapping double tiles.
  if (state==[0,1,0,1] and stateNow==[0,0,0,1]) or (state==[1,0,1,0] and stateNow==[0,0,1,0]):
    stateNow = state
    


  if (stateNow != state and stateNow != [0,0,0,0]):
    print(stateNow, counter)
    counter = 0
    if not mindlessTaps:
      if stateNow[0]:
        clickk(x1,y)
      if stateNow[1]:
        clickk(x2,y)
      if stateNow[2]:
        clickk(x3,y)
      if stateNow[3]:
        clickk(x4,y)


  state = stateNow


print("Timed out!")