Tag: work

I wrote Python code to play this scratch game.
However, it is too slow to work properly, as each picture when clicked takes a screenshot of almost the same thing

    ____
_ _ | ______
_ | ______
|

click
Screenshot

____
_ _ | ______
__ | _____
|

And so it clicks again because it thinks it's still deep enough to jump, so it's double dead.

Any ideas on how to improve the speed for it to work?
Here is the code:

#Circle on scratch destroyer
Import numpy as np #Numpy
import screenUtils #My own code, which retrieves the screenshot (no problem, the screenshots are lightning fast)
Sleep, time #sleep for sleep and time for time verification
from pymouse import Click PyMouse #Mouse
PyKeyboardEvent # Failsafe key from the Pykeyboard import is q
From threading, import the #Threading thread for the keyboard input and screenshot loop
m = PyMouse () #Init mouse
jumpHeight = 40 #Ho the player jumps with every click
class safe (PyKeyboardEvent): #I said it was safe because it is fail-safe
def xtra (self):
self.tog = False #Toggle
def tap (self, keycode, character, press):
"" "
Subclass this method with your key event handler. It is obtained
the key code associated with the key event and the string name for
the key if one can be assigned (keyboard mask status will apply). The
Argument & # 39; press & # 39; is true if the key was pressed, and false if the key was pressed
Key was released.
"" "
if self.lookup_char_from_keycode (keycode) == "q" and press: #if the event is a press of the "q" key
self.tog = not self.tog #toggle the screenshot loop
otherwise:
consist
Click = (575, 450) #where on the screen to click
e = safe () #Init Keyboard event handler
extra()
def checkClick (screen):
lineY = [] #The y-axis of all line pixels
circP = [] #The pixels on the right side of the circle
if e.tog: #Only execute when Safegaurd is off
pX = 0 #Pos X
pY = 0 #Pos Y
width = len (screen[0]) #Width of the screenshot
whiteFilter = [] #Init the white filter
for w in the range (width):
whiteFilter.append (np.array ([255,255,255])) # Fill in the white filter
for y in range (len (screen)): # For each Y-layer
if np.array_equal (whiteFilter, screen[y]): # If the layer is white, skip it
#meh
consist
otherwise:
for x in range (len (screen[y])): # For every pixel in this layer
when screen[y][x][0]    > = 30 and screen[y][x][0] <= 50 and screen[y][x][1] >= 50 and screen[y][x][1] <= 65 and screen[y][x][2] >= 130 and screen[y][x][2] <= 150:
                        lineY.append(pY) #Found a line pixel
                    if screen[y][x][0] >= 60 and screen[y][x][0] <= 70 and screen[y][x][1] >= 75 and screen[y][x][1] <= 85 and screen[y][x][2] >= 175 and screen[y][x][2] <= 185:
                        circP.append((pX, pY)) #Found a circle pixel
                    pX += 1 #Increment X pos
            pY += 1 #Increment Y pos
            pX = 0 #Reset X Pos
        pix = [] #Init pix array (this stores all circle pixels at X position 35 of the screenshot)
        for pos in circP:
            if pos[0] == 35:
                pix.append(pos)
        final = []
        found = False
        for p in pix: #This loop gets the two inner pixels of the circle at X position 35
            for P in pix:
                if found == False:
                    if abs(p[1] - P[1]) == 87:
                        final.append(p)
                        final.append(P)
                        found = True
        bottom = () #The bottom pixel
        if len(final) == 2: #Double check the length of final
            try: #Handle random exceptions if you turn off safeguard when not on the game
                if final[0][1] >    final[1][1]: #Finds the bottom pixel
bottom = final[1]
                otherwise:
bottom = final[0]
                if max (lineY) - below[1] > = jumpHeight: #Detect, if the program should click
print ("click")
click on[0], click[1])
except:
consist

def screenLoop ():
while true:
if e.tog:
screen = screenUtils.grab_screen (405.325.468.675) #Screenshot
screena = np.array (screen)
start = time ()
checkClick (screena)
stop = time ()
print ("time:" + str (stop - start))

t = thread (destination = screenLoop)
t.daemon = true
t.start ()
e.run ()